Leetcode 链表

1、Linked List Cycle
链接：https://leetcode.com/problems/linked-list-cycle/
思路：fast、slow两个指针，fast走两步，slow走一步，若有环，fast和slow都进入环，必然相遇；若fast == null || fast.next == null，无环

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

2、Linked List Cycle II
链接：https://leetcode.com/problems/linked-list-cycle-ii/
思路：碰撞点p到连接点的距离=头指针到连接点的距离，因此，分别从碰撞点、头指针开始走，相遇的那个点就是连接点。

    public ListNode detectCycle(ListNode head) {
        if(head == null || head.next == null)
            return null;
        ListNode temp = head, fast = head, slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                temp = head;
                while(temp != slow){
                    temp = temp.next;
                    slow = slow.next;
                }
                return temp;
            }
        }
        return null;
    }

3、Remove Duplicates from Sorted List
链接：https://leetcode.com/problems/remove-duplicates-from-sorted-list/
思路：遍历一次，相邻值相同，删除

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

4、Rotate List
链接：https://leetcode.com/problems/rotate-list/
思路：遍历一遍链表，记录长度，将尾部执行头部，然后与k比较

    public ListNode rotateRight(ListNode head, int k) {
        if(head == null || head.next == null || k == 0)
            return head;
        int count = 1;
        ListNode temp = head;
        while(temp.next != null){
            temp = temp.next;
            count++;
        }
        temp.next = head;
        int flag = count - k%count;
        for(int i = 0; i < flag; i++)
            temp = temp.next;
        ListNode newhead = temp.next;
        temp.next = null;
        return newhead;
    }

5、Remove Duplicates from Sorted List II
链接：https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/
思路：使用递归思想，删除重复节点。

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

6、Partition List
链接：https://leetcode.com/problems/partition-list/
思路：新建一个头指针指向head，p指向大于等于x的第一个值，遍历链表，将小于x的节点插入p的前面。

    public ListNode partition(ListNode head, int x) {
        if(head == null || head.next == null)
            return head;
        ListNode new_head = new ListNode(-1);
        new_head.next = head;
        ListNode p = new_head, q = head, temp;
        while(p.next != null && p.next.val < x){
            p = p.next;
        }
        q = p;
        while(q.next != null){
            if(q.next.val < x){
                temp = q.next;
                q.next = temp.next;
                temp.next = p.next;
                p.next = temp;
                p = p.next;
            }else {
                q = q.next;
            }
        }
        return new_head.next;
    }

7、Swap Nodes in Pairs
链接：https://leetcode.com/problems/swap-nodes-in-pairs/
思路：采用递归思想，交换前后两个节点

    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null)
            return  head;
        ListNode q = head.next;
        head.next = swapPairs(q.next);
        q.next = head;
        return q;
    }

8、Merge Two Sorted Lists
链接：https://leetcode.com/problems/merge-two-sorted-lists/
思路：两个链表合并，遍历，比较大小。

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null)
            return l2;
        if(l2 == null)
            return l1;
        ListNode head, p = l1, q = l2, r;
        if(p.val <= q.val){
            head = p;
            p = p.next;
        }else{
            head = q;
            q = q.next;
        }
        r = head;
        while(p != null && q != null){
            if(p.val <= q.val){
                r.next = p;
                p = p.next;
            }else{
                r.next = q;
                q = q.next;
            }
            r = r.next;
        }
        r.next = (p != null) ? p: q;
        return  head;
    }

9、remove nth node from end of list
链接：https://leetcode.com/problems/remove-nth-node-from-end-of-list/
思路：两个指针，pre先移动N步，q指向头部；之后pre移动一步，q移动一步

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

10、单链表反转

    public ListNode reverse(ListNode head) {
        if(head == null)
            return head;
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode pre = dummy.next, pcur = pre.next;
        while(pcur != null){
            pre.next = pcur.next;
            pcur.next = dummy.next;
            dummy.next = pcur;
            pcur = pre.next;
        }
        return dummy.next;
    }

11、Reverse Linked List II
链接：https://leetcode.com/problems/reverse-linked-list-ii/
思路：pre指向反转的前一个节点，front指向反转的第一个节点，last指向当前反转的最后一个节点，last指向反转序列后面的第一个节点。前插法反转链表

    public ListNode reverseBetween(ListNode head, int m, int n) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        head = dummy;
        for (int i = 1; i < m; i++) {
            head = head.next;
        }
        ListNode pre = head;
        ListNode front = head.next;
        ListNode last = front, q = front.next;
        for (int i = m; i < n; i++) {
            ListNode temp = q.next;
            q.next = last;
            last = q;
            q = temp;
        }
        front.next = q;
        pre.next = last;
        return dummy.next;
    }