手撕链表——多方法解决链表面试题

一、链表的快慢指针问题

例题：

本题就是快慢指针问题，读题得要找到中间节点，我们的第一个反应是先遍历得到节点个数n，在走n/2步即可走到中间节点，但是如果数据过于庞大，就要处理多步，此时引入快慢指针，解题思路就是定义两个指针，快的走两步，慢的走一步，当快的走向空时，那么慢的就一定是走到中点。

代码如下：

public ListNode middleNode(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }else {
            ListNode fir = head;
            ListNode sec = head;
            while (fir != null && fir.next != null){
                fir = fir.next.next;
                sec = sec.next;
            }return sec;
        }
    }

例题：

 

 此题与上一题的思路大相径庭，要找到倒数第k个节点的值，那么，就让快指针先走k步，然后快慢指针一起走，当快指针走到空时，那么慢指针一定就走到了倒数的第k个节点，返回值即可。

代码如下：

 public int kthToLast(ListNode head, int k) {
        ListNode fast = head;
        ListNode slow = head;
        for(int i = 0; i < k ; i++){
            fast = fast.next;
        }
        while(fast != null){
            fast = fast.next;
            slow = slow.next;
        }
        return slow.val;
    }

二、环形链表问题

例题：

环形链表我们可以借用操场跑圈的问题，在日常生活中，跑的快的同学，总是能够越过一圈追上跑得慢的同学，由此我们可以定义两个指针，让快指针一次走两步，慢指针一次走一步，此时，如果有快指针等于了慢指针的时刻，那么一定是环形链表，反之则不是。

代码如下：

 public boolean hasCycle(ListNode head) {
        if(head == null || head.next == null){
            return false;
        }
        else {
            ListNode fast = head;
            ListNode low = head;
            while (fast != null && fast.next != null){
                fast = fast.next.next;
                low = low.next;
                if (fast == low){
                    return true;
                }
            }
        }
        return false;
    }

例题：

 本题与上一题的区别是要返回入环的节点，那么如何找到入环的节点呢？？？此时就牵扯到了数学问题，以下是我画图分析的：

根据表达式得到 当快慢指针相遇，在原处重新引入一个新指针，当他走到B点时一定会与慢指针相遇，那么直接返回节点即可，代码如下：

public ListNode detectCycle(ListNode head) {
        if (head == null || head.next == null){
            return null;
        }else {
            ListNode fast = head;
            ListNode low = head;
            while (fast != null && fast.next !=null){
                fast = fast.next.next;
                low = low.next;
                if(fast == low){
                   ListNode cur = head;
                   while (cur != low){
                       cur = cur.next;
                       low = low.next;
                   }
                   return low;
                }
            }
        }
        return null;
    }

三、反转链表问题

例题：

 反转我介绍两种方法，遍历算法以及递归算法：

遍历：新链表，采用头插入方法遍历原链表即可得到反转后链表

代码如下：

public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null){
           return head;
        }else{
            ListNode prev = null;
            ListNode cur = head;
            while (cur != null){
                ListNode next = cur.next;
                cur.next = prev;
                prev = cur;
               cur = next;
            }
            return prev;
        }
    }

递归：结合方法语义，输入一个链表我们就能得到一个反转的链表，此时记住第二个节点，反转后，让第二个节点指向头节点，头节点指向空，反转后的新节点为头节点。

代码如下：

public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }else {
           ListNode x = head.next;
           ListNode newHead = reverseList(head.next);
           x.next = head;
           head.next = null;
        return newHead;
        }
    }

四、删除链表重复元素

例题：

代码如下：

public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        } else {
            ListNode prev = head;
            ListNode cur = head.next;
            while (cur != null) {
                if (prev.val != cur.val) {
                    cur = cur.next;
                    prev = prev.next;
                } else {
                    while (cur != null && prev.val == cur.val) {
                        cur = cur.next;
                    }
                    prev.next = cur;
                    prev = prev.next;
                }
            }
        }
        return head;
    }

 例题：

代码如下： 

public ListNode deleteDuplicates(ListNode head) {
    ListNode dummyHead = new ListNode();
    dummyHead.next = head;
    ListNode prev = dummyHead;
    ListNode cur = prev.next;
    while (cur != null) {
        ListNode net = cur.next;
        if (net == null) {
            break;
        } else {
            if (cur.val != net.val) {
                prev = prev.next;
                cur = cur.next;
            }else {
            while (net != null && cur.val == net.val) {
                net = net.next;
            }
            prev.next = net;
            cur = net;
        }
    }
    }return dummyHead.next;
}

五、总结

     以上就是链表中常见的一些问题，解题方法大多是大同小异，最重要的还是掌握解题思路，这样会少走一些弯路！！