LeetCode题解——数组、链表、跳表

最新推荐文章于 2024-05-25 18:58:57 发布

yxin185

最新推荐文章于 2024-05-25 18:58:57 发布

阅读量298

点赞数

分类专栏： LeetCode题解归类文章标签： leetcode 数据结构

本文链接：https://blog.csdn.net/yx185/article/details/104150188

版权

LeetCode题解归类专栏收录该内容

5 篇文章 0 订阅

订阅专栏

如有问题，敬请指正！
最近做的一些LeetCode题目的解答，参考了题解部分内容。

283.移动零

1. 解法一

class Solution {
    // 将非零元素全部移动到前面，后面直接用0来填充
    public void moveZeroes(int[] nums) {
        if (nums == null || nums.length == 0) return;

        int insertPos = 0;
        for (int num : nums) {
            if (num != 0) nums[insertPos ++] = num;
        }

        while (insertPos < nums.length) {
            nums[insertPos ++] = 0;
        }
    }
}

2.解法二

class Solution {
    // 记录第一个0出现的位置，然后和后面不是0的元素进行交换位置
    public void moveZeroes(int[] nums) {
        int k = 0;
        for (int i = 0;i < nums.length;i ++) {
            if (nums[i] != 0) {
                swap(nums, i, k ++);
            }
        }
    }

    private void swap(int[] arr, int i, int j) {
        if (i == j) return;
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

70.爬楼梯

1.解法一：记忆化递归、剪枝

class Solution {
    private int[] memo; // 初始化一个记忆数组
    public int climbStairs(int n) {
        // 使用记忆化递归方法
        if (n <= 1) return 1;
        memo = new int[n + 1];
        memo[0] = 1;
        memo[1] = 1;
        int res = helper(n);
        return res;
    }

    private int helper(int n) {
        if (n <= 1) return memo[n];
        // 如果这个数出现过，就直接返回值；否则记录下来，然后递归操作
        if (memo[n] != 0) 
            return memo[n];
        else {         
            memo[n] = helper(n - 1) + helper(n - 2);
            return memo[n];
        }
            
    }
}

2.解法二：动态规划

class Solution {
	// 动态规划，自底向上递推
    public int climbStairs(int n) {
        if (n <= 1) return 1;
        int[] memo = new int[n + 1];
        memo[0] = 1;
        memo[1] = 1;
        for (int i = 2;i <= n;i ++) {
            // 递归公式
            memo[i] = memo[i - 1] + memo[i - 2];
        }
        return memo[n];
    }
}

11.盛最多水的容器

1.解法一

class Solution {
    public int maxArea(int[] height) {
        if (height == null || height.length == 0) return 0;
        // 设计两个指针，一前一后
        int i = 0, j = height.length - 1;
        int res = 0;
        int area = 0;
        while (i < j) {
            area = Math.min(height[i], height[j]) * (j - i);
            res = Math.max(res, area);
            // 只有往大的一边移动才可能出现更大的面积
            if (height[i] < height[j]) {
                i ++;
            } else {
                j --;
            }
        }
        return res;
    }
}

15.三数之和

1.解法一

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if (nums == null || nums.length < 3) 
            return res;
        // 需要先对数组进行排序
        Arrays.sort(nums);
        for (int i = 0;i < nums.length - 2; i ++) {
            // 如果最小的数大于0，则直接跳出，不可能得到结果为0了
            if (nums[i] > 0) break;
            if (i > 0 && nums[i] == nums[i - 1]) continue;
            int L = i + 1, R = nums.length - 1;
            while (L < R) {
                int sum = nums[i] + nums[L] + nums[R];
                if (sum == 0) {
                    res.add(Arrays.asList(nums[i], nums[L], nums[R]));
                    // 去重
                    while (L < R && nums[L] == nums[L + 1]) L ++;
                    while (L < R && nums[R] == nums[R - 1]) R --;
                    // 还需要再跳一步
                    L ++;
                    R --;
                } else if (sum < 0) {
                    // 结果不够大
                    L ++;
                } else {         
                    // 结果不够小           
                    R --;
                }
            }   
        }
        return res;
    }
}

2.解法二

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if (nums == null || nums.length < 3) 
            return res;
        // 需要先对数组进行排序
        Arrays.sort(nums);
        for (int i = 0;i < nums.length - 2;i ++) {
            // 对第一个元素进行去重
            if (i == 0 || (i > 0 && nums[i] != nums[i - 1])) {
                int L = i + 1, R = nums.length - 1;
                // 避免解法一中每一次while循环都新建一个目标数
                int target = 0 - nums[i];
                while (L < R) {
                    if (target == nums[L] + nums[R]) {
                        res.add(Arrays.asList(nums[i], nums[L], nums[R]));
                        while (L < R && nums[L] == nums[L + 1]) L ++;
                        while (L < R && nums[R] == nums[R - 1]) R --;
                        L ++;
                        R --;
                    } else if (target < nums[L] + nums[R]) {
                        R --;
                    } else {
                        L ++;
                    }
                }
            }
        }
        return res;
    }
}

206.反转链表（背住）

1.解法一：迭代

class Solution {
    public ListNode reverseList(ListNode head) {
        // 记录前一个节点
        ListNode prev = null;
        // 当前节点
        ListNode curr = head;
        while (curr != null) {
            // 因为要往后遍历，所以要记录一下当前节点的下一个节点
            ListNode next = curr.next;
            curr.next  = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}

2.解法二：递归

class Solution {
    public ListNode reverseList(ListNode head) {
        // 递归终止条件
        if (head == null || head.next == null) return head;

        ListNode prev = reverseList(head.next);
        head.next.next = head;
        head.next = null; // 自身顺序指向下一个节点置为空
        return prev;
    }
}

24.两两交换链表中的节点

1.解法一：迭代法

class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) return head;

        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode prev = dummy;
        while (head != null && head.next != null) {
            prev.next = head.next;
            head.next = head.next.next;
            prev.next.next = head;

            prev = prev.next.next;
            head = head.next;
        }
        return dummy.next;
    }
}

1.画图解：

在这里插入图片描述

2.解法二：递归

class Solution {
    public ListNode swapPairs(ListNode head) {
        // 递归终止条件
        if (head == null || head.next == null) return head;

        ListNode next = head.next;
        head.next = swapPairs(next.next);
        next.next = head;

        return next;
    }
}

1.画图解：

递归就是将大问题分解为小问题，在这里就是假设现在只有三部分了，将这三部分重新排序就可以得到新的逆序链表

在这里插入图片描述

141.环形链表

1.解法一：快慢指针

如果在链表中存在环，慢指针一次走一步，快指针一次走两步，快指针总会追上慢指针。

public class Solution {
    // 使用快慢指针
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) return false;
        ListNode slow = head;
        ListNode fast = head.next;
        while (fast != null) {           
            if (slow.val == fast.val) {
                return true;
            }
            slow = slow.next;
            // 这个地方容易出现空指针异常
            if (fast.next != null)
                fast = fast.next.next;
            else 
                return false;
        }
        return false;
    }
}

// 下面的双指针更加简洁
public class Solution {
    // 使用快慢指针
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) return false;
        ListNode slow = head;
        ListNode fast = head.next;
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return true;
    }
}

// 简洁
public class Solution {  
    public boolean hasCycle(ListNode head) {
        if (head == null) return false;
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) return true;
        }
        return false;
    }
}

在第13行进行的判断是因为，快指针一次走两步，如果不先判断fast.next 是否为空，就直接进行fast.next.next 操作，可能就会出现null.next 即空指针异常；
加一个判断，如果出现fast.next == null 的情况，说明链表已经遍历完了，还没有发现环，则说明这个链表没有环。

1.时间复杂度：O(n)

2.空间复杂度：O(1)

2.解法二：哈希表

使用一个 HashSet 来存储遍历过的头结点 head，如果这个头结点已经计算过，说明存在环
时间空间复杂度都为 O(n)，但是在 LeetCode 中效率远低于快慢指针

public class Solution {  
    public boolean hasCycle(ListNode head) {
        Set<ListNode> nodeSet = new HashSet<>();
        while (head != null) {
            if (nodeSet.contains(head)) {
                return true;
            } else {
                nodeSet.add(head);
                head = head.next;
            }
        }
        return false;
    }
}

142.环形链表2

1. 解法一：哈希表

使用额外空间并且效率很低。时空复杂度都为 O(n)

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null || head.next == null) return null;
        Set<ListNode> set = new HashSet<>();
        while (head != null) {
            // 判断一下这个头结点出现过没有，如果出现过，则环肯定是在这个位置环上的
            if (set.contains(head)) {
                return head;
            }
            // 将遍历过的头结点放入一个set集合
            set.add(head);
            head = head.next;       
        }
        return null;
    }
}

2.解法二:Floyd算法

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null || head.next == null) return null;
        // 首先判断有没有环，有环的话记录一下快慢指针第一次相遇的节点
        ListNode slow = head;
        ListNode fast = head;
        ListNode meet = null;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                meet = fast;
                break;
            }
        }

        // 这个条件判断是否有环，如果没有环就返回空
        if (meet == null) {
            return null;
        }        

        // 有环就要进入下一步
        ListNode ptr1 = head;
        while (ptr1 != meet) {
            ptr1 = ptr1.next;
            meet = meet.next;
        }

        return meet;
    }
}

1.时间复杂度 O(n)，因为引入常数个数指针，所以空间复杂度 O(1)

2.分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e4Fzlq8l-1580651913729)(F:\Java视频\极客时间-算法训练营\题解\pic\142-2.jpg)]

首先慢指针一次移动一步，快指针一次移动两步；
如果有环，两个指针第一次相遇于点 h

此时可以得到如下公式

2 * Distance(slow) = Distance(fast)
2 * (F + a) = F + a + b + a
F = b

所以，从第一次相遇的点 h 和头结点开始，一次移动一个位置，两个指针会在环的入口处相遇

25.K个一组翻转链表

1.解法一

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (k == 1) return head;
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode prev = dummy, end = dummy;
        while (end.next != null) {
            for (int i = 0;i < k && end != null;i ++) end = end.next;
            if (end == null) break;
            ListNode start = prev.next;
            ListNode next = end.next;
            end.next = null; // 将前面链表和后面链表断开，next当成一个新的链表头
            prev.next = reverse(start);
            start.next = next;
		   // 更新 prev和start，开始下一次翻转	
            prev = start;
            end = prev;
        }
        return dummy.next;
    }

    // 翻转一个链表，返回这个链表的链表头
    private ListNode reverse(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode next  = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}

26.删除排序数组中的重复项

1.解法一：双指针

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        int i = 0;
        for (int j = 1;j < nums.length;j ++) {
            // 用不重复的项去覆盖第一个重复的项
            if (nums[j] != nums[i]) {
                i ++;
                nums[i] = nums[j];
            }
        }
        return i + 1;
    }
}

2.解法二

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        int count = 0; // count 记录的是在当前索引指向的位置之前有多少个重复的元素，所有重复的元素
        for (int i = 1;i < nums.length;i ++) {
            if (nums[i] == nums[i - 1]) count ++;
            else nums[i - count] = nums[i];
        }
        return nums.length - count;
    }
}

189.旋转数组

1.解法一

时间复杂度和空间复杂度都为 O(n)，且没有达到题目要求的原地算法。就是单纯的重新新建一个数组进行辅助

class Solution {
    public void rotate(int[] nums, int k) {
        // 最笨的方法
        if (nums == null || nums.length <= 1) return;
        k = k % nums.length;
        int[] aux = new int[nums.length];
        for (int i = 0;i < nums.length;i ++) {
            aux[ (i+k) % nums.length ] = nums[i];
        }
        for (int i = 0;i < aux.length;i ++) {
            nums[i] = aux[i];
        }
    }
}

2.解法二：使用反转

这个方法基于事实：当我们旋转一个数组 k 次， k % n 个尾部元素会被移动到头部，剩下的元素会被向后移动。在这个方法中，我们首先将所有元素反转。然后反转前 k 个元素，再反转后面 n-kn−k 个元素，就能得到想要的结果。

假设 n = 7, k = 3
```
原始数组                  : 1 2 3 4 5 6 7
反转所有数字后             : 7 6 5 4 3 2 1
反转前 k 个数字后          : 5 6 7 4 3 2 1
反转后 n-k 个数字后        : 5 6 7 1 2 3 4 --> 结果
```

class Solution {
    public void rotate(int[] nums, int k) {
        int L = nums.length;
        if (nums == null || L <= 1) return;
        k = k % L;
        reverse(nums, 0, L - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, L - 1);
    }

    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int tmp = nums[start];
            nums[start] = nums[end];
            nums[end] = tmp;
            end --;
            start ++;
        }
    }
}

3.解法三：环状数组(未做)

将数组元素直接放在他的最终的位置上，但这会导致放的位置的老元素被覆盖，所以需要处理的就是保存这个老元素，将这个老元素放在他该在的位置上。

21.合并两个有序链表

1.解法一：双指针，其实也是一种归并的思想，不容易造成栈溢出

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(-1);
        ListNode prev = dummy;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            // 将每一个节点连接起来
            prev = prev.next;
        }
        // 确保两个链表都被遍历完了，可以进行优化
        while (l1 != null) {
            prev.next = l1;
            l1 = l1.next;
            prev = prev.next;
        }
        while (l2 != null) {
            prev.next = l2;
            l2 = l2.next;
            prev = prev.next;
        }
        return dummy.next;
    }
}

2.对解法一后半部分的优化

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(-1);
        ListNode prev = dummy;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }
        // 如果 l1 短，则返回l2
        // 如果 l1 不短（要么长，要么相等），则返回 l1 就行
        prev.next = l1 == null ? l2 : l1;
        return dummy.next;
    }
}

3.解法三：递归

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // 递归终止条件
        if (l1 == null) {
            return l2;
            // 递归终止条件
        } else if (l2 == null) {
            return l1;
            // 如果两个都不为空，就可以判断l1的下一个节点了
            // l1的下一个节点其实就是l1.next和l2合并之后返回的头结点
            // 连接好后就可以返回l1了
        } else if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
            // 同上
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

88.合并两个有序数组

1.解法一

1.时间复杂度O(m + n)

2.空间复杂度O(nums1.length)

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        // 还是使用两个指针来完成
        // 先使用额外空间
        int[] aux = new int[nums1.length];
        int p1 = 0, p2 = 0, count = 0;
        while (p1 < m && p2 < n) {
            // if (nums1[p1] <= nums2[p2]) {
            //     aux[count ++] = nums1[p1];
            //     p1 ++;
            // } else {
            //     aux[count ++] = nums2[p2];
            //     p2 ++;
            // }
            aux[count ++] = (nums1[p1] < nums2[p2]) ? aux[count ++] = nums1[p1 ++] : aux[count ++] = nums2[p2 ++];
        }
        while (p1 < m) {
            aux[count ++] = nums1[p1 ++];
        }
        while (p2 < n) {
            aux[count ++] = nums2[p2 ++];
        }
        for (int i = 0;i < aux.length;i ++) {
            nums1[i] = aux[i];
        }
    }
}

2.解法二：从后往前遍历，优化空间复杂度为 O(1)

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        // 从后往前遍历，节省空间
        int len1 = m - 1;
        int len2 = n - 1;
        int len = m + n - 1;
        // 在可以移动的范围内把大数全部放到nums1的末尾
        while (len1 >= 0 && len2 >= 0) {
            nums1[len --] = nums1[len1] > nums2[len2] ? nums1[len1 --] : nums2[len2 --];
        }
        // 因为最后是把所有数合并到nums1中
        // 为了避免nums2中还有数没有进行合并，需要把nums2中还没有合并的数拷贝到nums1中
        // 比如nums1 = {4,5,6,7,0,0,0}
        // nums2 = {1,2,3}
        System.arraycopy(nums2, 0, nums1, 0, len2 + 1);
    }
}

66.加一

1.解法一

class Solution {
    public int[] plusOne(int[] digits) {
        int carry = 0;
        for (int i = digits.length - 1;i >= 0; i --) {
            // 如果小于9，说明不会有进位
            // if (digits[i] < 9) {
            //     digits[i] ++ ;
            //     return digits;
            // 如果等于9，那么就有进位，再接着计算前面一位
            // } else {
            //     digits[i] = 0;
            //     carry = 1;
            // }
            // 下面三行代码实现的也是上面注释掉的部分的功能
            digits[i] ++;
            digits[i] = digits[i] % 10; // 判断是否有进位
            if (digits[i] != 0) return digits;       
        }
        // 前面都没有返回的话说明全是9
        int[] res = new int[digits.length + 1];
        res[0] = 1;
        return res;
    }
}

yxin185

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode题解——数组、链表、跳表

如有问题，敬请指正！最近做的一些LeetCode题目的解答，参考了题解部分内容。283.移动零1. 解法一class Solution { // 将非零元素全部移动到前面，后面直接用0来填充 public void moveZeroes(int[] nums) { if (nums == null || nums.length == 0) return;...
复制链接

扫一扫