Leetcode链表专项

基础链表题目中常使用的一些方法，记录下来，方便复习翻看。

1. 链表的删除操作，比如删除链表中的重复元素(Leetcode 83)，删除链表中的某个节点(leetcode 10)等；
2. 链表的的合并，比如两个链表相加(leetcode 2)，合并两个有序链表(leetcode 21)等；
3. 判读链表中是否有环(leetcode 141)，链表的公共起点(leetcode 160)等；

链表的删除操作

1. 删除链表中的某个节点是个基本操作。链表的删除需要有两个指针，一个是当前遍历使用的cur指针，另一个是当前指针的前一个节点的指针pre。

ListNode* remove(ListNode* head, int val) /* 删除的值为val的节点 */
{
	if (!head) return nullptr;
	ListNode* cur = head;
	ListNode* pre;
	while (cur) {
		if (cur->val == val) {
			pre->next = cur->next;
			break;
		}
		pre = cur;
		cur = cur->next;
	}
}

2. 删除链表的倒数第n个节点，需要用到快慢针。这个题目和寻找链表的中点是同类型的题目。这道题的快慢指针和平时使用的快慢指针稍有不同。平时使用的快慢指针，是快指针每次走两步，而慢指针每次只走一步，如下：

/* 因为快指针走在前面，慢指针走过的节点都是快指针走过的，因此只需要检验快指针的有效性即可 */
while(fast->next) { 
fast = fast->next->next;
slow = slow->next;
}

而本题使用的“快满指针”稍有区别，使用上面的快慢指针的方法是无法通过一次遍历就找到的。如果快指针先走N步，然后慢指针和快指针再以相同的速度往前走，当快指针走到链表尾部，那么慢指针走到的那个节点则正好是需要删除的节点。

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* tmp_head = head;
        ListNode* fast = head;
        ListNode* slow = head;
        ListNode* ptr = head;
        while (n > 1) {
            fast = fast->next; /* 先让快指针先走n步 */
            n--;
        }
        
        if  (fast->next) {
            while (fast->next) { /* 慢指针再从头节点出发，快指针和慢指针以相同的速度往前走 */
                fast = fast->next;
                ptr = slow; /* 用来记录慢指针当前节点的前一个节点，和上面1的操作相同 */
                slow = slow->next;
            }
        } else {
            head = head->next;
        }
        
        ptr->next = slow->next; /* 删除节点 */
        return head;
    }

合并链表

合并两个有序(升序)链表，一种方法是开辟一个新的空间，然后两个链表的节点双双比较。

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == nullptr || l2 == nullptr) {
            return l1 == nullptr ? l2 : l1;
        }
        ListNode* new_list = new ListNode(-1);
        ListNode* head = new_list;
        while (l1 && l2) {
            if (l1->val <= l2->val) {
                new_list->next = new ListNode(l1->val);
                l1 = l1->next;
            } else {
                new_list->next = new ListNode(l2->val);
                l2 = l2->next;
            }
            new_list = new_list->next;
        }
        if (l1) {
            new_list->next = l1;
        }

        if (l2) {
            new_list->next = l2;
        }
        return head->next;
    }

另外一种方法是使用递归，不需要开辟新的空间。

    ListNode* mergeNode(ListNode* l1, ListNode* l2)
    {
        if (!l1) return l2;
        if (!l2) return l1;
        if (l1->val <= l2->val) {
            l1->next = mergeNode(l1->next, l2);
            return l1;
        } else {
            l2->next = mergeNode(l1, l2->next);
            return l2;
        }
    }
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == nullptr || l2 == nullptr) {
            return l1 == nullptr ? l2 : l1;
        }

        return mergeNode(l1, l2);
    }

合并K个升序链表。可以使用优先队列(小顶堆)将每个链表先按照头结点的大小放入队列中，然后每次取出堆顶的节点，并插入链表中即可。需要重新定义新的数据类型，并重载运算符。

    struct Node {
        int val;
        ListNode* ptr;
        bool operator < (const Node& rhs) const {
            return rhs.val < val;
        }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if (lists.empty()) {
            return nullptr;
        }
        // cout << lists.size() << endl;
        /* 使用优先队列 */
        priority_queue<Node> que;
        for (auto elem : lists) {
            if (elem) {
                que.push({elem->val, elem});
            }
        }

        ListNode* head = new ListNode(-1);
        ListNode* tmp = head;
        while (!que.empty()) {
            auto node = que.top(); /* 取出堆顶节点 */
            que.pop();
            tmp->next = node.ptr; /* 插入链表中 */
            tmp = tmp->next;
            if (node.ptr->next) { /* 再将新的节点插入队列中 */
                que.push({node.ptr->next->val, node.ptr->next});
            }
        }
        return head->next;
    }

判断链表中是否有环

判断链表中是否有环，可以使用快慢指针，当两个指针相遇了，那么就说明链表中有环。

    bool hasCycle(ListNode *head) {
        if (!head) {
            return false;
        }
        ListNode* first = head;
        ListNode* second = head->next;

        while (first && second) {
            if (first == second) {
                return true;
            }

            first = first->next;
            if (second->next != nullptr) { /* 需要注意的是，second指针走的快些，因此要判断second->next指针是否为空 */
                second = second->next->next; 
            } else {
                return false;
            }
        }
        return false;
    }