链表总结1-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_51147313/article/details/145322278

反转，调换

都需要dummy节点
交换逻辑差不多，都需要多指针，关键是如何初始化指针和返回指针以及迭代过程

206 反转链表

在这里插入图片描述

/**
 * 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* reverseList(ListNode* head) {
        if(head==nullptr) return head;
        ListNode* cur = head;
        ListNode* pre = nullptr;
        while(cur){
            ListNode* nex = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nex;
        }
        return pre;
    }
};

24 两两交换链表中的节点

题目连接
在这里插入图片描述

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        // 如果链表为空或者只有一个节点，直接返回
        if (head == nullptr || head->next == nullptr) return head;
        
        // 创建一个虚拟头节点，方便处理头节点交换
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        
        ListNode* cur = dummy;
        
        // 交换链表中的每一对节点
        while (cur->next != nullptr && cur->next->next != nullptr) {
            ListNode* first = cur->next;        // 当前节点
            ListNode* second = cur->next->next; // 下一个节点
            
            // 交换这两个节点
            first->next = second->next;
            second->next = first;
            cur->next = second;
            
            // 移动指针
            cur = first;
        }
        
        // 返回新的头节点
        return dummy->next;
    }
};

简化

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        ListNode* newHead = head->next;
        head->next = swapPairs(newHead->next);
        newHead->next = head;
        return newHead;
    }
};

25 k个一组翻转链表

题目连接
在这里插入图片描述

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        // 如果链表为空或者k为1，直接返回链表
        if (head == nullptr || k == 1) return head;
        
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        
        ListNode* pre = dummy; // `pre` 是反转块之前的节点
        ListNode* cur = head;
        
        int count = 0;
        while (cur) {
            count++;  // 当前节点的计数
            
            // 每当计数达到k，进行反转
            if (count % k == 0) {
                ListNode* next = cur->next;  // 保存反转块后的节点
                pre = reverse(pre, next);  // 执行反转，并更新pre
                cur = next;  // 继续处理下一个块
            } else {
                cur = cur->next;  // 继续遍历
            }
        }
        
        return dummy->next;  // 返回链表的头节点
    }

    // 反转k个节点，返回反转后尾节点的next（即原来块的下一个节点）
    ListNode* reverse(ListNode* pre, ListNode* next) {
        ListNode* last = pre->next;  // 记录反转前第一个节点
        ListNode* cur = last->next;  // 从第二个节点开始反转
        while (cur != next) {
            last->next = cur->next;  // 将反转节点移除
            cur->next = pre->next;   // 将cur节点插入pre节点之后
            pre->next = cur;         // 更新pre的next指针
            cur = last->next;        // 继续处理下一个节点
        }
        return last;  // 返回反转后的块尾节点（就是原来第一个节点）
    }
};

合并，排序

148 排序链表

给你链表的头结点 head ，请将其按升序排列并返回排序后的链表。

示例 1：

输入：head = [4,2,1,3]
输出：[1,2,3,4]
示例 2：

输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]
示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目在范围 [0, 5 * 104] 内
-105 <= Node.val <= 105

进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？

思路

哈希表

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if (!head) return nullptr;  // 添加空指针检查
        
        ListNode* dummy = new ListNode(0);
        ListNode* cur = head;
        // 删除未使用的 min 变量
        vector<pair<int,ListNode*>> res;
        
        // 收集所有节点
        while(cur) {
            res.push_back({cur->val, cur});
            cur = cur->next;
        }
        
        // 根据节点值排序
        sort(res.begin(), res.end());
        
        dummy->next = res[0].second;
        cur = res[0].second;
        for(int i = 1; i < res.size(); i++){
            cur->next = res[i].second;
            cur = cur->next;
        }
        
        // 设置最后一个节点的next为nullptr
        cur->next = nullptr;
        
        // 获取结果并释放dummy节点
        ListNode* result = dummy->next;
        delete dummy;
        
        return result;
    }
};

归并排序，使用快慢指针找中心点，快指针只负责索引，归并的过程就是合并两个有序链表

class Solution {
public:
   ListNode* sortList(ListNode* head) {
       if (!head || !head->next) return head;
       
       ListNode *fast = head->next, *slow = head;
       while (fast && fast->next) {
           slow = slow->next;
           fast = fast->next->next;
       }
       
       ListNode* tmp = slow->next;
       slow->next = nullptr;
       
       ListNode* left = sortList(head);
       ListNode* right = sortList(tmp);
       
       ListNode* h = new ListNode(0);
       ListNode* res = h;
       
       while (left && right) {
           if (left->val < right->val) {
               h->next = left;
               left = left->next;
           } else {
               h->next = right;
               right = right->next;
           }
           h = h->next;
       }
       
       h->next = left ? left : right;
       return res->next;
   }
};