LeetCode算法练习——链表（二）

LeetCode23. 合并K个排序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

思路：

• 将多条链表中的每个节点值压入同一个容器；
• 对这些容器内的元素进行排序；
• 最后将容器内的元素串联成链表。

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        vector<int> tmp;
        ListNode* head;
        ListNode* p = new ListNode(0);
        ListNode* q = p;
        for(int i = 0; i < lists.size(); i++){
            head = lists[i];
            while(head){
                tmp.push_back(head->val);
                head = head->next;
            } 
        }
        if(tmp.size()==0)
            return NULL;
        sort(tmp.begin(), tmp.end());
        for(int i = 0; i < tmp.size(); i++){
            p->next = new ListNode(0);
            p = p->next;
            p->val = tmp[i];
        }  
        return q->next;
    }
};

LeetCode24. 两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:

给定 1->2->3->4, 你应该返回 2->1->4->3.

我们需要定义三个节点，第一个节点记录当前节点，第二个节点记录当前节点的下一个节点，第三个节点为最后返回的头节点，first->next = second->next;second->next = first;对相邻节点进行两两交换，并定义一个tmp临时记录first节点，用来处理节点总数为奇数的情况。

lass Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head==NULL)
            return head;                    //空的就直接返回
        ListNode *first = head;             //记录当前节点
        ListNode *second = first->next;     //记录当前节点的下一个节点
        ListNode *ans = second;             //最后返回的头节点
        if(second==NULL)                    //只有一个节点也直接返回
            return head;
        while(1){
            first->next = second->next;
            second->next = first;
            ListNode *tmp = first;
            if(first->next != NULL){
                first = first->next;
                second = first->next;
            }
            else    break;
            if(second != NULL)  tmp->next = second;
            else    break;
        }
        return ans;
    }
};

LeetCode25. K 个一组翻转链表

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例：

给你这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

思路：按k切割链表-->区域链表进行反转-->链表串联；此题是链表的综合运用，我们需要实时关注头指针的变化。

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode *pre = dummy;
        ListNode *cur = head;
        ListNode *tail = dummy;
        while(true){
            int count = 0;
            //tail = pre; 
            while(tail && count < k){               //链表切割
                tail = tail->next;
                count++;
            }
            if(tail == NULL)    break;              //区域长度小于k，不翻转
            while(pre->next != tail){               //链表反转，tail为区域链表的尾结点
                cur = pre->next;                    //当前节点位置移动
                pre->next = cur->next;              //前一个节点的next指向当前节点的next
                cur->next = tail->next;             //当前节点的next指向尾结点的next
                tail->next = cur;                   //尾结点的next指向当前节点
            }                                       //翻转完，head变成k区间的最后一个节点
            pre = head;                             
            tail = head;
            head = pre->next;                       //重新定义各个指针，串联链表
        }
        return dummy->next;
    }
};