链表问题汇总

最新推荐文章于 2024-05-11 21:25:28 发布
最新推荐文章于 2024-05-11 21:25:28 发布
阅读量165 收藏 2
点赞数
分类专栏： 链表 LeetCode 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42438346/article/details/119926718
版权

在这里插入图片描述

//快慢指针
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL)
            return head;
        ListNode* pre = NULL, *cur = head, *tmp;

        while(cur != NULL){
            tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }

        return pre;

    }
};

//递归
class Solution {
public:
    ListNode* reverse(ListNode* pre, ListNode* cur){
        if(cur == NULL){
            return pre;
        }
        ListNode* tmp = cur->next;
        cur->next = pre;
				
				// 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur, tmp);
    }
    ListNode* reverseList(ListNode* head) {
        if(head == NULL)
            return head;
				
				// 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }
};

在这里插入图片描述

设置虚拟头结点的作用：
移除了一个头结点，是不是发现，在单链表中移除头结点 和 移除其他节点的操作方式是不一样，其实在写代码的时候也会发现，需要单独写一段逻辑来处理移除头结点的情况。

设置虚拟头结点后， 原链表的所有节点就都可以按照统一的方式进行移除了。

//快慢指针
//fast先走n+1步，然后slow开始同步走
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;

        ListNode* fast = dummyHead, *slow = dummyHead;
        for(int i = 0; i <= n ; i++)
            fast = fast->next;
        
        
        while(fast != NULL){
            fast = fast->next;
            slow = slow->next;
        }

        ListNode* del = slow->next;
        slow->next = del->next;
        delete del;
        ListNode* ret = dummyHead->next;
        delete dummyHead;

        return ret;
    }
};

在这里插入图片描述

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* cur = dummyHead->next;
        ListNode* pre = dummyHead;

        while(cur != NULL){
            if(cur->val == val){
                ListNode* del = cur;
                pre->next = cur->next;
                cur = pre->next;
                delete del;
            }
           else{
               pre = cur;
               cur = cur->next;
           } 
            
        }

        ListNode* ret = dummyHead->next;
        delete dummyHead;

        return ret;
    }
};

在这里插入图片描述

题解：https://leetcode-cn.com/problems/reorder-list/solution/dong-hua-yan-shi-kuai-man-zhi-zhen-143-z-4kmk/

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* slow = head;
        ListNode* fast = head;

        while(fast != NULL && fast->next != NULL){
            fast = fast->next->next;
            slow = slow->next;
        }

        return slow;
    }
};

在这里插入图片描述

class Solution {
public:
    bool hasCycle(ListNode *head) {
        
        ListNode* slow = head, *fast = head;

        while(fast && fast->next){
            slow = slow->next;
            fast = fast->next->next;

            if(fast == slow) return true;
        }

        return false;
    }
};

设置快慢指针，慢指针每走一步，快指针走两步，如果存在环，则快指针肯定会先走进环，慢指针后进入环。
又因为快指针走的比慢指针快，故二者终会相邻，然后再慢指针走一步，快指针走两步，二者就会相遇。

在这里插入图片描述

1.找到链表中间结点（若结点个数为偶数个，则返回中间第一个结点）
2.反转中间结点后面的链表
3.将链表前半部分和反转后的后半部分进行合并
题解：https://leetcode-cn.com/problems/reorder-list/solution/dong-hua-yan-shi-kuai-man-zhi-zhen-143-z-4kmk/

class Solution {
public:
    ListNode* findMin(ListNode* head){
        ListNode* slow = head, *fast = head;
        while(fast->next != NULL && fast->next->next != NULL){
            fast = fast->next->next;
            slow = slow->next;
        }

        return slow; //为偶数个的话，返回中间两个结点的前面一个
    }

    ListNode* reverseList(ListNode* head){
        ListNode* pre = NULL, *cur = head, *tmp;
        while(cur != NULL){
            tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }

        return pre;
    }

    void mergeList(ListNode* head1, ListNode* head2){
        ListNode* next1 = NULL, *next2 = NULL;

        while(head1 != NULL && head2 != NULL){
            next1 = head1->next;
            next2 = head2->next;

            head1->next = head2;
            head1 = next1;

            head2->next = head1;
            head2 = next2;
        }
    }

    void reorderList(ListNode* head) {
        if(head == NULL)
            return;
        
        ListNode* mid = findMin(head);

        //中间结点后面的部分进行反转
        ListNode* head2 = mid->next;
        mid->next = NULL;
        head2 = reverseList(head2);

        ListNode* head1 = head;
        mergeList(head1, head2);

    }
};

在这里插入图片描述

  1. 先求链表长度，若k大于链表长度，则用k对长度取余。
  2. 求倒数第k个结点的前一个结点
  3. 让倒数第k个结点成为头结点
    题解：https://leetcode-cn.com/problems/rotate-list/solution/dong-hua-yan-shi-kuai-man-zhi-zhen-61-xu-7bp0/
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(k == 0 || head == NULL)
            return head;
        ListNode* tmp = head;
        int cnt = 0;
        while(tmp != NULL){
            cnt++;
            tmp = tmp->next;
        }
        k = k % cnt;



        ListNode* slow = head, *fast = head, *fastPre = head;

        for(int i = 0; i < k+1; i++)
            fast = fast->next;
        
        for(int i = 0; i < k; i++)
            fastPre = fastPre->next;
        
        while(fast != NULL){
            fast = fast->next;
            slow = slow->next;
            fastPre = fastPre->next;
        }

        fastPre->next = head;
        head = slow->next;
        slow->next = NULL;



        return head;
        

    }
};

在这里插入图片描述
在这里插入图片描述

//归并排序
//空复O(logn) 时复O(nlogn)
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(head == NULL || head->next == NULL) return head;
        
        ListNode* slow = head, *fast = head;
        
        while(fast->next != NULL && fast->next->next != NULL){
            slow = slow->next;
            fast = fast->next->next;
        }
        
        ListNode* rightHead = slow->next;
        slow->next = NULL;  //cut
        
        ListNode* left = sortList(head);
        ListNode* right = sortList(rightHead);
        
        return Merge(left, right);
        
    }
    
    ListNode* Merge(ListNode* h1, ListNode* h2){
        ListNode* dummyHead = new ListNode(0);
        ListNode* p = dummyHead;
        
        while(h1 != NULL && h2 != NULL){
            if(h1->val < h2->val){
                p->next = h1;
                h1 = h1->next;
            }
            else{
                p->next = h2;
                h2 = h2->next;
            }
            
            p = p->next;
        }
        
        if(h1)
            p->next = h1;
        else
            p->next = h2;
        
        
        return dummyHead->next;
    
    }
};

在这里插入图片描述
前缀和+hashmap
删除结点就要用到dummyhead

class Solution {
public:
    ListNode* removeZeroSumSublists(ListNode* head) {
        ListNode* cur = head;

        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;

        int preSum = 0;
        unordered_map<int, ListNode*> mp;
        mp[0] = dummyHead;

        while(cur != NULL){
            preSum += cur->val;
            if(mp.find(preSum) != mp.end()){
                ListNode* tmp = mp[preSum]->next;
                mp[preSum]->next = cur->next;

                int tmpSum = preSum;
                while(tmp != cur){
                    tmpSum += tmp->val;
                    mp.erase(tmpSum);
                    tmp = tmp->next;
                }
            }else{
                mp[preSum] = cur;
            }
            cur = cur->next;
        }
        ListNode* ret = dummyHead->next;
        delete dummyHead;

        return ret;

    }
};

在这里插入图片描述

整个链表分为已反转区、待反转区和未反转区
指针分别为 pre, start end,next;

class Solution {
public:
    ListNode* reverseList(ListNode* head){
        ListNode* pre = NULL, *cur = head;

        while(cur != NULL){
            ListNode* tmp = cur->next;
            cur->next = pre;

            pre = cur;
            cur = tmp;
        }

        return pre;
    }
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(head->next == NULL || k == 1)
            return head;
        
        
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* pre = dummyHead;
        ListNode* end = head, *start = head;

        while(start != NULL){
            int tmp = k - 1;
            while(tmp && end != NULL){
                tmp--;
                end = end->next;
            }
            if(end == NULL)
                break;

            ListNode* next = end->next;
            end->next = NULL;

            pre->next = reverseList(start);
            pre = start;

            start->next = next;

            start = next;
            end = start;
        }


        ListNode* ret = dummyHead->next;
        delete dummyHead;

        return ret;
        
    }
};

在这里插入图片描述
哈希表

  1. 首先构造原链表节点宇新节点之间的哈希映射关系。
  2. 构造每个节点的next和random。
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == NULL) return head;

        unordered_map<Node* , Node*> mp;

        Node* cur = head;
		
		//1. 首先构造原链表节点宇新节点之间的哈希映射关系。
        while(cur){
            mp[cur] = new Node(cur->val);
            cur = cur->next;
        }

		//2. 构造每个节点的next和random。
        cur = head;
        while(cur){
            mp[cur]->next = mp[cur->next];
            mp[cur]->random = mp[cur->random];
            cur = cur->next;
        }

        return mp[head];

    }
};
Jelly_Believer
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表面试问题总结：
weixin_43934357的博客
07-20 256
**无法高效获取长度，无法根据偏移快速访问元素，是链表的两个劣势。**然而面试的时候经常碰见诸如获取倒数第k个元素，获取中间位置的元素，判断链表是否存在环，判断环的长度等和长度与位置有关的问题。这些问题都可以通过灵活运用双指针来解决。 Tips：双指针并不是固定的公式，而是一种思维方式~ 1.先来看"倒数第k个元素的问题"。设有两个指针 p 和 q，初始时均指向头结点。首先，先让 p 沿着 next 移动 k 次。此时，p 指向第 k+1个结点，q 指向头节点，两个指针的距离为 k 。然后，同时移动 p 和
链表经典问题汇总
vivi的技术博客
08-09 1万+
收集了一下链表常见的面试为题： 1、如何判断一个单链表有环 2、如何判断一个环的入口点在哪里 3、如何知道环的长度 4、如何知道两个单链表（无环）是否相交 5、如果两个单链表（无环）相交，如何知道它们相交的第一个节点是什么 6、如何知道两个单链
链表及经典问题（船长系列）
weixin_53433446的博客
04-13 118
链表-船长版
完全搞懂链表的常见的问题以及解法
最新发布
weixin_45765910的博客
05-11 532
你要是还对链表的各种问题搞不懂，不妨我们一起整，哈哈哈哈哈
链表常见问题总结
qq_39471489的博客
03-08 823
0. 单向链表如何找到倒数n个节点 一种容易想到的方法是，我们首先从头节点开始对链表进行一次遍历，得到链表的长度 LL。随后我们再从头节点开始对链表进行一次遍历，当遍历到第 L-n+1L−n+1 个节点时，它就是我们需要删除的节点。 为了与题目中的 nn 保持一致，节点的编号从 11 开始，头节点为编号 11 的节点。 为了方便删除操作，我们可以从哑节点开始遍历 L-n+1L−n+1 个节点。当遍历到第 L-n+1L−n+1 个节点时，它的下一个节点就是我们需要删除的节点，这样我们只需要修改一次指针，就能
链表问题
weixin_33709219的博客
09-23 46
http://wenku.baidu.com/link?url=mIGD66zTocZ_mjiE6gZ1whhhGnCT1JqktEJX5XD8PfPd4-AQDpKe7z7rvo8t99V0a-9duvIteZiWs_wQtlkKYFsnI4HpIoGQdLMbzq63zia 转载于:https://www.cnblogs.com/lishennan/p/4831730.html
链表试题算法汇总.doc
10-12
ink() error:%d\n", res);return res;}Link *pPre = NULL;Link *pCurr = pHead;Link *pNext;while (pCurr !...链表因其动态特性，在解决许多实际问题时非常有用，例如在内存管理、数据存储和图形算法等领域。
C语言结构体链表的排序方法汇总
12-29
C语言结构体链表的排序方法汇总 ========================== 功能：选择排序(由小到大) 返回：指向链表表头的指针 ========================== */ /* 选择排序的基本思想就是反复从还未排好序的那些节点中， ...
链表面试题总结
10-22
数据结构，链表所有综合面试题型汇总，有大神漏缺的给我留言
基础算法与数据结构汇总，包括排序、链表、二叉树、图、暴力递归、贪心算法等相关内容.zip
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 ..."如果问题的最优解包含子问题的最优解，则该问题表现出最优子结构
面试问题汇总
08-04
【标题】：“面试问题汇总”通常意味着这是一份集中的技术面试问题集合，可能涵盖了多个IT领域的关键知识点，包括但不限于编程语言、数据结构、算法、操作系统、计算机网络、数据库、软件工程等方面。这类文档通常...
单链表问题总结
zlp1992的专栏
08-25 2876
Leetcode 单链表相关问题解决 判断链表是否存在环 找出环的入口节点
关于链表的一些问题
菩提树下写代码
07-28 287
1.判断一个任意长度的链表是否存在环？ 答：很多人也许会设置一个指针指向第一个节点，但是这种方法是错误的，因为链表可能是从中间某个节点开始才有环的，开始的节点并不一定会在环里面。让我们想象一下如果一个链表存在环的话，那么这个链表一定是“6”型或“0”型的，也就是开始可能存在某些节点不存在环之中，这就增加了这个的复杂性，那么很多人会想到设置一个浮标，然后遍历一遍链表这样做是可以的但是时间复杂度为O（
java的listnode_在java中使用ListNode
weixin_28916013的博客
02-12 4329
ListNode是由自己定义的java中的链表对象类结构如下public class ListNode{int val;ListNode next;public ListNode(int x){val=x;}}初始化时必须传值有一列 1.给出 Input: (2 -> 4 -> 3) + (5 -> 6 -> 4) 要求Output: 7 -> 0 -> ...
在java中使用ListNode
热门推荐
SuperHero521的博客
08-02 5万+
ListNode是由自己定义的java中的链表对象 类结构如下 public class ListNode { int val; ListNode next; public ListNode(int x){ val=x; } } 初始化时必须传值 有一列  1.给出 Input: (2 -> 4 -> 3) + (5 -> 6
编程题总结 链表问题常用解决方法
filan的博客
08-21 1363
一文打尽链表问题。通过复习链表基本操作插入、删除、遍历；以及进阶问题：翻转链表、双指针，快慢指针、转换为路径问题 解决编程实例 链表分割，链式A+B 回文链表，链表相交、链表成环
初学者，如何理解链表，为什么要引入链表？
Kevin_YZLong的博客
03-24 4628
或许这是让每一个IT初学者很头痛的问题，明明我们在之前已经接触了数组，感到数组已经是万能的数据存储位置了，但是，如果我们如果一直在使用比较复杂的数据（也就是比较多的数据时），我们肯定会感到很反感，因为对于数组这种数据结构，在你自己使用之前，一定要对其大小进行一番定义，这样一来，它的存储空间在数据处理过程中显得极为不方便，因为谁也不想对将要处理的数据做一个空间的预算，这是我们每一个程序员都很忌讳的，
关于单链表的一些常见问题
seuqi的博客
07-23 1641
#include using namespace std; #include #include struct ListNode { int _data; struct ListNode* _next; ListNode(int x) :_data(x), _next(NULL) {} }; typedef ListNode Node; void PushBack(Node*
算法面试题总结_嵌入式-常用知识&面试题库_大厂面试真题.doc
08-07
问题要求将二元查找树（BST）转换成一个排序的双向链表，同时保持原树的搜索特性。首先，我们需要遍历BST，利用中序遍历（In-order traversal）的顺序（左子树 -> 根节点 -> 右子树）来构建有序链表。在这个过程中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值