链表合集1

最近在准备面试，把基础的算法稍微复习一下。

1. 链表反转        leeetcode 206 

        (1)最常用的，用两个相邻的指针依次向后遍历

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

        (2) 用栈实现，记得放进去的时候每个节点next要设为Null，不然最后结果会有循环链表

    public ListNode reverseList(ListNode head) {
        Stack<ListNode> stack = new Stack<>();
        ListNode temp = null;
        while(head != null){
            stack.push(head);
            temp = head;
            head = head.next;
            temp.next = null;
        }
        ListNode newHead = new ListNode();
        ListNode cur = newHead;
        while(!stack.isEmpty()){
            cur.next = stack.pop();
            cur = cur.next;
        }
        return newHead.next;
    }

        (3) 头插法，需要生成一个新链表，额外空间复杂度O(N)

    public ListNode reverseList(ListNode head) {
        ListNode newHead = null;
        while(head != null){
            ListNode cur = new ListNode(head.val);
            cur.next = newHead;
            newHead = cur;
            head = head.next;
        }
        return newHead;
    }

        (4) 递归法，这个我想了一会才想明白。if里判断head == null是预防传进来就是个NULL，判断head.next == null是想返回最后一个节点。

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

        return cur;
    }

2. 找链表中点        leetcode 876

快慢指针，while里条件这么写的原因是：当链表长度为偶数时，fast先为NULL，当长度为奇数时，fast.next先为NULL，因此可以在while循环结束之后根据fast或fast.next哪个为NULL判断链表长度是奇数还是偶数。此外，在链表长度为偶数时，slow最后指向中间两个节点后一个，如果需要靠前一个中点，声明一个prev变量，每次slow往下移之前令prev = slow即可，一开始我想的是在找到slow之后再从头遍历一遍，太蠢了。

    public ListNode middleNode(ListNode head) {
        ListNode slow = head, fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

3. 删除链表倒数第K个节点        leetcode 19

先说怎么找到倒数第K个节点：假设链表长度为n，先让一个指针fast走k步，然后slow指针从头开始和fast一直往后走，直到fast == null，这样fast又走了(n-k)步，加起来正好n步等于链表长度，slow也走了(n-k)步，此时slow距离链表结尾的null刚好k步，就等于倒数第k个节点。

要想删除的话，用一个prev指针，表示slow前一个节点，每次slow往后移之前让prev = slow。当slow到达倒数第k个节点后，需要删除slow节点，只需要让prev.next = prev.next.next即可，就跳过了slow节点。

特殊情况，当n=k，等于正好删除头节点，应当让新的头节点指向第二个节点(如果有的话)

    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode slow = head, fast = head, prev = null;
        for(int i = 0; i < n; i++){
            fast = fast.next;
        }
        while(fast != null){
            prev = slow;
            slow = slow.next;
            fast = fast.next;
        }
        if(prev == null){
            return head.next;
        }
        prev.next = prev.next.next;
        return head;
    }

4. 两个升序的链表合并        leetcode 21

很简单，主要是这个方法在归并排序中有用，提醒自己复习一下排序

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode newHead = new ListNode();
        ListNode cur = newHead;
        while(list1 != null && list2 != null){
            if(list1.val <= list2.val){
                cur.next = list1;
                list1 = list1.next;
            } else{
                cur.next = list2;
                list2 = list2.next;
            }
            cur = cur.next;
        }
        while(list1 != null){
            cur.next = list1;
            list1 = list1.next;
            cur = cur.next;
        }
        while(list2 != null){
            cur.next = list2;
            list2 = list2.next;
            cur = cur.next;
        }
        return newHead.next;
    }

5. 将原链表按照某个值分成左右两半，各自保留原来顺序        leetcode 86

这题以前第一次做的时候没看懂意思，注意不要使用额外空间就行，用两个小链表分别存大的和小的，最后首尾相连。

    public ListNode partition(ListNode head, int x) {
        ListNode big = new ListNode();
        ListNode small = new ListNode();
        ListNode curBig = big;
        ListNode curSmall = small;
        while(head != null){
            if(head.val >= x){
                curBig.next = new ListNode(head.val);
                curBig = curBig.next;
            } else{
                curSmall.next = new ListNode(head.val);
                curSmall = curSmall.next;
            }
            head = head.next;
        }
        curSmall.next = big.next;
        return small.next;
    }

6. 判断链表是不是回文结构        leetcode 234

这题以前第一次写的时候，居然存到了一个ArrayList里面然后首尾比较。现在写链表题注重不适用额外空间。因此找到中点，然后把后半部分链表反转，然后和前半部分链表挨个比较节点的值。

有趣的是，使用双指针法得到的反转链表，自然会和前半部分断开，然后如果原始链表长度为奇数，根据中点反转的后半部分链表是会包括原中点的，但是比较的时候不会有影响。最后，比较完之后可以把后半部分链表再恢复回去，再把前后连起来，需要多保存一个prev指向中点前一位。

class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head.next == null){
            return true;
        }
        ListNode[] temp = getMid(head);
        ListNode prev = temp[0], mid = temp[1];
        ListNode tail = reverseList(mid);
        boolean res = check(head, tail);
        ListNode oldMid = reverseList(tail);
        prev.next = oldMid;
        //print(head);
        return res;
    }
    private boolean check(ListNode root1, ListNode root2){
        while(root1 != null && root2 != null){
            if(root1.val != root2.val){
                return false;
            }
            root1 = root1.next;
            root2 = root2.next;
        }
        return true;
    }
    private ListNode[] getMid(ListNode root){
        ListNode slow = root, fast = root, prev = null;
        while(fast != null && fast.next != null){
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        return new ListNode[]{prev, slow};
    }
    private ListNode reverseList(ListNode head){
        if(head == null || head.next == null){
            return head;
        }
        ListNode cur = reverseList(head.next);
        head.next.next = head;
        head.next = null;

        return cur;
    }
    private void print(ListNode head){
        while(head != null){
            System.out.println(head.val + " ");
            head = head.next;
        }
    }
}

7. 判断两个链表是否相交        leetcode 160

如果有一个链表为空，肯定不相交；分别找到两个链表的最后一个非空节点，如果不相等肯定不相交；如果相交，在之前找最后节点的时候保存了两个链表的长度，长度差为p, 让长的那个头节点先走p步，然后两个头节点一起走，相等时就是相交节点。

    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null){
            return null;
        }
        
        int lengthA = 0, lengthB = 0;
        ListNode curA = headA, curB = headB;
        
        while(curA.next != null){
            curA = curA.next;
            lengthA++;
        }
        lengthA++;
        
        while(curB.next != null){
            curB = curB.next;
            lengthB++;
        }
        lengthB++;
        
        if(curA != curB){
            return null;
        }
        
        curA = headA;
        curB = headB;
        if(lengthA < lengthB){
            for(int i = 0; i < lengthB - lengthA; i++){
                curB = curB.next;
            }
        }
        if(lengthA > lengthB){
            for(int i = 0; i < lengthA - lengthB; i++){
                curA = curA.next;
            }
        }
        while(curA != null && curB != null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }

8. 链表里是否有环        leetcode 141

快慢指针，while里条件和找中点一样，就是保证不越界，如果原链表就一个节点，且next不指向自己，while循环根本进不了。一定要先移动slow和fast再判断是否相等！！！！

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

9. 如果链表有环，找到环开始的节点        leetcode 142

上一题的扩展。首先让快慢指针一直走直到相遇，如果没相遇直接退出了，说明没有环，返回空。

如果有环，设链表总长度为n，环的长度为k，则链表头到环第一个节点长度为(n-k)。当快慢指针相遇时，快指针比慢指针多走的就是环的长度，因此慢指针走了k步，此时让慢指针和head头指针一起往后移动，当它们相遇时，就刚好在环的第一个节点，它们也必然相遇在环的第一个节点。因为当慢指针走了k步和快指针相遇后，再走(n-k)步，头指针也走(n-k)步，此时慢指针刚好走完n步，所以和头指针相遇在环的第一个节点。

    public ListNode detectCycle(ListNode head) {
        ListNode slow = head, fast = head;
        boolean find = false;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(slow == fast){
                find = true;
                break;
            }
        }
        if(!find){
            return null;
        }
        while(head != slow){
            head = head.next;
            slow = slow.next;
        }
        return slow;
    }