怒刷LeetCode的第11天（Java版）

怒刷LeetCode的第11天（Java版）
目录

第一题

题目来源

题目内容

解决方法

方法一：迭代

方法二：递归

方法三：指针转向

第二题

题目来源

题目内容

解决方法

方法一：快慢指针

方法二：Arrays类的sort方法

方法三：计数器

方法四：额外的数组

第三题

题目来源

题目内容

解决方法

方法一：双指针

方法二：List

方法三：交换元素

方法四：递归

第一题

题目来源

25. K 个一组翻转链表 - 力扣（LeetCode）

题目内容

解决方法

方法一：迭代

题目描述中要求将链表每 k 个节点作为一组进行翻转。这是一个比较经典的链表问题，可以使用迭代的方法来解决。具体思路如下：
1. 首先定义两个指针 prev 和 curr，分别指向当前组的前一个节点和当前节点。
2. 使用一个计数器 count 来记录当前组中已经遍历的节点数目。
3. 遍历链表，对于每个节点 curr：
  - 将 curr 的下一个节点保存到 next。
  - 如果 count 等于 k，则说明当前组内的节点已经遍历完毕，需要进行翻转。具体操作如下：
    调用 reverse 函数对 prev 和 curr 之间的节点进行翻转，返回翻转后的头节点，并将它赋值给新的 prev。
    将翻转后的最后一个节点的 next 指向 next，即连接下一组的头节点。
    更新 curr 和 prev，将它们都指向 next。
    将 count 重置为 0，表示下一组的遍历开始。
  - 如果 count 不等于 k，则说明当前组内的节点还未满 k 个，继续遍历下一个节点。
  - 将 curr 更新为 next，继续遍历下一个节点。
  - 将 count 增加 1。
4. 返回翻转后的链表头节点。
```
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode prev = dummy;
    ListNode curr = head;
    int count = 0;
 
    while (curr != null) {
        count++;
        ListNode next = curr.next;
        if (count == k) {
            prev = reverse(prev, next);
            count = 0;
        }
        curr = next;
    }
 
    return dummy.next;
}
 
private ListNode reverse(ListNode start, ListNode end) {
    ListNode prev = start;
    ListNode curr = start.next;
    ListNode first = curr;
 
    while (curr != end) {
        ListNode next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
 
    start.next = prev;
    first.next = curr;
    return first;
}
 
}
```
复杂度分析：

时间复杂度分析：
- 遍历链表需要 O(n) 的时间，其中 n 是链表的长度。
- 在每个节点组内进行翻转操作时，需要遍历 k 个节点，即 O(k) 的时间复杂度。
- 总共有 n/k 个节点组，所以翻转操作的总时间复杂度是 O((n/k) * k) = O(n)。
因此，总的时间复杂度是 O(n)。

空间复杂度分析：
- 我们只使用了常数级别的额外空间，例如指针变量和辅助节点。
- 因此，空间复杂度是 O(1)。
综上所述，该解法的时间复杂度为 O(n)，空间复杂度为 O(1)。

LeetCode运行结果：

方法二：递归

除了迭代的解法，还可以使用递归的思路来实现链表的翻转。

具体的递归思路如下：
1. 定义一个函数 reverseKGroupRecursive，其功能是将以 head 为头节点的链表每 k 个节点进行翻转，并返回翻转后的链表的头节点。
2. 首先遍历链表，找到第 k+1 个节点 next。
  - 如果 next!=null，说明当前组内有至少 k 个节点，可以进行翻转操作。
    调用 reverse 函数对以 head 为头节点、以 next 为尾节点的子链表进行翻转，并将翻转后的尾节点返回，将其赋值给 newHead。
    将 head 的 next 指针指向下一组的头节点，即调用 reverseKGroupRecursive(next, k)。
    返回 newHead，作为翻转后的链表的头节点。
  - 如果 next==null，说明剩余的节点数少于 k 个，无需翻转，直接返回 head。
```
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
    ListNode curr = head;
    int count = 0;
 
    while (curr != null && count < k) {
        curr = curr.next;
        count++;
    }
 
    if (count == k) {
        ListNode newHead = reverseKGroupRecursive(head, curr, k);
        head.next = reverseKGroup(curr, k);
        return newHead;
    }
 
    return head;
}
 
private ListNode reverseKGroupRecursive(ListNode head, ListNode tail, int k) {
    ListNode prev = tail;
    ListNode curr = head;
 
    while (curr != tail) {
        ListNode next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
 
    return prev;
}
 
}
```
复杂度分析：

时间复杂度分析：
- 遍历链表需要 O(n) 的时间，其中 n 是链表的长度。
- 递归调用了 n/k 次，每次都需要翻转 k 个节点，因此每次递归操作的时间复杂度是 O(k)。
- 整个算法的时间复杂度是 O((n/k) * k) = O(n)。
因此，总的时间复杂度是 O(n)。

空间复杂度分析：
- 递归的深度是 n/k，因此递归调用栈的最大深度是 O(n/k)。
- 每次递归操作需要常数级别的额外空间，例如指针变量和辅助节点。
- 因此，空间复杂度是 O(n/k)，在最坏情况下为 O(n)。需要注意的是，在实际使用中链表长度较大时，递归方法可能会导致递归调用栈溢出。
综上所述，递归解法的时间复杂度为 O(n)，空间复杂度为 O(n/k)（在最坏情况下为 O(n)）。

需要注意的是，递归方法对于链表长度较大时可能会导致递归调用栈溢出，因此在实际使用中需要注意链表长度是否适合使用递归解法。

LeetCode运行结果：

方法三：指针转向

除了迭代、递归的方法，还可以使用指针转向的思路来实现链表的翻转。
```
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null || k <= 1) {
            return head;
        }
 
        ListNode dummy = new ListNode(0); // 创建一个虚拟头节点
        dummy.next = head;
        ListNode prev = dummy;
 
        while (head != null) {
            ListNode tail = prev;
            
            // 判断剩余节点数是否大于等于 k
            for (int i = 0; i < k; i++) {
                tail = tail.next;
                if (tail == null) {
                    // 剩余的节点数不满 k 个，直接返回结果
                    return dummy.next;
                }
            }
 
            ListNode nextGroupHead = tail.next; // 下一组节点的头节点
 
            // 翻转当前组内的节点
            ListNode[] reversed = reverse(head, tail);
            head = reversed[0];
            tail = reversed[1];
 
            // 将翻转后的组连接到结果链表中
            prev.next = head;
            tail.next = nextGroupHead;
            
            // 更新 prev 和 head，准备处理下一组
            prev = tail;
            head = nextGroupHead;
        }
 
        return dummy.next;
    }
 
    private ListNode[] reverse(ListNode head, ListNode tail) {
        ListNode prev = tail.next;
        ListNode curr = head;
 
        while (prev != tail) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
 
        return new ListNode[] {tail, head};
    }
}
```
该方法通过指针转向的方式，每次翻转一组的节点。其中，reverse 方法用于翻转当前组内的节点。

复杂度分析：

时间复杂度分析：
- 翻转一组的时间复杂度为 O(k)，其中 k 是每组节点的数量。
- 对于包含 n 个节点的链表，一共有 n/k 组需要翻转。
- 因此，总的时间复杂度为 O((n/k) * k) = O(n)。
空间复杂度分析：
- 空间复杂度取决于额外使用的变量和递归调用栈的空间。
- 额外使用的变量有 dummy、prev、tail 和 nextGroupHead，它们占用的空间是常数级别的，因此不会随着输入规模 n 的增加而增加。
- 在递归实现中，递归调用栈的深度最多为 n/k，因为总共有 n/k 组需要翻转。
- 因此，递归调用栈的空间复杂度为 O(n/k)。
- 综上所述，总的空间复杂度为 O(1)。
综合来说，该方法的时间复杂度为 O(n)，空间复杂度为 O(1)。需要注意的是，在处理不满 k 个节点的情况时，需要额外判断并返回结果。

LeetCode运行结果：

第二题

题目来源

26. 删除有序数组中的重复项 - 力扣（LeetCode）

题目内容

解决方法

方法一：快慢指针

由于数组已经按非严格递增排列，可以利用快慢指针来遍历数组。慢指针指向当前不重复的元素，快指针用于遍历整个数组。如果快指针指向的元素与慢指针指向的元素不同，说明找到了一个新的不重复元素，将其存放在慢指针的下一个位置，并将慢指针后移一位。最后返回慢指针加1即可。
```
class Solution {
public int removeDuplicates(int[] nums) {
    if(nums.length == 0){
        return 0;
    }
    int i = 0;
    for(int j = 1; j < nums.length; j++){
        if(nums[i] != nums[j]){
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}
 
}
```
复杂度分析：
- 时间复杂度：O(n)，其中n为数组的长度。该算法通过使用快慢指针，只需一次遍历数组即可完成操作。
- 空间复杂度：O(1)。该算法只使用了常数级的额外空间，不随输入规模的增加而增加。
LeetCode运行结果：

方法二：Arrays类的sort方法

除了使用快慢指针的解法外，在Java中还可以使用Arrays类的sort方法来解决该问题。

该方法首先对数组进行排序，使得重复元素相邻。然后使用快慢指针的方法遍历数组，将不重复的元素放到慢指针所指向的位置，并移动慢指针。最后返回慢指针加1作为新数组的长度。
```
class Solution {
public int removeDuplicates(int[] nums) {
    Arrays.sort(nums);
    int i = 0;
    for (int j = 1; j < nums.length; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}
 
}
```
复杂度分析：
- 时间复杂度：O(n log n)，其中n为数组的长度。排序需要O(n log n)的时间复杂度，遍历数组需要O(n)的时间复杂度。
- 空间复杂度：O(1)，原地修改数组，不需要额外的空间。
LeetCode运行结果：

方法三：计数器

除了前面提到的思路和方法，还可以使用一个计数器来记录重复元素的个数，并根据计数器的值进行相应的操作。
1. 该方法使用count变量来记录数组中不重复元素的个数，duplicateCount变量来记录重复元素的个数。
2. 遍历数组时，如果当前元素与前一个元素相同，则将duplicateCount加1；否则将count加1。
3. 同时，如果duplicateCount大于0，则将当前元素向前移动duplicateCount个位置，相当于删除了重复元素。
4. 最后返回count作为新数组的长度。
```
class Solution {
public int removeDuplicates(int[] nums) {
    if (nums.length == 0) {
        return 0;
    }
    
    int count = 1;
    int duplicateCount = 0;
    
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] == nums[i - 1]) {
            duplicateCount++;
        } else {
            count++;
        }
        
        if (duplicateCount > 0) {
            nums[i - duplicateCount] = nums[i];
        }
    }
    
    return count;
}
 
}
```
复杂度分析：
- 时间复杂度：O(n)，其中n为数组的长度。需要遍历整个数组一次。
- 空间复杂度：O(1)，原地修改数组，不需要额外的空间。
在遍历数组时，只有在出现重复元素时才会对数组进行修改。对数组的修改是通过将重复元素向前移动来实现的，而不是删除重复元素。因此，不需要额外的空间来存储删除后的新数组。这种方法的空间复杂度是常数级别的。

综上所述，使用计数器的解法是一种高效的解决方案，具有线性的时间复杂度和常数级别的空间复杂度。

LeetCode运行结果：

方法四：额外的数组

除了之前提到的思路和方法，还可以使用额外的数组来存储不重复的元素。

该方法创建一个新的数组uniqueNums，用于存储不重复的元素。遍历原始数组时，如果当前元素与前一个元素不相同，则将当前元素添加到uniqueNums数组中，并将计数器count加1。最后，将uniqueNums数组中的元素赋值回原数组nums，并返回count作为新数组的长度。
```
class Solution {
public int removeDuplicates(int[] nums) {
    if (nums.length == 0) {
        return 0;
    }
    
    int[] uniqueNums = new int[nums.length];
    
    uniqueNums[0] = nums[0];
    int count = 1;
    
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] != nums[i - 1]) {
            uniqueNums[count] = nums[i];
            count++;
        }
    }
    
    // 将uniqueNums数组中的元素赋值回原数组
    for (int i = 0; i < count; i++) {
        nums[i] = uniqueNums[i];
    }
    
    return count;
}
 
}
```
复杂度分析：
- 时间复杂度：O(n)，其中n为数组的长度。需要遍历整个数组一次，并进行一次数组元素的复制操作。
- 空间复杂度：O(n)，因为需要使用额外的数组来存储不重复的元素。
在遍历原始数组时，只有在出现与前一个元素不相同的元素时才将其添加到新数组中。因此，新数组的长度最多为原数组的长度，即使用了额外的O(n)空间。

综上所述，使用额外数组的解法是一种线性时间复杂度的解决方案，但需要额外的空间来存储新的数组。这种方法适用于不要求原地修改数组的情况。

LeetCode运行结果：

第三题

题目来源

27. 移除元素 - 力扣（LeetCode）

题目内容

解决方法

方法一：双指针

这道题可以使用双指针的方法来解决。定义两个指针：慢指针slow和快指针fast。

算法的思路如下：
1. 初始化慢指针slow为0。
2. 遍历数组，如果当前元素nums[fast]等于给定值val，则快指针fast向前移动一步，跳过该元素。
3. 如果当前元素nums[fast]不等于给定值val，则将nums[fast]赋值给nums[slow]，同时慢指针slow向前移动一步。
4. 重复步骤2和步骤3，直到快指针fast遍历完整个数组。
5. 返回慢指针slow的值。
```
class Solution {
public int removeElement(int[] nums, int val) {
    int slow = 0;
    for (int fast = 0; fast < nums.length; fast++) {
        if (nums[fast] != val) {
            nums[slow] = nums[fast];
            slow++;
        }
    }
    return slow;
}
 
}
```
复杂度分析：
- 时间复杂度：遍历数组所需的时间为 O(n)，其中 n 是数组的长度。在每次遍历时，只有快指针需要移动，而慢指针最多移动了 n 次。因此，整个算法的时间复杂度为 O(n)。
- 空间复杂度：该算法使用了常数个额外变量，不随输入规模 n 变化，因此空间复杂度为 O(1)。无论输入数组的长度如何，算法都只需要固定的额外空间。
综上所述，该算法的时间复杂度为 O(n)，空间复杂度为 O(1)。

LeetCode运行结果：

方法二：List

除了双指针的方法，还可以使用 Java 中的 List 来解决这个问题。具体的做法如下：
1. 创建一个 List 集合（例如 ArrayList）来存储不等于给定值val的元素。
2. 遍历数组，如果当前元素nums[i]不等于给定值val，则将其添加到 List 中。
3. 将 List 转换为数组并返回。
```
class Solution {
public int removeElement(int[] nums, int val) {
    List list = new ArrayList<>();
    for (int num : nums) {
        if (num != val) {
            list.add(num);
        }
    }
    Integer[] arr = list.toArray(new Integer[list.size()]);
    for (int i = 0; i < arr.length; i++) {
        nums[i] = arr[i];
    }
    return list.size();
}
 
}
```
这种方法的本质是通过使用 List 集合来存储不等于给定值val的元素，然后将 List 转换为数组并重新赋值给原数组。最后返回 List 的大小即为移除元素后的新长度。

复杂度分析：

时间复杂度：
1. 遍历数组并将不等于给定值val的元素添加到 List，时间复杂度为 O(n)，其中 n 是数组的长度。
2. 将 List 转换为数组，需要遍历 List 中的元素，时间复杂度同样为 O(n)。
综上所述，整个算法的时间复杂度为 O(n)。

空间复杂度：
1. 创建了一个大小为 n 的 List 来存储不等于给定值val的元素，占用了额外的 O(n) 空间。
2. 将 List 转换为数组时，需要创建一个新的数组，大小为 List 的大小，同样占用了额外的 O(n) 空间。
综上所述，整个算法的空间复杂度为 O(n)。

相比之下，双指针和的方法在空间复杂度上是优于使用 List 的方法的，因为它只需要常数个额外变量，即空间复杂度为 O(1)。因此，建议使用双指针的方法来解决这个问题，以获得更好的空间效率。

LeetCode运行结果：

方法三：交换元素

除了双指针、List，还可以使用交换元素的思路来解决这个问题。具体的做法如下：
1. 初始化两个指针i和j，初始值分别为0和数组长度-1。
2. 循环移动指针i，直到找到第一个等于给定值val的元素。
3. 循环移动指针j，直到找到第一个不等于给定值val的元素。
4. 如果i小于j，则将元素nums[j]赋值给nums[i]，并将指针i和j分别加1和减1。
5. 重复步骤2到步骤4，直到i大于等于j。
6. 返回指针i，即为移除元素后的新长度。
```
class Solution {
public int removeElement(int[] nums, int val) {
    int i = 0;
    int j = nums.length - 1;
    while (i <= j) {
        while (i <= j && nums[i] != val) {
            i++;
        }
        while (i <= j && nums[j] == val) {
            j--;
        }
        if (i < j) {
            nums[i] = nums[j];
            i++;
            j--;
        }
    }
    return i;
}
 
}
```
这种交换元素的方法通过使用两个指针分别从头尾向中间移动，并通过交换元素的方式来实现移除元素的目的。

复杂度分析：
- 时间复杂度：使用两个指针分别从头尾向中间移动，最坏情况下需要遍历整个数组，时间复杂度为 O(n)，其中 n 是数组的长度。
- 空间复杂度：这种方法只使用常数个额外变量，即空间复杂度为 O(1)。
综上所述，使用交换元素的方法的时间复杂度为 O(n)，空间复杂度为 O(1)。与双指针的方法相比，交换元素的方法具有相同的时间复杂度，但空间复杂度更低，因为不需要额外的数据结构（如 List）来存储元素。从空间效率的角度来看，交换元素的方法是较优的选择。

LeetCode运行结果：

方法四：递归

除了双指针、交换元素和使用 List 的方法，还可以利用递归来解决这个问题。具体的做法如下：
1. 编写一个递归函数，传入当前遍历到的索引位置和计数器 count。
2. 在递归函数中，判断当前遍历到的元素是否等于给定值 val：
  - 如果相等，则将计数器 count 加1，并调用递归函数继续处理下一个元素。
  - 如果不相等，则将当前元素覆盖掉索引位置 count，并调用递归函数处理下一个元素。
3. 递归函数的终止条件是遍历完整个数组，返回计数器 count 的值。
4. 在主函数中，调用递归函数，传入初始索引0和计数器初始值0。
```
class Solution {
public int removeElement(int[] nums, int val) {
    return removeElementRecursive(nums, val, 0, 0);
}
 
private int removeElementRecursive(int[] nums, int val, int index, int count) {
    if (index == nums.length) {
        return count;
    }
    if (nums[index] != val) {
        nums[count] = nums[index];
        count++;
    }
    return removeElementRecursive(nums, val, index + 1, count);
}
 
 
}
```
这种递归的方法通过逐个处理数组元素，将不等于给定值 val 的元素覆盖到数组的前部分，从而实现移除元素的目的。

复杂度分析：
- 时间复杂度：递归函数需要遍历整个数组，因此时间复杂度取决于数组的长度，为 O(n)，其中 n 是数组的大小。
- 空间复杂度：递归调用会占用一定的栈空间，最坏情况下递归深度为 n，因此空间复杂度为 O(n)。
综上所述，使用递归的方法的时间复杂度为 O(n)，空间复杂度为 O(n)。

需要注意的是，递归方法的空间复杂度相对较高，因为每次递归调用都需要在栈上保存一些信息。在处理大规模数组时，可能会导致栈溢出。因此，如果要处理大规模数组，建议使用其他方法，如双指针或交换元素的方法，以保证较低的空间开销。

LeetCode运行结果：
相关阅读:
React useContext
《工程伦理与学术道德》之《工程活动中的环境伦理》
基于python+Django+SVM算法模型的文本情感识别系统
 mysql迁移以及迁移后配置文件的编写
 文件系统(七)：文件系统崩溃一致性、方法、原理与局限
 virtualbx_vagrant
谷歌版ChatGPT与旗下邮箱、视频、地图等，实现全面集成！
合同法重点笔记经典版
 【C++】模拟实现STL容器：list
Python if-for-while使用
原文地址：https://blog.csdn.net/m0_74293254/article/details/133149416

第一题

题目来源

题目内容

解决方法

方法一：迭代

方法二：递归

方法三：指针转向

第二题

题目来源

题目内容

解决方法

方法一：快慢指针

方法二：Arrays类的sort方法

方法三：计数器

方法四：额外的数组

第三题

题目来源

题目内容

解决方法

方法一：双指针

方法二：List

方法三：交换元素

方法四：递归