链表牛客网中等、较难题（C++）

最新推荐文章于 2022-11-01 21:50:55 发布
最新推荐文章于 2022-11-01 21:50:55 发布
阅读量608 收藏 2
点赞数
分类专栏： 数据结构算法学习 文章标签： 链表 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46741734/article/details/126551211
版权

链表部分总体小节

1：链表部分，要学会多创建一些头指针，多个之间的互补使用衔接
2：学会巧使用pre->next=head,便于做到对后续的统一判断
3：快指针、慢指针的问题，快指针同时走两步是慢指针的2倍，可以用来判断是否有环，有环总是能撵上的
4：倒数第几个的问题，快指针先走第n步，则慢指针再走，两个链表可以很快地定位到倒数第n位
5：链表之间的赋值关系要慎重，因为很容易造成链表混乱，学习后面的方法，一种是直接对链表反转，一种是单个对内部的进行翻转，第二种自己理解花了很久，采用新建temp重新创造关系，以及指针next移动根部不动的方法自己要多深入体会
6：题目1中的算法要记住
7：要记得对链表的末尾加NULL不要忘记
8：多个头节点有的时候就是为了维护同一个链表，所有通常情况下都是不对head直接进行操作的，需要进行保留，只要少部分递归的情况需要直接用head，再者就是pre节点，最后返回pre->next的问题，虽然最开始定义的是pre->next=head, cur=head但是并不代表最终运算完返回pre->next还是等于head了，因为head会一直不变，但是pre->next也许会根据实际情况为空也是可能的，还是要看代码编写情况再确定！！！
总而言之~~~~~链表确实是比树会难一些，树基本不会修改删除一些树之间的关系，几乎就是求深度，最短路径等等，而链表则就要多一些插入删除的操作，其因为其简洁的形式，也多了一些更多结合使用的功能

题目1（链表的环入口点）

在这里插入图片描述

收获

在这里插入图片描述
在这里插入图片描述
1：这道题最重要的思想是第一次先找到相遇点，接下来快的从头开始遍历到入口的距离=相遇点到入口的距离+（k-1)圈圆环长度

代码

class Solution {
public:
//     算法的思路很重要！！！
    ListNode *iscycle(ListNode *head){
        if(head==NULL)
            return NULL;
        ListNode *fast=head;
        ListNode *slow=head;
        while(fast!=NULL&&fast->next!=NULL){
            fast=fast->next->next;
            slow=slow->next;
            if(fast==slow)
                return slow;
        }
        return NULL;
    }
    ListNode* EntryNodeOfLoop(ListNode* pHead) {
        ListNode *slow=iscycle(pHead);
        if(slow==NULL)
            return NULL;
        ListNode *fast=pHead;
        while(fast!=slow){
            fast=fast->next;
            slow=slow->next;
        }
        return slow;
    }
};

题目2（删除链表的倒数第n个节点）在这里插入图片描述

收获

1：这道题总体的思想还是快链表先走，慢链表记录前一个位置方便衔接
2：自己独立完成，较好

代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @param n int整型 
     * @return ListNode类
     */
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        // write code here
        ListNode *fast=head;
        //快链表先走n个，之后慢链表从头遍历并记住前一个选项用于删除
        for(int i=0;i<n;i++){
            fast=fast->next;
        }
        //如果没有这句话的话后期的pre没有初值不能使用next函数！！
        if(fast==nullptr)
            return head->next;
           //这里的head->next通常就是删除倒数第一个，所以直接返回第二个
        ListNode *slow=head;
        ListNode *pre;
        while(fast){
            pre=slow;
            fast=fast->next;
            slow=slow->next;
        }
        //循环结束pre指向的就是第n-1个节点！！
        pre->next=slow->next;
        return head;
    }
};

题目3（链表相加2）

在这里插入图片描述

收获

1：这道题在中间记录的过程中，本打算直接对得到的结果进行相反，忘记记录最初的位置了，导致不能很好的翻转是一个小失误，后来自己也及时改进
2：觉得自己对链表的排序合并，以及相加减移动这方面已经较熟悉了

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    ListNode *reverseLink(ListNode *head){
        if(head==NULL)
            return NULL;
        ListNode *pre=NULL;
        ListNode *cur=head;
        while(cur){
            ListNode *temp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=temp;
        }
        return pre;
    }
    ListNode* addInList(ListNode* head1, ListNode* head2) {
        // write code here
        if(head1==nullptr)
            return reverseLink(head2);
        if(head2==nullptr)
            return reverseLink(head1);
        //将前两个链表反转
        ListNode *first=reverseLink(head1);
        ListNode *second=reverseLink(head2);
        int jinwei=0;
        ListNode *third=nullptr;
        //如果不用这个result记录的话最后的third的链表方向反了，并且在创建头链表的时候要记得创建
        //第一个的特殊用法~
        ListNode *result;
        while(first&&second){
            if(third==nullptr){
                third=new ListNode((first->val+second->val+jinwei)%10);
                result=third;
                jinwei=(first->val+second->val+jinwei)/10;
            }else{
                third->next=new ListNode((first->val+second->val+jinwei)%10);
                third=third->next;
                jinwei=(first->val+second->val+jinwei)/10;
            }
            first=first->next;
            second=second->next;
        }
        while(first){
            third->next=new ListNode((first->val+jinwei)%10);
            jinwei=(first->val+jinwei)/10;
            third=third->next;
            first=first->next;
        }
        while(second){
            third->next=new ListNode((second->val+jinwei)%10);
            jinwei=(second->val+jinwei)/10;
            third=third->next;
            second=second->next;
        }
        if(jinwei){
            third->next=new ListNode(1);
            third=third->next;
        }
        return reverseLink(result);
    }
};

题目4（单链表的排序）

在这里插入图片描述

收获

1：相较于直接用链表排序的复杂，中间用vector数组辅助排序出的结果，速度比较快，完全自己独立完成

代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 the head node
     * @return ListNode类
     */
    //!!!!!!!aaaaa这是错觉么？？？好有成就感的感觉!!!!!!!!!!!!本来打算用数组的，但是确实没有
    //vector直接排序比较nice!!!
    ListNode* sortInList(ListNode* head) {
        // write code here
        if(head==nullptr||head->next==nullptr)
            return head;
        ListNode *temp=head;
        //创建一个
        vector<int >res;
        while(temp){
            res.push_back(temp->val);
            temp=temp->next;
        }
        sort(res.begin(), res.end());
        ListNode *returnnum=new ListNode(res[0]);
        temp=returnnum;
        for(int i=1;i<res.size();i++){
            temp->next=new ListNode(res[i]);
            temp=temp->next;
            temp->next=NULL;
        }
        return returnnum;
    }
};

题目5（链表的奇偶重排）

在这里插入图片描述

收获

1：这道题注意题目要求即可，是节点的编号奇数一边，偶数一边，不要直接对节点数据进行判断了

代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    ListNode* oddEvenList(ListNode* head) {
        // write code here
        if(head==nullptr||head->next==nullptr)
            return head;
        ListNode *temp=head;
        vector<int >jishu;
        vector<int >oushu;
        int i=0;
        while(temp){
            i++;
            if(i%2==0)
                oushu.push_back(temp->val);
            else
                jishu.push_back(temp->val);
            temp=temp->next;
        }
        ListNode *node=new ListNode(jishu[0]);
        temp=node;
        for(int j=1;j<jishu.size();j++){
            temp->next=new ListNode(jishu[j]);
            temp=temp->next;
            temp->next=nullptr;
        }
        for(int j=0;j<oushu.size();j++){
            temp->next=new ListNode(oushu[j]);
            temp=temp->next;
            temp->next=nullptr;
        }
        return node;
    }
};

题目6（删除有序链表中重复的元素）

在这里插入图片描述

收获

1：这道题相比于前面的删除掉只剩一个重复的而言，是需要把有重复的就删掉，于是就要记录第一个有重复的位置，一直将指针后移，直到没有重复为止
2：巧用链表之前的pre！

代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    ListNode* deleteDuplicates(ListNode* head) {
        // write code here
        if(head==nullptr||head->next==nullptr)
            return head;
        ListNode *pre=new ListNode(0);
        pre->next=head;
        ListNode *cur=pre;
        while(cur->next!=NULL&&cur->next->next!=NULL){
            if(cur->next->val==cur->next->next->val){
                int temp=cur->next->val;
                while(cur->next!=NULL&&cur->next->val==temp)
                    cur->next=cur->next->next;
            }
            else{
                cur=cur->next;
            }
        }
        return pre->next;
    }
};

题目7（链表内指定区间反转）

在这里插入图片描述

收获

1：这道题真的是本来最开始遇到的就是这题，但是最开始对链表的理解不是很深入，就不是很能理解，后来慢慢的理解了，就是最后的链接怎么将翻转的最后一位，和没翻转的下一位接上的问题，后来意识到原来是cur指针一直不动，利用cur->next，再新建temp进行链接实现的功能（印象很深刻了~）

代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @param m int整型 
     * @param n int整型 
     * @return ListNode类
     */
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        // write code here
        ListNode* res=new ListNode(-1);
        res->next=head;
        ListNode *pre=res;
        //当前节点!!
        ListNode  *cur=head;
        for(int i=1;i<m;i++){
            pre=cur;
            cur=cur->next;
        }
        //一直在移动指针，其实真正的操作是用temp和temp->next进行衔接！！！而且cur的位置一直
        //保持不变，正好对应的遍历在最后的时候的cur->next进行衔接！！！！呜呜呜
        for(int i=m;i<n;i++){
            //创建一个新temp等于当前的下一个，用于连接
            ListNode * temp=cur->next;
            //记录好下一次的位置，方便下一次循环用
            cur->next=temp->next;
            //建立好连接temp后是pre的下一个
            temp->next=pre->next;
            //pre的下一个是temp，通过这样就使得pre的next一直向前到翻转链表的尾部·temp之间在一点
            //一点的连接
            pre->next=temp;
        }
        return res->next;
    }
};

题目8（链表中的节点每 k 个一组翻转）

在这里插入图片描述

收获

1：这道题不是自己写的，题解用递归的思想实现，很方便，自己也理解了~

代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    //唔~理解起来还比较方便！！递归的想法！
    ListNode* reverseKGroup(ListNode* head, int k) {
        // write code here
        ListNode *tail=head;
        //遍历k次到尾部，实际上是下一组k的开始！！，注意判断的顺序
        for(int i=0;i<k;i++){
            if(tail==NULL)
                return head;
            tail=tail->next;
        }
        ListNode *pre=NULL;
        ListNode *cur=head;
        while(cur!=tail){
            ListNode *temp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=temp;
        }
        head->next=reverseKGroup(tail, k);
        return pre;
    }
};

题目9（合并 k 个已排序的链表）（hard）

在这里插入图片描述

收获

1：这道题最开始的思路，时间复杂度大概是k²，而不是题目所要求的log形式，自己想到了可以使用归并排序，但是不是很熟悉，看了题解，觉得自己应该可以写出来，链表和递归的结合的一种~~~

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
//     ListNode *sortLink(ListNode *head,ListNode* head2){
        
//     }
//     ListNode *mergeKLists(vector<ListNode *> &lists) {
//         if(lists.size()==1)
//             return lists[0];
//         //将对多个进行排序转换为排序n-1次，每次对两个进行升序排序，但是这么做的结果就是
//         //时间复杂度不满足要求，最好能同时排序两个，有一种归并排序的思想
//         ListNode *head=lists[0];
//         for(int i=1;i<lists.size();i++){
//             head=sortLink(head,lists[i]);
//         }
//         return head;
//     }
    ListNode *sortLink(ListNode *head1,ListNode* head2){
        if(head1==NULL)
            return head2;
        if(head2==NULL)
            return head1;
        ListNode *head=new ListNode(0);
        ListNode *cur=head;
        while(head1&&head2){
            if(head1->val<head2->val)
            {
                cur->next=head1;
                head1=head1->next;
            }
            else
            {
                cur->next=head2;
                head2=head2->next;
            }
            cur=cur->next;    
        }
        if(head1){
            cur->next=head1;
        }
        if(head2){
            cur->next=head2;
        }
        return head->next;
    }
    //归并排序的思想，一会儿可以练习练习，但是现在要去总结啦~~~
    ListNode *mergeLink(vector<ListNode *>&lists,int left,int right){
        if(left>right)
            return NULL;
        else if(left==right)
            return lists[left];
        int mid=(left+right)/2;
        return sortLink(mergeLink(lists, left, mid),mergeLink(lists, mid+1, right));
    }
    
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        return mergeLink(lists, 0, lists.size()-1);
    }
};
Pluviophile_miao～
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法LeetCode解题(C++)-15. 四数之和(难度：中等)
SmallBottle-CGWLMX的博客
10-30 300
题目描述： 给定一个包含n 个整数的数组nums和一个目标值target，判断nums中是否存在四个元素 a，b，c和 d，使得a + b + c + d的值与target相等？找出所有满足条件且不重复的四元组。 注意： 答案中不可以包含重复的四元组。 示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求...
超难链表题
The Shawshank Redemption
08-29 259
现有两个单链表，一个长度为M，一条长度为N，可能有环也可能无环，若他们相交，则给出他们相交的第一个节点，否则返回null，要求空间复杂度O(1)、空间复杂度O(M+N)。 这题信息量很大，需要拆分： 1.如何判断单链表有无环： 有环链表的判定方式：只要他能在遍历的过程中遍历到一个节点两次，那就是有环的。 所以我们可以准备一个hash，遍历链表： A.遇到了hash中未加入的节点，加入ha...
链表难题 leetcode25
看清这个世界
05-01 239
25. K 个一组翻转链表 https://leetcode-cn.com/classic/problems/reverse-nodes-in-k-group/ “”" 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 示例 : 给定这个链表：1->2-&gt...
链表系列之经典问题
cosysun的专栏
05-26 253
前文介绍了一些链表的基础知识，不熟悉的同学可以去看看，有了知识后，没有操作怎么行，所以从今天开始，给大家分析几个链表的经典问题，面试也是经常出现，废话不多说，我们一个个讲，重点补充一下，以下例子都是有链表头的，并都是用Golang。 一、链表倒置 这里介绍两种方法，头插入法和递归发。 1、head插入发 基本思想就是从头到尾遍历列表，每遍历一个节点，都插入到head后，直到链尾。看图： 代码： type ListNode struct { value interface{} next
C++笔试题目练习
GiannisLiu的博客
03-24 510
简介 这是我在笔试过程中通过牛客网进行模拟的笔试题目，这些题目很有意思也很锻炼人，写在博客中以方便后继的复习。 其中这些题目的题解全都来自于笔试下面评论区的题解，侵删。 题目 1 下面的程序可以从0…n-1中随机等概率的输出m个不重复的数。这里我们假设n远大于m knuth(int n, int m) { srand((unsigned int)time(0)); for (i...
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码）
最新发布
02-24
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码） 技术框架： 1. 线程池 + 非阻塞 socket + epoll + 事件处理的并发模型 2. 状态机解析HTTP请求 3. 心跳机制 4. 简易日志系统 主要内容： 1. ...
C++实现接两个链表实例代码
12-31
C++实现接两个链表实例代码 有以ha为头结点的链表，元素个数为m；以hb为头结点的链表，元素个数为n。现在需要你把这两个链表连接起来，并使时间复杂度最小，请分析并实现。 思路： 很简单的链表操作的题目，逆序...
【牛客网面试必刷TOP101】链表篇（一）
qq_66314292的博客
08-10 4476
链表是数据结构中重要的一个章节，他的重要性也不言而喻，在未来不管是笔试还是面试都会遇到这类的题目，所以接下来我就会把一些链表的常考的题目全部整理出来供大家学习指正。
C++构建链表
startllee的博客
11-01 1527
C++构建链表
c++链表的反转
09-04
c++链表的反转，创建链表，插入链表，链表反转，可下载直接运行。
c++简单编程题汇总450份（适合初学c++者）
06-28
里面包括了c++的450份编程题目。例如字符串排序、求面积、数值相加等等。对于初学c++的同学来说最适合不过了。学习了之后可以更加了解c++,编程考试更加容易了。
高难度C++编程习题
11-03
高难度c++编程习题，提高你的编程思想，编程能力，，，，，，，，，，，，，，，，，，，，，，，
【牛客网】华为机试题（00、C++版本）
热门推荐
Yngz_Miao的博客
07-15 2万+
华为机试题，本来以为对一些基础的程序还是有点信心的；不过不练不知道，一练吓一跳。平时虽然也都码程序，但是一到机试题就各种乱七八的不适应。还是要加强一下练习。   1、字符串最后一个单词的长度 题目描述：计算字符串最后一个单词的长度，单词以空格隔开。 例如：输入Hello World，输出5。 解答：这道题主要是练习一下字符串的输入和指定字符的查找。 #include &lt;iost...
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6696
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
链表与树 python
文选的blog
11-22 1003
链表与树是面试中出现频率最高的数据结构。 链表 之所以频率比较高，是因为在面试那中时长控制下，时间上是不允许面试官有太多的时间考察算法题，所以一些高难度的算法题一般都是说出一些思路或者写出核心算法就好，而难度太低的数组和字符串考察难度太低而被很多面试官选择性的放弃，再说链表这种数据结构，结构简单，但是可以考察的点会很多，简单点的像写出链表的插入和删除方法，难点的直接一道相关算法题，但是整体的代码量都不是很大，难度也不会很简单。整体来说之所以面试考察的比较频繁，就是因为代码量少而精，有一定难度从而有了一定
C++面试宝典--基础知识
wenkun_wang
09-04 4455
（一）基本语言 1. 说一下static关键字的作用 全局静态变量 在全局变量前加上关键字static，全局变量就定义成一个全局静态变量. 内存中位置：静态存储区，在整个程序运行期间一直存在。 初始化：未经初始化的全局静态变量会被自动初始化为0（自动对象的值是任意的，除非他被显式初始化）； 作用域：全局静态变量在声明他的文件之外是不可见的，准确地说是从定义之处开始，到文件结尾。 局部静态变量 ...
C++面向对象程序设计50道编程题（第25题）
夏栀的博客
12-08 6240
C++面向对象程序设计50道编程题（第25题） 摘要：C++程序设计实习是为学生提供了一个既动手又动脑，独立实践的机会，将课本上的理论知识和实际有机的结合起来，锻炼学生的分析问题和解决问题的能力，提高学生运用所学知识解决实际问题的能力。   本专辑为编程入门者、高校计算机软件专业学习或复习提供C++程序设计题库。   读者请先独立思考哦，再与参考程序进行比对检查。 一、问题描述 二、考察内容  ...
C++面向对象程序设计50道编程题（第29题）
夏栀的博客
12-08 2809
C++面向对象程序设计50道编程题（第29题） 摘要：C++程序设计实习是为学生提供了一个既动手又动脑，独立实践的机会，将课本上的理论知识和实际有机的结合起来，锻炼学生的分析问题和解决问题的能力，提高学生运用所学知识解决实际问题的能力。   本专辑为编程入门者、高校计算机软件专业学习或复习提供C++程序设计题库。   读者请先独立思考哦，再与参考程序进行比对检查。 一、问题描述 二、考察内容  ...
算法LeetCode解题(C++)-13. 三数之和(难度：中等)
SmallBottle-CGWLMX的博客
10-24 404
题目描述： 给定一个包含 n 个整数的数组nums，判断nums中是否存在三个元素 a，b，c ，使得a + b + c = 0 ？找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]， 满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]解法分析： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值