[leetcode] Summary of Linked List (1)

今天总结leetcode上那些与Linked List有关的题目。

1. Reverse Linked List

题目大意：将单链表反转（可以分别考虑递归和迭代的方式）

基本思路：

（1）递归方式，对于某个待反转的list，先递归调用函数得到list->next的反转，然后将list节点加到list->next节点之后即可。注意递归出口会返回反转后的链表的头指针，原始链表的头指针变成了最后一个节点，一定要置空。

ListNode* reverseList(ListNode* head) {
        if(NULL == head || NULL == head->next) 
        {
            return head;
        }
        ListNode *newHead = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return newHead;
    }

（2）迭代方式基本方法类似，不再赘述。

ListNode* reverseList(ListNode* head) {
        if(NULL == head || NULL == head->next) 
        {
            return head;
        }
        ListNode *ptr = head->next;
        head->next = NULL;
        while(ptr)
        {
            ListNode *tmp = ptr->next;
            ptr->next = head;
            head = ptr;
            ptr = tmp;
        }
        return head;
    }

2. Reverse Linked List II

题目大意：与1不同的是，这里不仅给出一个list，还给出它的两个位置m和n (1 ≤ m ≤ n ≤ length of list.)，要求只反转m和n之间的部分节点。且要求in-place和one-pass

基本思路：我的方法并没有高明到哪里去，只是简单的遍历，遇到m与n之间的节点就进行反转，需要注意的是m和n之间这部分的头和尾部分最后需要与原始链表连上。

ListNode *reverseBetween(ListNode *head, int m, int n) {
        ListNode *pre = NULL, *next, *ptr;
        ListNode *pPre = NULL, *ptail, *phead;
        ptr = head;
        int cnt = 1;
        while(ptr)
        {
            if(cnt >= m && cnt <= n)
            {
                if(cnt == m) ptail = ptr;
                if(cnt == n) phead = ptr;
                next = ptr->next;
                if(pPre) ptr->next = pPre;
                pPre = ptr;
                ptr = next;
            } else if(cnt < m){
                pre = ptr;
                ptr = ptr->next;
            } else {
                ptr = ptr->next;
            }
            ++cnt;
        }
        if(pre)
        {
            pre->next = phead;
            ptail->next = next;
        } else {
            head = phead;
            ptail->next = next;
        }
        return head;
    }

3. Remove Nth Node From End of List

题目大意：删除链表的倒数第n个节点，题目保证n是有效的，要求只遍历链表一次。

基本思路：维持一个快指针和一个慢指针，快指针在最开始的时候比慢指针多走n步，这样当快指针到达终点时，慢指针就到达了要删除的节点。由于删除操作需要知道被删除节点的前一个节点（当然不知道的情况下也可以做，参见一道题），所以我们就让快指针到达链表终点时慢指针恰好在被删除节点的前一个节点上。那么问题来了，如果被删除的是头节点怎么办？所以要在头节点前面添加一个空节点。

ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head == NULL) return head;
        ListNode *empty = new ListNode(0);
        empty->next = head;
        ListNode *slow = empty;
        ListNode *fast = head;
        while(fast != NULL && n > 0)
        {
            fast = fast->next;
            --n;
        }
        while(fast)
        {
            fast = fast->next;
            slow = slow->next;
        }
        fast = slow->next;
        slow->next = fast->next;
        delete(fast);
        head = empty->next;
        delete(empty);
        return head;
    }

4. Delete Node in a Linked List

题目大意：只给出指向链表中某个节点的指针，要求删除该节点。注意题目中强调了一点：这个节点不可能是尾节点。

基本思路：一看题目连链表的头指针都不给，还强调不可能删尾节点，我们就可以使用换val的策略了。就是把要删除的节点的next节点的值拷贝到该节点处，然后删掉next节点。

void deleteNode(ListNode* node) {
        if(node == NULL) return;
        node->val = node->next->val;
        ListNode *tmp = node->next;
        node->next = node->next->next;
        delete(tmp);
    }

5. Palindrome Linked List

题目大意：判断给定的链表是否是回文的。最好是O（n）的时间和O（1）的空间。

基本思路：维持一个快指针和一个慢指针，慢指针每次走一步，快指针每次走两步，这样快指针到终点的时候慢指针恰好到中点，这样就可以很容易将这个链表分成等长的两个部分。为了判断是否回文，就是前半段的逆序与后半段的正序是否一致。所以只要在慢指针移动的同时将前半部分的链表反转即可。

bool compareTwoLists(ListNode* head1, ListNode *head2) {
        ListNode *ptr1 = head1;
        ListNode *ptr2 = head2;
        if(NULL == ptr1 && NULL == ptr2) return true;
        while(ptr1 && ptr2)
        {
            if(ptr1->val != ptr2->val) return false;
            ptr1 = ptr1->next;
            ptr2 = ptr2->next;
        }
        if(NULL != ptr1 || NULL != ptr2) return false;
        else return true;
    }
    
    bool isPalindrome(ListNode* head) {
        if(head == NULL || head->next == NULL) return true;
        ListNode *slow = head;
        ListNode *fast = head;
        ListNode *pre = NULL;
        
        while(fast && fast->next)
        {
            fast = fast->next->next;
            
            ListNode *tmp = slow->next;
            slow->next = pre;
            pre = slow;
            slow = tmp;
        }
        ListNode *list1 = pre;
        ListNode *list2 = slow;
        if(fast != NULL) list2 = slow->next; 
        return compareTwoLists(list1, list2);
    }

6. Intersection of Two Linked Lists

题目大意：判断两个链表相交的交点。

基本思路：分别遍历两个链表一次，找到各自的长度m和n；然后让长度较大的那个链表的指针先走abs(m-n)步，然后两个指针一起走，快指针到终点时慢指针恰好在交点的位置。

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(NULL == headA) return headA;
        if(NULL == headB) return headB;
        int lenA = 0, lenB = 0;
        ListNode *pA = headA, *pB = headB;
        while(pA)
        {
            ++lenA;
            pA = pA->next;
        }
        while(pB)
        {
            ++lenB;
            pB = pB->next;
        }
        pA = headA;
        pB = headB;
        while(lenA > lenB)
        {
            --lenA;
            pA = pA->next;
        }
        while(lenB > lenA)
        {
            --lenB;
            pB = pB->next;
        }
        while(pA && pB)
        {
            if(pA == pB) return pA;
            pA = pA->next;
            pB = pB->next;
        }
        ListNode *ret = NULL;
        return ret;

7. Remove Linked List Elements

题目大意：删除链表中节点值等于指定元素的所有节点。

基本思路：遍历一遍，删除该删的节点。需要注意的是头节点需要单独处理，所以可以添加一个哨兵节点在头结点之前。

ListNode* removeElements(ListNode* head, int val) {
        if(head == NULL) return head;
        ListNode *empty = new ListNode(0);
        empty->next = head;
        ListNode *ptr = empty;
        while(ptr->next)
        {
            if(ptr->next->val == val)
            {
                ListNode *tmp = ptr->next;
                ptr->next = tmp->next;
                delete(tmp);
            } else ptr = ptr->next;
        }
        head = empty->next;
        delete(empty);
        return head;
    }

8. Linked List Cycle

题目大意：判断一个链表中是否有环，O（1）的空间复杂度。

基本思路：假设链表中存在环，我们让一个慢指针和一个快指针（每次走两步）一起出发的话，快指针最终肯定会追上慢指针。

bool hasCycle(ListNode *head) {
        if(head == NULL) return false;
        ListNode *fast = head;
        ListNode *slow = head;
        while(fast->next != NULL && fast->next->next != NULL)
        {
            slow = slow -> next;
            fast = fast->next->next;
            if(fast == slow) return true;
        }
        return false;
    }

9. Linked List Cycle II

题目大意：不仅要判断链表中是否有环，还要指出环开始的位置。

基本思路：下面我们来简单分析一下8中快慢指针相遇的位置与环的开始位置的关系。

为简单起见，我们假设快指针比慢指针多走了一圈（可以画图，更容易看出来）。假设链表的环长为L，根据快慢指针的相遇位置和环的起始位置我们可以把环分为两个部分：从起始点到相遇点长度为L1，从相遇点到起始点长度为L2（注意这里的距离都是沿着链表的方向算的）。链表的非环部分长度为N。

那么相遇的时候快指针走的长度为N+L1+L2+L1， 慢指针走的长度为N+L1，其中N+L1+L2+L1=2（N+L1），所以有L2 = N。也就是从相遇点到起点的距离与从链表头到起点的距离是相等的。

上面是特例，我们再来看看，如果快指针比慢指针多走了x圈，会不会有类似的等式呢？

N + x*(L1+L2) + L1 = 2 * (N + L1)

x*(L1+L2) = N + L1

(x-1)(L1+L2) + L2 = N

这个式子又是什么意思呢？右边N表示从链表头结点到环的起点，左边L2表示从相遇点到环的起点，左边(x-1)(L1+L2)表示要在还上转x-1圈。

所以结论就是，我们先通过8的方法找到快指针和慢指针的相遇点，然后让慢指针在相遇点不动，快指针回到链表起点，然后让快慢指针一起一步一步地走，当他们相遇时，一定都是处于环的起点。

ListNode *detectCycle(ListNode *head) {
        if(head == NULL) return NULL;
        ListNode *fast = head;
        ListNode *slow = head;
        
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast) break;
        }
        if(fast == NULL || fast->next == NULL) return NULL;
        fast = head;
        while(fast != slow)
        {
            fast = fast->next;
            slow = slow->next;
        }
        return slow;
    }