LeetCode 刷题【24. 两两交换链表中的节点、25. K 个一组翻转链表】

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

自己做

解：直接置换

cpp 复制代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        
        ListNode *p = head;

        if(p == nullptr)                //空链表
            return nullptr;

        if(p->next == nullptr)          //只有一个元素
            return head;

        //先交换前两位
        ListNode *q = p->next; 
        ListNode *r = q->next;

        p->next = r;               
        q->next = p;
        head = q;       //更新头指针指向的结点
        
        q = p->next;
        if(q != nullptr)
            r = q->next;
        else
            r = nullptr;

        //三英杰就位，交换？启动！
        while(r != nullptr){
            //交换
            p->next = r;
            q->next = r->next;
            r->next = q;

            //更新pqr位置
            p = q;
            q = p->next;

            if(q == nullptr)
                break;

            r = q->next;

        }
        
        return head;

    }
};

25. K 个一组翻转链表

自己做

解：头插反转合并

cpp 复制代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode *p = head;
        ListNode *r = new ListNode();       //头插
        
        //统计链表长度
        int len = 0;
        while(p != nullptr){
            p = p->next;
            len++;
        }

        if(len < k)               //连一组k都凑不出来
            return head;
        
        if(k == 1)                  //不用交换
            return head;

        //先处理第一组
        p = head;                   //重置指针p（上面用来统计长度了）
        ListNode *q = p->next;
        ListNode *tail = p;                //重新排序好的链表尾指针
        for(int i = 0; i < k; i++){     
            p->next = r->next;          //头插
            r->next = p;

            p = q;
            if(p != nullptr)
                q = q->next;
        }

        head = r->next;                 //重置头结点

        len -= k;                       //长度更新（这个长度表示剩下要排序的元素个数）

        while(len >= k){
            r->next = nullptr;          //重置头插链表
            ListNode *end = p;          //end指向头插链表的尾部

            for(int i = 0; i < k; i++){     
                p->next = r->next;          //头插
                r->next = p;

                p = q;
                if(p != nullptr)
                    q = q->next;
            }

            //现在r指向的头插链表又填装好了，p也指向了下一组的起始位置
            tail->next = r->next;           //反转的部分和原先的链表合并（head指向的）
            tail = end;                     //更新tail

            len -= k;                   //更新长度
        }

        //凑不成一组的部分合并
        tail->next = p;

        return head;

    }
};