双指针技巧总结

双指针大体有两个种。
一种是前后双指针：头尾开始遍历
一种是快慢双指针：一前一后

27 移除元素

    public int removeElement(int[] nums, int val) {
        int left = 0;
        for(int right = 0;right < nums.length;right++){
            if(nums[right] != val) nums[left++] = nums[right];
        }
        return left;
    }

这道题是相当经典的双指针。假设你不使用双指针，what will be happened?
首先，你需要判定当前元素是不是val，如果是就要整体数组往前移动。这个时候还要考虑到第二个元素是不是val，如果第二个元素还是val，那就还要继续调整数组，就是这么离谱。但是一旦用双指针的思路，就显得那么清澈。

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

    public int removeDuplicates(int[] nums) {
        int left = 0;
        for(int right = 1;right < nums.length;right++){
            if(nums[left] == nums[right]) continue;
            nums[++left] = nums[right];
        }
        return left + 1;
    }

总体是双指针的思路，但是对比我第一次写的和接下来几次写的，都大有不同

    public int removeDuplicates(int[] nums) {
        int left = 0;
        int tag = -999;
        for (int i =0;i<nums.length;i++){
            if (nums[i] != tag){
                tag = nums[i];
                nums[left++] = nums[i];
            }
        }
        return left;
    }
    // 这么写明显丑陋了很多

移动0

    public void moveZeroes(int[] nums) {
        int left = 0;
        for(int right = 0;right < nums.length;right++){
            if(nums[right] != 0){
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left++;
            }
        }
    }

这道题犯迷糊了，之前写的是nums[left] = 0;这样导致了一个很严重的问题，就是无法处理开头的数据。其实应该是交换的，这样就能同时处理0和其他数值的关系了。

844 比较含退格的字符串
我发现了一个核心的问题就是，left其实是用来记录的，right才是用来遍历的

    public boolean backspaceCompare(String s, String t) {
         String s_s = fun(s);
         String t_t = fun(t);
         System.out.println(s_s);
         System.out.println(t_t);
         return s_s.equals(t_t);
    }
    public String fun(String s){
        char[] array = s.toCharArray();
        int left = 0;
        int right = 0;
        while(array[right] == '#') right++;
        for(;right < array.length;right++){
            if(array[right] == '#'){
                if(left > 0) left--;
                continue;
            }
            array[left++] = array[right];
        }
        return new String(Arrays.copyOfRange(array,0,left));
    }

如果逆序+双指针，效果会更好，但是我不想用了
344 反转字符串

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

这就是前后指针的问题

替换空格

    public String replaceSpace(String s) {
        char[] s_array = s.toCharArray();
        int num_space = 0;
        for(int i = 0;i<s_array.length;i++){
            if(s_array[i] == ' ') num_space++;
        }
        char[] res = new char[s_array.length+2*num_space];

        int left = 0;
        
        for(int right = 0;right < res.length;right++){
            if(s_array[left] == ' '){
                res[right] = '%';
                res[right + 1] = '2';
                res[right + 2] = '0';
                right+=2;
                left++;
                continue;
            }
            res[right] = s_array[left++];
        }
        return new String(res);
    }

仔细看，这次我让left短指针在遍历，长指正在记录。所以这都是灵活变换的

反转链表
在链表中，这种双指针的操作是很频繁的。比如前一个指针的记录，后一个指针的记录，这都是相当相当常见的。

19 删除链表的倒数第N个节点

    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;

        ListNode pre = dummy;
        ListNode cur = head;

        for(int i =0;i<n;i++)
            cur = cur.next;

        while(cur != null){
            cur = cur.next;
            pre = pre.next;
        }
        pre.next = pre.next.next;

        return dummy.next;

    }

这道题别看我写的丑陋，很多都没家安全保护，但是实际上他的数据保证了可行性you konw？

面试题 02.07 链表相交

    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null) return null;
        int length_A = 0;
        int length_B = 0;
        ListNode temp = headA;
        while(temp != null){
            length_A++;
            temp = temp.next;
        }
        temp = headB;
        while(temp != null){
            length_B++;
            temp = temp.next;
        }
        if(length_A < length_B){
            temp = headA;
            headA = headB;
            headB = temp;

            int t = length_A;
            length_A = length_B;
            length_B = t;
        }
        int num = length_A - length_B;
        
        for(int i = 0;i<num;i++)
            headA = headA.next;

        while(headA != headB){
            headA = headA.next;
            headB = headB.next;
        }
        return headA;
    }

就是直来直去的一个思路。关键掌握判定条件
headA == headB这个条件相当关键

142 环形链表

    public ListNode detectCycle(ListNode head) {
        //讲道理这道题一开始没做过的话怎么想得到双指针这个思路的呀
        HashSet<ListNode> set = new HashSet();
        int index = 0;
        while(head != null){
            // System.out.println(head.val);
            if(!set.add(head)){
                return head;
            }
            head = head.next;
        }
        return null;
    }

这道题就很奇妙，为什么要用双指针呢，直接用一个hashset，他不香吗。