力扣labuladong一刷day16天秒杀7道数组题

最新推荐文章于 2026-08-20 21:29:57 发布

原创最新推荐文章于 2026-08-20 21:29:57 发布 · 94 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

力扣算法题

本文介绍了在力扣平台（LeetCode）上的一系列数组和链表相关题目，如删除有序数组重复项、排序链表去重、移除元素等，主要运用了快慢指针的方法。

力扣labuladong一刷day16天秒杀7道数组题

文章目录

一、26. 删除有序数组中的重复项

题目链接：https://leetcode.cn/problems/remove-duplicates-from-sorted-array/
思路：快慢指针，不等跟着走，相等停下等。

class Solution {
  public int removeDuplicates(int[] nums) {
        int k = 1;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] != nums[i-1]) {
                nums[k++] = nums[i];
            }
        }
        return k;
    }
}

二、83. 删除排序链表中的重复元素

题目链接：https://leetcode.cn/problems/remove-duplicates-from-sorted-list/
思路：快慢指针，相等慢指针停下等，不等删除元素快慢指针各往前走一步。结尾处要记得让slow指向null，截断后面相等的元素。

class Solution {
  public ListNode deleteDuplicates(ListNode head) {
        if (head == null) return null;
        ListNode slow = head, fast = head;
        while (fast != null) {
            if (fast.val != slow.val) {
                slow.next = fast;
                slow = slow.next;
            }
            fast = fast.next;
        }
        slow.next = null;
        return head;
    }
}

三、27. 移除元素

题目链接：https://leetcode.cn/problems/remove-element/
思路：依然是快慢指针，相等时慢指针停下等，不等时覆盖元素同步走。

class Solution {
    public int removeElement(int[] nums, int val) {
        if (nums.length == 0) return 0;
        int k = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != val) {
                nums[k++] = nums[i];
            }
        }
        return k;
    }
    
}

四、283. 移动零

题目链接：https://leetcode.cn/problems/move-zeroes/
思路：所谓移动零，和前面的移除元素删除元素没有什么区别，大同小异，只不过是在移动完了以后，把末尾的数都覆盖为0.

class Solution {
   public void moveZeroes(int[] nums) {
        int slow = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0) {
                nums[slow++] = nums[i];
            }
        }
        for (int i = slow; i < nums.length; i++) {
            nums[i] = 0;
        }
    }
}

五、167. 两数之和 II - 输入有序数组

题目链接：https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted/
思路：寻找a+b=target，只需要利用二分查找的思想，从数组的两端进行查找，a+b=target则返回，<则left++，>则right–。

class Solution {
  public int[] twoSum(int[] numbers, int target) {
        int left = 0, right = numbers.length-1;
        while (left < right) {
            int t = numbers[left] + numbers[right];
            if (t == target) {
                return new int[]{left+1, right+1};
            } else if (t < target) {
                left++;
            }else {
                right--;
            }
        }
        return new int[]{-1, -1};
    }
}

六、344. 反转字符串

题目链接：https://leetcode.cn/problems/reverse-string/
思路：翻转只需要使用左右双指针，两两替换即可。

class Solution {
   public void reverseString(char[] s) {
        int left = 0, right = s.length-1;
        while (left < right) {
            char temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            left++;
            right--;
        }
    }
}

七、5. 最长回文子串

题目链接：https://leetcode.cn/problems/longest-palindromic-substring/
思路：如果是让判断是否是回文子串，只需要从两头进行逐个比较即可。
如果是让找回文子串，那就要从每一个点开始向两端扩散，但又考虑长度为奇数或者偶数的问题，扩散时也是以一个点和两个点为基础进行扩散的。

class Solution {
    public String longestPalindrome(String s) {
        String res = "";
        for (int i = 0; i < s.length(); i++) {
            String s1 = find(s, i, i);
            String s2 = find(s, i, i+1);
            res = res.length() > s1.length() ? res : s1;
            res = res.length() > s2.length() ? res : s2;
        }
        return res;
    }

    String find(String s, int i, int j) {
        while (i >= 0 && j < s.length()) {
            if (s.charAt(i) == s.charAt(j)) {
                i--;
                j++;
            }else {
                break;
            }
        }
        return s.substring(i+1, j);
    }
}