快慢指针（初遇）

1、前提

数据结构书籍尚未看完，暂时只看了一部分的《大话数据结构》，因此对链表只是有点了解。

而后在LeetCode每日打卡中遇到这道题————https://leetcode-cn.com/problems/middle-of-the-linked-list(876   链表的中间结点)

相信这道题对于大佬甚至小白来讲都是很简单的一道题，可是我不会啊，因此就去看了一下题解，就发现了所谓的快慢指针，因此在此作一下笔记，但愿各位不要嘲笑。

2、内容

快慢指针

定义

快慢指针就是定义两根指针，其位置一快一慢，以此来制造出本身想要的差值。这个差值可让咱们找到链表上相应的节点以及一系列操做

单链表的快慢指针

对于单链表，每一个结点只有一个存储下一结点的 next 指针。当咱们在查找某个结点的时候，没法和数组同样经过下标快速定位到待查询的结点，只能从头结点开始，经过每一个结点的 next 指针，一个个结点的匹配查找。

这就表明了单链表循环的一个特色，它在遍历上没法后悔，遍历走过了，就是过了，没法回头。除非再用一个数据结构去记录已经遍历的结点，那就再也不是一个单纯的单链表了。因此当咱们遇到一个指针遍历链表不能解决问题的时候，能够尝试用两个指针来遍历链表。这就引起出一种解决方案，就是快慢指针，一个指针没法完成任务，那就再引入一个指针。它经过两个指针 fast 和 slow 指针，让两个指针保持必定的间隔规律，达到咱们查找的目的。

应用

1. 找出链表的中间节点
2. 判断链表是否存在环
3. 删除链表的倒数第n的节点
4. 将有序链表转换为二叉搜索树

找出链表的中间节点

给定一个带有头结点 head 的非空单链表，返回链表的中间结点。

若是有两个中间结点，则返回第二个中间结点。

题目描述（此为连接里的LeetCode题）

示例 1：

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，咱们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例 2：

输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
因为该列表有两个中间结点，值分别为 3 和 4，咱们返回第二个结点。

思路：

用快慢两个指针 slow 与 fast 一块儿遍历链表。根据两个指针之间的间隔，来达到咱们的目的，因此使slow 一次走一步，fast 一次走两步。那么当 fast 到达链表的末尾时，slow 必然位于中间。

代码：

/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/

    //链表的中间结点
    class Solution {//用两个指针 slow 与 fast 一块儿遍历链表。slow 一次走一步，fast 一次走两步。那么当 fast 到达链表的末尾时，slow 必然位于中间。
        public ListNode middleNode(ListNode head) {//快慢指针
            ListNode fast = head;
            ListNode slow = head;
            while(fast != null && fast.next != null){//由于后面是fast = fast.next.next，因此若fast.next为空，则会产生异常；
                fast = fast.next.next;
                slow = slow.next;
　　//若链表为单数，则最终fast.next=null，结束循环，slow为中间结点
　　//若链表为双数，则最终fast=null,结束循环，slow=(len+1)/2的中间结点；
            }
            return slow;
        }
    }

链表中倒数第k个节点

此题出自LeetCode——https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/（面试题2二、链表中倒数第K个结点）

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有6个节点，从头节点开始，它们的值依次是一、二、三、四、五、6。这个链表的倒数第3个节点是值为4的节点。

题目描述

示例：

给定一个链表: 1->2->3->4->5, 和  k = 2.
返回链表 4->5.

思路：

让快指针先走k步，而后两个指针同时走到头时，慢指针就是链表倒数第k个结点；

注意点：

这题中咱们须要注意，若是输入的k大于链表的结点数，须要怎样进行判断，若是k小于等于0，还有就是须要注意空指针的问题。

代码：

class Solution {//快慢指针，让快指针先走k步，而后两个指针同时走到头时，慢指针就是链表倒数第k个结点；

    public ListNode getKthFromEnd(ListNode head, int k) {

        if(head == null || k==0){

            return null;

        }

        ListNode fast = head;

        ListNode slow = head;

        while(k>0){

            if(fast != null){

                fast = fast.next;

                k--;

            }else{

                return null;

            }

        }

        while(fast != null){

            slow = slow.next;

            fast = fast.next;

        }

        return slow;

    }

}

判断链表中是否有环

给定一个链表，判断链表中是否有环。

若是链表中有某个节点，能够经过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，咱们使用整数 pos 来表示链表尾链接到链表中的位置（索引从 0 开始）。 若是 pos 是 -1，则在该链表中没有环。注意：pos 不做为参数进行传递，仅仅是为了标识链表的实际状况。

若是链表中存在环，则返回 true 。 不然，返回 false 。

出自：https://leetcode-cn.com/problems/linked-list-cycle

题目描述

示例 ：

输入：head = [3,2,0,-4], pos = 1输出：true解释：链表中有一个环，其尾部链接到第二个节点。

代码：

public class Solution { public boolean hasCycle(ListNode head) { if(head == null || head.next == null){ return false; } ListNode fast = head.next;//fast和slow设置不同的值，是由于下面的循环，如果值同样，循环在初始状况下就终止了。
        ListNode slow = head; while(fast != slow){ if(fast == null || fast.next == null){ return false; } fast = fast.next.next; slow = slow.next; } return true; } }

删除排序数组中的重复项

此为LeetCode题——https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/（2六、删除排序数组中的重复项）

给定一个排序数组，你须要在 原地 删除重复出现的元素，使得每一个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

题目描述：

示例：

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 而且原数组 nums 的前两个元素被修改成 1, 2。

你不须要考虑数组中超出新长度后面的元素。

思路：

能够放置两个指针slow和fost，由于是有序数组，因此当fost指针指向的值不等于slow指向的值时，那么就能够将此时fost指向的值添加到此时slow指针的位置，而且将slow加一;

代码：

class Solution {

    public int removeDuplicates(int[] nums) {

        int fost = 0;

        for(int slow=1;slow<nums.length;slow++){

            if(nums[fost] != nums[slow]){

                nums[fost+1]=nums[slow];

                fost++;

            }

        }

        return fost+1;

    }

}