链表相关题目

爱吃香菜和葱

已于 2022-08-26 20:54:15 修改

阅读量274

点赞数

分类专栏： leetcode 数据结构&&算法文章标签：链表数据结构

于 2022-01-19 09:42:10 首次发布

本文链接：https://blog.csdn.net/qq_41648804/article/details/122573958

版权

剑指 Offer 22. 链表中倒数第k个节点

快慢指针和翻转链表模板

ListNode* reverse(ListNode* curr){
    //从curr开始翻转链表
    //返回值pre即为翻转后的头节点
    ListNode *pre = nullptr;
    while(curr){
        ListNode* next = curr->next;
        curr->next = pre;
        pre = curr;
        curr = next;
    }
    return pre;
}

ListNode* slow_fast(ListNode* head){
    //通过快慢指针寻找中点
    //slow指向的是中点之后的那个节点即num/2+1处
    ListNode* slow = head, *fast = head;
    while(fast != tail){
        slow = slow->next;
        fast = fast->next;
        if(fast != tail){
            fast = fast->next;
        }
    }
    return slow;
}

141. 环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。否则，返回 false 。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        //使用快慢指针
        ListNode *p = head, *q = head;
        while(p != NULL && q != NULL){
            p = p->next;
            q = q->next;
            if(q != NULL) q = q->next;
            if(p != NULL && q != NULL && p == q) return true;
        }
        return false;
    }
};

142. 环形链表 II

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改链表。

示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //********----
        //环外长度为p，环内长度为q，两者相遇处即为从链表起始点开始的距离为q节点，此时只需要再引入一个节点从头结点处开始与链表起始点开始的距离为q节点
        //同时向右移动，相遇处即为循环开始的地方
        ListNode *p = head, *q = head;
        while(p != NULL && q != NULL){
            p = p->next;
            q = q->next;
            if(q != NULL) q = q->next;
            //若判断成功，说明是循环链表
            if(p != NULL && q != NULL && p == q) break;
        }
        //非循环链表
        if(q == NULL) return q;
        p = head;
        while(p != q){
            p = p->next;
            q = q->next;
        }
        return q;
    }
};

148. 排序链表

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

示例 1：

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

#include "bits/stdc++.h"

using namespace std;


/**
 * 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* sortList(ListNode* head) {
        //按照归并排序的思路，即可完成，时间复杂度均为O(n log n)
        //若使用自上而下的递归，需要O(log n)的空间复杂度;若使用自下而上的思路，只需要O(1)复杂度
        return Msort(head, nullptr);
    }
    ListNode* Merge(ListNode* p, ListNode* q){
        //合并链表节点p以及q部分链表，并返回合并之后头节点的指针
        ListNode* empty_head = new ListNode(0);
        ListNode* temp_1 = p, *temp_2 = q, *temp = empty_head;
        while(temp_1 != nullptr && temp_2 != nullptr){
            if(temp_1->val <= temp_2->val){
                temp->next = temp_1;
                temp_1 = temp_1->next;
            }else{
                temp->next = temp_2;
                temp_2 = temp_2->next;
            }
            temp = temp->next;
        }
        if(temp_1 != nullptr) temp->next = temp_1;
        if(temp_2 != nullptr) temp->next = temp_2;
        return empty_head->next;
    }
    ListNode* Msort(ListNode* head, ListNode* tail){
        //包含head而不包含tail
        //排序head---tail（尾节点的next）部分,并返回sort之后的头节点指针
        if(head == nullptr) return head;
        if(head->next == tail){
            //当前只有一个节点，直接返回即可
            //一定要将当前head节点和tail之间断开，否则后续排序有问题
            head->next = nullptr;
            return head;
        }
        //通过快慢指针寻找中点
        ListNode* slow = head, *fast = head;
        while(fast != tail){
            slow = slow->next;
            fast = fast->next;
            if(fast != tail){
                fast = fast->next;
            }
        }
        ListNode* mid = slow;
        //所以Msort第二部分的起始节点为mid
        return Merge(Msort(head, mid), Msort(mid, tail));
    }
    ListNode* sortList_no_recursion(ListNode* head){
        //使用自下而上的思路完成
        int length = 0;
        ListNode *p = head;
        while(p){
            length += 1;
            p = p->next;
        }
        ListNode* empty_head = new ListNode(0, head);
        for(int sub_length = 1; sub_length < length; sub_length <<= 1){
            //归并排序，按照每段大小为sub_length进行归并为长度2×sub_length段
            //prev指向待排序子串的前一个，curr指向当前待排序子串
            ListNode* prev = empty_head, *curr = empty_head->next;
            while(curr != nullptr){
                ListNode* head_1 = curr;
                for(int i = 1; i < sub_length && curr != nullptr; i++){
                    curr = curr->next;
                }
                ListNode* head_2 = nullptr;
                if(curr != nullptr){
                    //防止越界访问
                    head_2 = curr->next;
                    curr->next = nullptr;//将两个子段分割开
                }
                curr = head_2;
                //继续寻找下一个可以切割段的地方
                for(int i = 1; i < sub_length && curr != nullptr; i++){
                    curr = curr->next;
                }
                ListNode* next = nullptr;//指向下一处要分段的地方
                if(curr != nullptr){
                    next = curr->next;
                    curr->next = nullptr;
                }
                ListNode* merged = Merge(head_1, head_2);
                prev->next = merged;
                while(prev->next != nullptr){
                    prev = prev->next;
                }
                curr = next;
            }
        }
        return empty_head->next; 
    }

};

160. 相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须保持其原始结构。

自定义评测：

评测系统的输入如下（你设计的程序不适用此输入）：

intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被视作正确答案。

示例 1：

最低0.47元/天解锁文章

爱吃香菜和葱

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
链表相关题目

141. 环形链表给你一个链表的头节点 head ，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。如果链表中存在环，则返回 true 。否则，返回 false 。示例 1：输入：head = [3,2,0,-4],
复制链接

扫一扫