【LeetCode-java】001-300复习【01】：双指针专题

最新推荐文章于 2024-07-21 15:36:00 发布
最新推荐文章于 2024-07-21 15:36:00 发布
阅读量176 收藏
点赞数
分类专栏： LeetCode 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42711949/article/details/107323741
版权

这是每次刷LeetCode时最先刷的专题，主要目的是练手熟悉刷题环境。

  1. 中等 无重复字符的最长子串 Longest Substring Without Repeating Characters
    20.07.06
    思路：用last记录上一次出现的位置。妙啊。其实本来想写HashMap的，可惜不会。滑动窗口倒是很有共识。
class Solution {
    private int res = 0;
    public int lengthOfLongestSubstring(String s) {
        int[] last = new int[128];
        for(int i=0;i<128;i++){
            last[i] = -1;
        }
        int left = 0;
        int n = s.length();
        for(int i=0;i<n;i++){
            int index = s.charAt(i);
            left = Math.max(left,last[index]+1);
            res = Math.max(res,i-left+1);
            last[index] = i;
        }
        return res;
    }
}
  1. 中等 盛最多水的容器 Container with Most Water
    20.07.06
    思路：双指针，向中间收
class Solution {
    int res = 0;
    public int maxArea(int[] height) {
        int left = 0;
        int right = height.length-1;
        while(left<right){
            res = Math.max(res,(right-left)*Math.min(height[left],height[right]));
            if(height[left]<height[right]) left++;
            else right--;
        }
        return res;
        
    }
}
  1. 中等 三数之和 3 Sum
    20.07.06
    思路：双指针
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> ls = new ArrayList<>();
 
        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, sum = 0 - nums[i];
                while (l < r) {
                    if (nums[l] + nums[r] == sum) {
                        ls.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 (nums[l] + nums[r] < sum) {
                        while (l < r && nums[l] == nums[l + 1]) l++;
                        l++;
                    } else {
                        while (l < r && nums[r] == nums[r - 1]) r--;
                        r--;
                    }
                }
            }
        }
        return ls;
    }
}
  1. 中等 最接近的三数之和 3 Sum Closest
    20.07.06
    思路： 没什么思路，写熟了就好。
class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int closestNum = nums[0] + nums[1] + nums[2];

        for (int i = 0; i < nums.length - 2; i++) {
            int l = i + 1, r = nums.length - 1;
            while (l < r){
                int threeSum = nums[l] + nums[r] + nums[i];
                if (Math.abs(threeSum - target) < Math.abs(closestNum - target)) {
                    closestNum = threeSum;
                }
                if (threeSum > target) {
                    r--;
                } else if (threeSum < target) {
                    l++;
                } else {
                    return target;
                }
            }
        }

        return closestNum;
    }
}
  1. 中等 四数之和 4 Sum
    20.07.06
    思路：和三数之和完全一样，不过要加上去重的部分。
class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<>();
        
        for(int a=0;a<nums.length-3;a++){
            if(a>0 && nums[a] == nums[a-1]) continue;
            for(int b=a+1;b<nums.length-2;b++){
                if(b>a+1 && nums[b] == nums[b-1]) continue;
                int c = b+1;
                int d = nums.length-1;
                while(c<d){
                    int sum = nums[a]+nums[b]+nums[c]+nums[d];
                    if(sum == target){
                        ans.add(Arrays.asList(nums[a],nums[b],nums[c],nums[d]));
                        while(c<d && nums[c] == nums[c+1]) c++;
                        while(c<d && nums[d] == nums[d-1]) d--;
                        c++;d--;
                    }else if(sum < target){
                        while(c<d && nums[c] == nums[c+1]) c++;
                        c++;
                    }else{
                        while(c<d && nums[d] == nums[d-1]) d--;
                        d--;
                    }
                }
            }
        }
        return ans;
    }
}
  1. 中等 删除链表的倒数第N个元素 Remove N-th Node From End of List
    20.07.10
    思路：这个题做过无数遍，只是我不知道Java的链表怎么写。很舒适的一个题。打键盘非常有节奏感。
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        ListNode slow = dummy;
        ListNode fast = head;
        while(n>0){
            fast = fast.next;
            n--;
        }

        while(fast!=null){
            slow = slow.next;
            fast = fast.next;
        }

        slow.next = slow.next.next;
        return dummy.next;        
    }
}
  1. 简单 删除排序数组中的重复项 Remove Duplicates From Sorted Array
    20.07.10
    思路：没什么思路。见下面。坑多。
class Solution {
    public int removeDuplicates(int[] nums) {
        int j=0;
        for(int i=1;i<nums.length;i++){ //i=1是因为第一个总是要保留的
            if(nums[i]!=nums[j]){
                nums[++j] = nums[i];//++j也是因为第一个要保留，所以先加再换
            }
        }
        return j+1;//注意一下，不然最后一个进不来
    }
}
  1. 简单 移除元素 Remove Element
    20.07.10
    思路：和26题其实完全一样，甚至比26题更简单。
class Solution {
    public int removeElement(int[] nums, int val) {
        int j = 0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=val){
                nums[j++] = nums[i];
            }
        }
        return j;
    }
}
  1. 简单 实现strStr() Implement strStr
    20.07.10
    思路：没什么，只是我不知道Java的chatAt怎么用。
class Solution {
    public int strStr(String haystack, String needle) {
        //各种空值条件处理
        if (needle == null || needle.length() ==0 ) {
            return 0;
        }
        if (haystack == null) {
            return -1;
        }
        if (haystack.length() < needle.length()) {
            return -1;
        }
        //遍历
        for (int i = 0; i < haystack.length(); i++) {
            
            if (haystack.length() - i < needle.length()) {
                return -1;
            }
            for (int j = 0; j < needle.length(); j++) {
                if (haystack.charAt(i + j) != needle.charAt(j)) {
                    break;
                } else {
                    if (j == needle.length() - 1) {
                        return i;
                    }
                }
            }
        }
        return -1;
    }
}
  1. 困难 接雨水 Trapping Rain Water
    20.07.10
    思路：记录左边和右边的最小值，然后累加。这是在刷Java的时候看到的一个思路。本来我是想像以前一样做两个list的，但是后来我忘了Java的List怎么构造。这实际上是一个上述思路的化简版本，只用一个数组做。有点像11题的做法了。
class Solution {
    public int trap(int[] height) {
        int min = 0, max = 0;
        int l = 0, r = height.length - 1;

        int vol = 0;
        while(l<r){
            min = height[height[l]<height[r]?l++:r--];
            max = Math.max(min,max);
            vol += max-min;
        }

        return vol;
    }
}
  1. 中等 旋转链表 Rotate List
    20.07.10
    思路：不过是一个快慢指针连成环然后解开。我得想想为什么之前的不对。把while改成for为什么就对了呢。
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if(head == null || k==0) return head;

        ListNode slow = head;
        ListNode fast = head;
        int n = 1;
        while(fast.next!=null){
            fast = fast.next;
            n++;
        }
        fast.next = head;

        int mov = n - (k%n);
        for(int i=0;i<mov;i++){
            fast = fast.next;
            slow = slow.next;
        }

        fast.next = null;
        return slow;
    }
}
  1. 中等 颜色分类 Sort Colors
    20.07.10
    思路：三路排序，Java里面没有swap函数，写了半天。注意right不能小于i，这样可能会把2换到中间来。
class Solution {
    public void sortColors(int[] nums) {
        if(nums.length == 0) return;
        int left = 0;
        int right = nums.length-1;
        int temp;
        int i = 0;
        
        while(i<=right){
            if(nums[i] == 0){
                nums[i++] = nums[left];
                nums[left++] = 0;
            }else if(nums[i] == 2){
                nums[i] = nums[right];
                nums[right--] = 2;
            }else{
                i++;
            }
        }
        return;
    }
}
  1. 中等 删除排序数组中的重复项II Remove Duplicates from Sorted Array II
    20.07.10
    思路：这题我想起来了，就是那个中间等于前后两个那个题。非常妙。
class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        if(n == 0) return 0;
        int index = 0;
        for(int i=0;i<n;i++){
            if(i>0 && i<n-1 && nums[i] == nums[i-1] && nums[i] == nums[i+1]){
                continue;
            }
            nums[index++] = nums[i];
        }
        return index;
    }
}
  1. 中等 分隔链表 Partition List
    20.07.10
    思路：我以为有什么新思路，结果还是两个表。
class Solution {
    public ListNode partition(ListNode head, int x) {
        if(head == null) return head;
        ListNode dummy1 = new ListNode(0);
        ListNode dummy2 = new ListNode(0);
        ListNode p = head;
        ListNode p1 = dummy1;
        ListNode p2 = dummy2;

        while(p!=null){
            if(p.val < x){
                dummy1.next = p;
                dummy1 = dummy1.next;
            }else{
                dummy2.next = p;
                dummy2 = dummy2.next;
            }
            p = p.next;
        }
        dummy1.next = p2.next;
        dummy2.next = null;
        return p1.next;
    }
}
  1. 简单 合并两个有序数组 Merge Sorted Array
    20.07.10
    思路：没什么，很熟悉了。边界条件要非常小心。
class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int right = m+n-1;
        int right1 = m-1;
        int right2 = n-1;

        while(right!=right1){
            if(right1>=0 && nums1[right1]>nums2[right2]){
                nums1[right--] = nums1[right1--];
            }else{
                nums1[right--] = nums2[right2--];
            }
        }
        return;
    }
}
  1. 简单 验证回文串 Valid Panlindrome
    20.07.11
    思路：啊，字符串呜呜呜呜。
class Solution {
    public boolean isPalindrome(String s) {
        if(s == null) return true;
        s = s.toLowerCase();
        StringBuilder str = new StringBuilder(1);
        for(char c:s.toCharArray()){
            if((c >= '0' && c<='9')||(c >= 'a' && c <= 'z')){
                str.append(c);
            }
        }
        return str.toString().equals(str.reverse().toString());
    }
}
  1. 简单 环形链表 Linked List Cycle
    20.07.11
    思路：快慢指针，不过初始化的时候要fast = head.next。
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 != slow){
            if(fast.next == null || fast.next.next == null) return false;
            fast = fast.next.next;
            slow = slow.next;
        }
        return true;
    }
}
  1. 中等 环形链表II Linked List Cycle II
    20.07.11
    思路：这题描述不清楚，要返回什么都没讲清，虽然思路很清楚。
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null || head.next == null) return null;
        ListNode fast = head, slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) break;
        }
        if(fast == null || fast.next == null) return null;  //不存在环的情况
        fast = head;  //可能出现在第一个节点
        while(fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }
}
  1. 简单 两数之和II-输入有序数组 Two Sum II-Input Array is Sorted
    20.07.11
    思路：做过三数之和的对这个应该不陌生。要记得new int[] 的方法。
class Solution {
    public int[] twoSum(int[] numbers, int target) {
        if(numbers == null) return null;
        int left = 0;
        int right = numbers.length-1; 
        while(left<right){
            int sum = numbers[left] + numbers[right];
            if(sum < target){
                left++;
            }else if(sum > target){
                right--;
            }else{
                return new int[]{left+1,right+1};
            }
        }
        return null;
    }
}
  1. 中等 长度最小的子数组 Minimum Size Subarray Sum
    20.07.11
    思路：一个滑动窗口。我觉得算简单题。
class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int i = 0;
        int len = 0;
        int sum = 0;
        for(int j=0;j<nums.length;j++){
            sum += nums[j];
            while(sum >= s){
                len = len == 0 ? j-i+1 : Math.min(len,j-i+1);
                sum -= nums[i++];
            }
        }
        return len;
    }
}
  1. 中等 回文链表 Panlindrome Linked List
    20.07.11
    思路：分为两个部分。第一个是找中点，非常简单。第二个是翻转链表，这个不容易。这里使用的递归的方法写的。
class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null || head.next == null) return true;
        ListNode slow = head;
        ListNode fast = head;
        while(fast.next != null && fast.next.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }

        slow = reverse(slow.next);
        while(slow != null){
            if(head.val != slow.val){
                return false;
            }
            head = head.next;
            slow = slow.next;
        }
        return true;
    }

    public ListNode reverse(ListNode head){
        if(head.next == null) return head;
        ListNode newHead = reverse(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}
  1. 中等 较小的三数之和 3 Sum Smaller
    20.07.11
    思路：count+=right-left，真是精妙。
class Solution {
    public int threeSumSmaller(int[] nums, int target) {
        int count = 0;
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            int left = i+1;
            int right = nums.length-1;
            while(left<right){
                int sum = nums[i] + nums[left] + nums[right];
                if(sum < target){
                    count+= right-left;left++;
                }else{
                    right--;
                }   
            }
        }
        return count;
    }
}
  1. 简单 移动零 Move Zeros
    20.07.11
    思路：2分钟一次AC。
class Solution {
    public void moveZeroes(int[] nums) {
        if(nums == null || nums.length == 0) return;
        int slow = 0;
        for(int i=0;i<nums.length;i++){
            if(nums[i] != 0){
                nums[slow++]=nums[i];
            }
        }
        while(slow<nums.length){
            nums[slow++] = 0;
        }
        return;
    }
}
  1. 中等 寻找重复数 Find The Duplicate Number
    20.07.11
    思路：快慢指针。而且循环条件是nums[slow]!=nums[left]。
class Solution {
    public int findDuplicate(int[] nums) {
        int slow = 0;
        int fast = 0;
        while(true){
            fast = nums[nums[fast]];
            slow = nums[slow];
            if(slow == fast){
                fast = 0;
                while(nums[slow] != nums[fast]){
                    slow = nums[slow];
                    fast = nums[fast];
                }
                return nums[slow];
            }
        }
    }
}
招财猫qwq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【LeetCode-java】001-300复习【02】深度优先搜索专题
招财猫qwq的博客
07-15 145
今天更新的是深度优先搜索的22题~
leetcode中国-leetcode-PrimaryAlgorithm:这是学习leetcode初级算法笔记，以便后续的学习复习
06-29
本部分只是用java语言记录了leetcode的初级算法的学习和汇总，详细的解题都会放在leetcode题解上，以便督促自己学习和寻找乐趣。 第一章 数组(更新完毕) (双指针) (遍历) (暴力法) (set去重) (set去重) (map查找表) ...
【LeetCode-java】001-300复习-专题序
招财猫qwq的博客
07-13 161
20.07.13开始更新LeetCode复习记录。这里使用的是java语言。复习001-300题，并且按专题划分。第一次复习的时候会有一些困难的题目没有收入，之后会继续更新。 Java! 目前已更新： 双指针
【LeetCode-java】001-300复习【03】链表专题
招财猫qwq的博客
07-19 226
今天更新的链表相关的题目~ 中等 两数相加 Add Two Numbers 20.07.13 思路：一个carry，然后建表。 class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode dummy = new ListNode(0); ListNode curr = dummy; int carry = 0; while(
【LeetCode-java】复习专题（2）：双指针（2）：移除元素
招财猫qwq的博客
08-02 125
今天复习专题写的是双指针的`26.删除排序数组中的重复项`和`27.移除元素`~
LeetCode-Notes-Waiting
03-20
怀特的leetcode笔记 2020-03-19 2020-03-18 2020-03-17复习 2020-03-16 2020-03-15复习 2020-03-14异或复习 2020-03-13复习 2020-03-12复习 2020-03-10链表 DFS 2020-03-09 2020-03-07回溯 2020-03-06 2020-03-05 ...
leetcode2-leetcode2:Java中的LeetCode解决方案
06-30
本项目 "leetcode2:Java中的LeetCode解决方案" 提供了针对 LeetCode 题目的 Java 实现，对于学习和复习算法非常有帮助。 在这个项目中，你可以找到一系列的 Java 类文件，每个类通常对应一个 LeetCode 题目的解决...
leetcode分类-LeetCode:力码
06-30
leetcode 分类 LeetCode 此项目为找工作期间练习的题目，来自 所推荐的 LeetCode 上经典题目。分类包括： 数组（循环不变量、对撞指针和滑动窗口） 查找表（哈希表） 链表（虚拟头节点、快慢指针） 栈与队列 二叉树...
leetcode分类-leetcode:进行leetcode刷题而已
06-30
- 数组：涉及数组操作和数组相关的算法，如双指针、滑动窗口等。 - 递归与回溯：解决组合优化和搜索问题，如八皇后问题、N皇后问题等。 - 哈希函数与散列：解决查找和冲突问题，如开放寻址法、链地址法等。 - 位...
leetcode hot100 （面试复习用）
大厂小码农的博客
07-20 707
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。输入：nums = [5,7,7,8,8,10], target = 8输出：[3,4]// 继续向左查找} else {// 查找目标值在数组中的结束位置// 继续向右查找} else {
【LeetCode】分隔链表
qq_26521261的博客
07-20 285
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
it_fly的专栏
07-21 126
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
1. LeetCode-数组和字符串
weixin_43149506的博客
07-18 916
数组和字符串介绍以及相关例题
【LeetCode】80.删除有序数组中的重复项II
最新发布
说文科技，做有态度的研究。
07-21 78
思路很好想到，但是实现起来不是那么容易。
LeetCode 150, 112, 130
qq_61350148的博客
07-21 484
讲解了栈、二叉树、搜索相关的题目。
24暑假算法刷题 | Day15 | LeetCode 110. 平衡二叉树，257. 二叉树的所有路径，404. 左叶子之和，222. 完全二叉树的节点个数
weixin_54468359的博客
07-17 1153
day15打卡：二叉树的递归与迭代
Leetcode热题100 Day2
KGthe3的博客
07-19 163
但是即使这样我在写的时候还是花了很多时间，一个是边界条件的处理（尤其是连续有相同值的处理）以及我发现了leetcode的编译器和本地的编译器不一样：本地没有进行越界检查，但是leetcode是开启了的。首先需要对原先的区间进行排序，排序的原则是先按照左端从小到大，左端相同则看右端。这样的话，用两个指针表示当前的已合并区间的左端和右端，不断判断这个右端是否大于下一个区间的左端，如果大于，则合并。窗口的特性是窗口内所有字母的出现次数，因为是异位值，所以只要出现次数相同即可，并不需要考虑出现的顺序。
每日一题，力扣leetcode Hot100之283. 移动零
u013373155的博客
07-19 254
首先，两个指针都指向同一个位置，i=j=0，如果移动指针i的位置不为0则进行交换，固定指针+1，如果为0的话，固定指针不变，移动指针往后面移一直找。这样的话固定指针就会指在0的位置，相当于移动指针遇到非0就和0进行交换。对于当前数组进行调整，不使用额外空间，那么既用双指针。
Leetcode 1302.层数最深子叶结点的和
m0_54244065的博客
07-18 714
大家好，今天我给大家分享一下我关于这个题的想法，我这个题过程比较复杂，但大家如果觉得好的话，就请给个免费的赞吧，谢谢了^ _ ^ 1.题目要求: 举例如图所示: 2.做题思路: 1.先用前序遍历求出树的结点数量: 2.然后再根据结点数量用malloc分配两个数组，一个要进行层序遍历，一个要记录树每一层的宽度: 3.然后我们进行层序遍历,设置变量把每一行结点的数量记录下来，再把每个结点存入数组中: 3.全部代码: 好了，这就是我全部代码大家如果觉得好的话，就请给个免费的赞吧，谢谢了^ _ ^ .

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值