代码随想录的第一天打卡，自己的第三天

代码随想录的第一天打卡，自己的第三天

一、学习目标

1. 掌握二分法
2. 掌握双指针法

二、学习内容

1. 双指针法

1.1. 同向双指针

1.1.1. 链表的快慢指针

• 本章尚未涉及

1.1.2. 移动元素类

• 核心就是用慢指针记录当前位置，把非目标值前移，目标值后移
• 类似的题目：
  • 移动零

 class Solution {
    public void moveZeroes(int[] nums) {
        int fast;
        int slow = 0;
        int n = nums.length;

        for(fast = slow; fast < n; fast++) {
            if(nums[fast] != 0) {
                int temp = nums[fast];
                nums[fast] = nums[slow];
                nums[slow] = temp;
                slow++;
            }
        }
    }
}

• 比较含退格的字符串（只会用栈，但是很明显不是最优解）

class Solution {
    public void backspace(String s,Stack<Character> stack) {
        
        for(int i = 0; i < s.length(); i++) {
            if(s.charAt(i) != '#') {
                stack.push(s.charAt(i));
            }
            if(!stack.isEmpty()&&s.charAt(i) == '#') {
                stack.pop();
            } 
        }
    }
    public boolean backspaceCompare(String s, String t) {
        Stack<Character> stack0 = new Stack<>();
        Stack<Character> stack1 = new Stack<>();
        backspace(s, stack0);
        backspace(t, stack1);
        while(!stack0.isEmpty() && !stack1.isEmpty()) {
            if(stack0.pop() != stack1.pop()) {
                return false;
            }
        }

        if(!stack0.isEmpty() || !stack1.isEmpty()) {
            return false;
        }
        return true;
    }
}

1.1.3. 滑动窗口类

• 暂时未涉及

1.2. 相向双指针

1.2.1. 二分查找类问题

• 二分查找基础版

class Solution {
    public int search(int[] nums, int target) {
        int i = 0;
        int j = nums.length - 1;

        while(i <= j) {
            int mid = (i + j) / 2;
            if(nums[mid] < target) {
                i = mid + 1;
            }else if(nums[mid] > target){
                j = mid - 1;
            } else{
                return mid;
            }
        } 
        return -1;（进阶版的时候，这里返回 i 表示没找到，但是插入的位置是 i ）
    }
}

• 二分查找进阶——搜索插入位置（找到位置之后返回左边界）

class Solution {
    public int search(int[] nums, int target) {
        int i = 0;
        int j = nums.length - 1;

        while(i <= j) {
            int mid = (i + j) / 2;
            if(nums[mid] < target) {
                i = mid + 1;
            }else if(nums[mid] > target){
                j = mid - 1;
            } else{
                return mid;
            }
        } 
        return i;
    }
}

• 二分查找进阶——查找左右边界问题（分别查找左右边界）

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] res = new int[]{searchLeft(nums,target), searchRight(nums, target)};
        return res;
        
    }

    public int searchLeft(int[] nums, int target) {
        int i = 0;
        int j = nums.length - 1;
        int m1 = Integer.MAX_VALUE;
        while(i <= j) { //范围内有东西
            int mid1 = (i + j) >> 1;

            if(nums[mid1] > target) { //目标在左边
                j = mid1 - 1;
            } else if(nums[mid1] < target) { //目标在右边
                i = mid1 + 1;
            } else {
                m1 = Math.min(m1, mid1);//找到了
                j = mid1 - 1;
            }
        }
        return m1 == Integer.MAX_VALUE ? -1 : m1;//没找到,m1就没改变值
    }

    public int searchRight(int[] nums, int target) {
        int i = 0;
        int j = nums.length - 1;
        int m2 = Integer.MIN_VALUE;
        while(i <= j) { //范围内有东西
            int mid2 = (i + j) >> 1;

            if(nums[mid2] > target) { //目标在左边
                j = mid2 - 1;
            } else if(nums[mid2] < target) { //目标在右边
                i = mid2 + 1;
            } else {
                m2 = Math.max(m2, mid2);//找到了
                i = mid2 + 1;
            }
        }
        return m2 == Integer.MIN_VALUE ? -1 : m2;//没找到的话，m2就不会改变值
    }
}

• 二分查找进阶——查找旋转数组中的目标值（核心就是分类）

class Solution {
    public int search(int[] nums, int target) {
        int n = nums.length;
        int left = 0;
        int right = n - 1;
        int res = -1;
        
        while(left <= right) {
            int mid = (left +right) >> 1;
			//这里分类，看的是旋转之后，前半段和后半段的比例
            if(nums[left] <= nums[mid]) {
            //这里是看哪里是顺序段，因为二分搜索只适用于顺序区间
                if(nums[left] <= target && nums[mid] >= target) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else {
                if(nums[mid] <= target && nums[right] >= target) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }

            if(nums[mid] == target) {
                res = mid;
            }
        }
        return res;
    }
}

1.2.2. 三数之和类问题

• 基础版，三数之和
  时间复杂度：O($n^2$)

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //排序数组
        Arrays.sort(nums);

        //初始化结果集合以及数组长度
        int n = nums.length;
        List<List<Integer>> res = new ArrayList<>();

        for(int i = 0; i < n - 2; i++) {
            int x = nums[i];
			//去重
            if(i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
			//优化减枝
            if(x + nums[i + 1] + nums[i + 2] > 0) {
                break;
            }
            if(x + nums[n - 1] + nums[n - 2] < 0) {
                continue;
            }

            int j = i + 1;
            int k = n - 1;

            while(j < k) {
                int sum = x + nums[j] + nums[k];

                if(sum > 0){
                    k--;
                } else if(sum < 0) {
                    j++;
                } else if(sum == 0) {
                    res.add(List.of(x, nums[j], nums[k]));
                    //优化减枝
                    for(j += 1; j < k && nums[j] == nums[j - 1]; j++) {
                        continue;
                    }
                    for(k -= 1; j < k && nums[k] == nums[k + 1]; k--) {
                        continue;
                    }
                }
            } 
        }
        return res;
    }
}

平方根问题

• X 的平方根
• 有效的完全平方根
  • 两道题代码几乎一致，只写第二题

class Solution {
    public boolean isPerfectSquare(int num) {
        long i = 1;
        long j = num / 2;
        while(i < j) {
            long mid = i + ((j - i + 1) >> 1);
            if(mid > num / mid) {
                j = mid - 1;
            } else if(mid == num / mid){
                i = mid;
            } else {
                i = mid;
            }
        }
        if(i * i == num) {
            return true;
        }
        return false;
    }
}