从0学算法:双指针

  双指针，指的是在遍历对象的过程中，不是普通的使用单个指针进行访问。而是使用两个指针采用不同的方式进行移动，从而达到我们的目的。

  单指针就是我们常用的for循环，使用一个指针从容器的一端遍历至另一端，相对比较好理解。如下图:

单指针.png

  双指针算法被广泛的用来解决数组、链表相关的问题，除此之外二分查找和滑动窗口等算法也用到了双指针算法。常见的双指针有以下几种用法:

1.快慢指针
2.固定间距指针
3.对撞指针
下面，我将针对这三种用法来举例说明。

1.快慢指针

  快慢指针指两个指针步长不同。
  经典用法就是用于检测链表是否有环，例如LeetCode 141 Easy 环形链表。这道题我们除了可以用HashSet判断一个节点是否被访问过以外，也可以用快慢指针来解决:如果链表存在环，那么快指针终将追上慢指针。
  题目描述和官方解法如下:

LeetCode 141 环形链表

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;
}

2.固定间距指针

  两个指针距离一定的距离，步长相同
  经典用法就是用于解决滑动窗口，或者一次遍历获取链表的倒数第n个节点问题，例如LeetCode 19 Easy 删除链表的倒数第N个节点
我们可以使用两个指针而不是一个指针。第一个指针从列表的开头向前移动 n+1 步，而第二个指针将从列表的开头出发。现在，这两个指针被 nn 个结点分开。我们通过同时移动两个指针向前来保持这个恒定的间隔，直到第一个指针到达最后一个结点。此时第二个指针将指向从最后一个结点数起的第 nn 个结点。我们重新链接第二个指针所引用的结点的 next 指针指向该结点的下下个结点。
  题目描述和官方解法如下:

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

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode first = dummy;
    ListNode second = dummy;
    // Advances first pointer so that the gap between first and second is n nodes apart
    for (int i = 1; i <= n + 1; i++) {
        first = first.next;
    }
    // Move first to the end, maintaining the gap
    while (first != null) {
        first = first.next;
        second = second.next;
    }
    second.next = second.next.next;
    return dummy.next;
}

3.固定间距指针

  两个指针从头尾相向遍历
  经典用法就是用于解决二分查找问题，或是n数之和等一系列问题。例如LeetCode 1，LeetCode 15，LeetCode 18，这三道的难度分别是Easy，Easy，Medium，虽然难度是递增的，但是其解法的中心思想一直没变：对于有序数组，使用头尾两个指针，使用sum和target进行比对，遍历整个数组。这里直接举LeetCode 18 四数之和这个例子吧，其他太简单。 四数之和
  题目描述和我个人的解法如下:

LeetCode 18 四数之和

 public List> fourSum(int[] nums, int target) {
        List> res = new ArrayList<>();
        if (nums == null || nums.length < 4) {
            return res;
        }

        int size = nums.length;
        Arrays.sort(nums);

        for (int i = 0; i < size - 3; i++) {

            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            int min = nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3];
            int max = nums[i] + nums[size - 3] + nums[size - 2] + nums[size - 1];
            if (min > target) {
                break;
            }
            if (max < target) {
                continue;
            }

            for (int j = i + 1; j < size - 2; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }

                int left = j + 1;
                int right = size - 1;

                int minSub = nums[i] + nums[j] + nums[left] + nums[left + 1];
                int maxSub = nums[i] + nums[j] + nums[right] + nums[right - 1];
                if (minSub > target) {
                    continue;
                }
                if (maxSub < target) {
                    continue;
                }

                while (left < right) {
                    int sum = nums[i] + nums[j] + nums[right] + nums[left];
                    if (sum == target) {
                        res.add(new ArrayList<>(Arrays.asList(nums[i], nums[j], nums[left], nums[right])));
                        while (left < right && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        while (left < right && nums[right] == nums[right - 1]) {
                            right--;
                        }
                        left++;
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        right--;
                    }
                }
            }
        }
        return res;
    }