【链表复习】C++ 链表复习及题目解析 (3)

最新推荐文章于 2024-06-22 23:12:49 发布
最新推荐文章于 2024-06-22 23:12:49 发布
阅读量810 收藏 1
点赞数
分类专栏： C++ 数据结构 复习 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AMor_05/article/details/131236314
版权
C++ 同时被 3 个专栏收录
15 篇文章 2 订阅
订阅专栏
数据结构
15 篇文章 0 订阅
订阅专栏
复习
15 篇文章 0 订阅
订阅专栏

目录

剑指offer 中的链表题目

JZ6 从尾到头打印链表

JZ18 删除链表的结点

JZ24 反转链表

JZ25 合并两个排序的链表

JZ52 两个链表的第一个公共结点

JZ23 链表中环的入口结点

JZ22 链表中倒数第k 个结点

JZ35 复杂链表的复制

JZ76 删除链表中重复的结点

本次给大家带来所有的在剑指Offer 中的题目，请大家在学习之余也复习一下链表的相关知识。

剑指offer 中的链表题目

JZ6 从尾到头打印链表

思路：

我们都知道链表无法逆序访问，那肯定无法直接遍历链表得到从尾到头的逆序结果。但是我们都知道递归是到达底层后才会往上回溯，因此我们可以考虑递归遍历链表，因此三段式如下：

  • 终止条件： 递归进入链表尾，即节点为空节点时结束递归。

  • 返回值： 每次返回子问题之后的全部输出。

  • 本级任务： 每级子任务递归地进入下一级，等下一级的子问题输出数组返回时，将自己的节点值添加在数组末尾。

具体做法：

  • step 1：从表头开始往后递归进入每一个节点。

  • step 2：遇到尾节点后开始返回，每次返回依次添加一个值进入输出数组。

  • step 3：直到递归返回表头。

解法1:

 void _printListFromTailToHead(ListNode* head, vector<int>& res){
 if(head) {
 _printListFromTailToHead(head->next, res);
 res.push_back(head->val);
 }
 }
 vector<int> printListFromTailToHead(ListNode* head) {
 vector<int> res;
 _printListFromTailToHead(head, res);
 return res;
 }

解法2:

我先从前往后迭代，而后反转链表，也可以。

 /**
 * struct ListNode {
 *       int val;
 *       struct ListNode *next;
 *       ListNode(int x) :
 *             val(x), next(NULL) {
 *       }
 * };
 */
 class Solution {
 public:
     vector<int> printListFromTailToHead(ListNode* head) {
         vector<int> ret;
         while(head){
             ret.push_back(head->val);
             head = head->next;
        }
         int n = ret.size();
         int left = 0, right = n - 1;
         while(left < right){
             int tmp = ret[left];
             ret[left] = ret[right];
             ret[right] = tmp;
             left++, right--;
        }
         return ret;
    }
 };
 ​

解法3: 使用栈 先正序把val 输入到栈中，然后取栈顶元素放入vector中。

JZ18 删除链表的结点

 /**
  * struct ListNode {
  *int val;
  *struct ListNode *next;
  *ListNode(int x) : val(x), next(nullptr) {}
  * };
  */
 class Solution {
 public:
     /**
      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
      *
      * 
      * @param head ListNode类 
      * @param val int整型 
      * @return ListNode类
      */
     ListNode* deleteNode(ListNode* head, int val) {
         if(!head) return nullptr;
         // write code here
         ListNode* newHead = new ListNode(-1);
         newHead->next = head;
         for(ListNode* node = newHead; node->next ; node = node->next){
             if(node->next->val == val) node->next = node->next->next;
        }
         return newHead->next;
    }
 };

JZ24 反转链表

链表的反转是老生常谈的一个问题了，同时也是面试中常考的一道题。最简单的一种方式就是使用栈，因为栈是先进后出的。实现原理就是把链表节点一个个入栈，当全部入栈完之后再一个个出栈，出栈的时候在把出栈的结点串成一个新的链表。

 /**
  * struct ListNode {
  *int val;
  *struct ListNode *next;
  *ListNode(int x) : val(x), next(nullptr) {}
  * };
  */
 class Solution {
 public:
     /**
      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
      *
      * 
      * @param head ListNode类 
      * @return ListNode类
      */
     ListNode* ReverseList(ListNode* head) {
         // write code here
 stack<ListNode*> s;
 while(head){
 s.push(head);
 head = head->next;
 }
 ListNode* newHead = new ListNode(-1);
 ListNode* node = newHead;
 while(!s.empty()){
 ListNode* top = s.top();
 node->next = top;
 top->next = nullptr;
 node = top;
 s.pop();
 }
 return newHead->next;
    }
 };
 ​

双指针解法：

 /*
 struct ListNode {
 int val;
 struct ListNode *next;
 ListNode(int x) :
 val(x), next(NULL) {
 }
 };*/
 class Solution {
 public:
     ListNode* ReverseList(ListNode* pHead) {
 if(!pHead || !pHead->next){
 return pHead;
 }
 ListNode* curr = pHead;
 ListNode* prev = nullptr;
 while(curr){
 ListNode* next = curr->next;
 curr->next = prev;
 prev = curr;
 curr = next;
 }
 return prev;
    }
 };

JZ25 合并两个排序的链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

思路：升序排列的方法就是比较两个链表的结点中val 的大小，取小的一个尾插到新链表中。注意在这题中可以使用虚拟头结点来简化过程。

我的解法1：

 class Solution {
 public:
     ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
         ListNode* pcurr1 = list1;
         ListNode* pcurr2 = list2;
         ListNode* head = new ListNode;
         ListNode* newCurr = head;
         while(pcurr1 && pcurr2){
             if(pcurr1->val > pcurr2->val){
                 newCurr->next = pcurr2;
                 pcurr2 = pcurr2->next;
            }else{
                 newCurr->next = pcurr1;
                 pcurr1 = pcurr1->next;
            }
             newCurr = newCurr->next;
        }
       //来判断到底是谁终止了，直接修改newCurr 到未终止的结点的指向即可。
         newCurr->next = (pcurr1 == nullptr) ? pcurr2 : pcurr1;
         return head->next;
    }
 };

我的解法2: 递归如果 list1 或者 list2 一开始就是空链表 ，那么没有任何操作需要合并，所以我们只需要返回非空链表。否则，我们要判断 list1 和 list2 哪一个链表的头节点的值更小，然后递归地决定下一个添加到结果里的节点。如果两个链表有一个为空，递归结束。

 class Solution {
 public:
     ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
         if(!list1)  return list2;
         else if(!list2) return list1;
         else if(list1->val < list2->val){
             list1->next = mergeTwoLists(list1->next, list2);
             return list1;
        }else{
             list2->next = mergeTwoLists(list1, list2->next);
             return list2;
        }
    }
 };

JZ52 两个链表的第一个公共结点

思路：我们可以采用简单的双指针法，可以假设A 长度为m， B 长度为n，如果相交，A 和 B相交片段长度为 x， 不相交的片段长度分别为a 和b。

那么如果我们采用双指针法：

当链表 headA 和 headB 都不为空时，创建两个指针 pA和 pB，初始时分别指向两个链表的头节点 headA 和 headB，然后将两个指针依次遍历两个链表的每个节点。具体做法如下：

  • 每步操作需要同时更新指针 pA 和 pB。

  • 如果指针 pA不为空，则将指针 pA 移到下一个节点；如果指针 pB不为空，则将指针 pB 移到下一个节点。

  • 如果指针 pA为空，则将指针 pA 移到链表 headB的头节点；如果指针 pB 为空，则将指针 pB 移到链表 headA 的头节点。

  • 当指针 pA 和 pB 指向同一个节点或者都为空时，返回它们指向的节点或者 null。

那么如果二者相交，则 m = a + x， n = b + x。pA 和 pB 一定在走过 a + b + x 长度时相等。如果二者不相交，则一定不会出现相等（可以分类讨论）。

 /*
 struct ListNode {
 int val;
 struct ListNode *next;
 ListNode(int x) :
 val(x), next(NULL) {
 }
 };*/
 class Solution {
 public:
     ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
 if(!pHead1 || !pHead2) return nullptr;
         ListNode* pA = pHead1;
 ListNode* pB = pHead2;
 while(pA != pB){
 if(pA == nullptr) pA = pHead2;
 else pA = pA->next;
 if(pB == nullptr) pB = pHead1;
 else pB = pB->next;
 }
 if(pA == nullptr) return nullptr;
 else return pA;
 }
 };

JZ23 链表中环的入口结点

环的题目中，我们知道如何判断是否有环（快慢指针），那么同样的，入口结点也可以用快慢指针解决。只需要：

  • 让快慢指针从链表头出发，快2慢1，如果有环最终必会相遇（这也是判断是否有环的方法）

  • 将快指针回调回链表头，开始快慢都每次各走一步，相遇点即为入口结点。

下面是证明方法：

假设 环如图所示：

 

fast = a + b + n * (b + c); slow = a + b;

同时，fast = 2 slow; --> a = (n - 1)b + n * c;

所以如果让 fast 置为链表头，一次走一步，走 a 长度的，那么 slow 也会走 a 长度，因为 a = (n - 1)b + n * c，因为slow 原本在 a + b 位置， 所以相加，正好得到： a + a + b = (n - 1)b + n * c + a + b = a + n (b + c); 所以恰好会在链表环入口处相遇。

 ​
 /*
 struct ListNode {
     int val;
     struct ListNode *next;
     ListNode(int x) :
         val(x), next(NULL) {
     }
 };
 */
 class Solution {
 public:
     ListNode* EntryNodeOfLoop(ListNode* pHead) {
         ListNode* fast = pHead;
         ListNode* slow = pHead;
         while(fast){
             slow = slow->next;
             if(fast->next) fast = fast->next->next;
             else return nullptr;
             if(fast == slow){
                 fast = pHead;
                 while(fast != slow){
                     fast = fast->next;
                     slow = slow->next;
                }
                 return fast;
            }
        }
         return nullptr;
    }
 };

JZ22 链表中倒数第k 个结点

我们需要找倒数第k 个节点，那么完全也可以利用双指针法去解，让快指针先走 k步，然后快慢同步走，快指针走到链表尾的时候，由于慢指针和快指针相差k 步，所以慢指针指向的就是第k 个结点。

 /**
  * struct ListNode {
  *int val;
  *struct ListNode *next;
  *ListNode(int x) : val(x), next(nullptr) {}
  * };
  */
 class Solution {
 public:
     /**
      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
      *
      * 
      * @param pHead ListNode类 
      * @param k int整型 
      * @return ListNode类
      */
     ListNode* FindKthToTail(ListNode* pHead, int k) {
         // write code here
         if(!pHead || k <= 0) return nullptr;
         ListNode* pfast = pHead;
         ListNode* pslow = pHead;
         for(int i = k; i > 0; --i){
             if(pfast) pfast = pfast->next;
             else if(!pfast && i == 0) return pHead;
             else return nullptr;
        }
         while(pfast){
             pfast = pfast->next, pslow = pslow->next;
        }
         return pslow;
    }
 };

JZ35 复杂链表的复制

我们首先将该链表中每一个节点拆分为两个相连的节点，例如对于链表 A→B→C，我们可以将其拆分为 A→A′→B→B′→C→C′ 。对于任意一个原节点 S，其拷贝节点 S′ 即为其后继节点。

这样，我们可以直接找到每一个拷贝节点 S′ 的随机指针应当指向的节点，即为其原节点 SSS 的随机指针指向的节点 T 的后继节点 T‘ 。需要注意原节点的随机指针可能为空，我们需要特别判断这种情况。

当我们完成了拷贝节点的随机指针的赋值，我们只需要将这个链表按照原节点与拷贝节点的种类进行拆分即可，只需要遍历一次。同样需要注意最后一个拷贝节点的后继节点为空，我们需要特别判断这种情况。

复杂度分析

时间复杂度：O(n)，其中 n 是链表的长度。我们只需要遍历该链表三次。读者们也可以自行尝试在计算拷贝节点的随机指针的同时计算其后继指针，这样只需要遍历两次。 空间复杂度：O(1)。注意返回值不计入空间复杂度。

 /*
 // Definition for a Node.
 class Node {
 public:
     int val;
     Node* next;
     Node* random;
     
     Node(int _val) {
         val = _val;
         next = NULL;
         random = NULL;
     }
 };
 */
 ​
 class Solution {
 public:
     Node* copyRandomList(Node* head) {
         if(head == nullptr){
             return nullptr; //如果为空则不讨论
        }
         for(Node* node = head; node != nullptr; node = node->next->next){
             Node* newNode = new Node(node->val);
             nodeNew->next = node->next;
             node->next = nodeNew; //创建新节点在原节点之后
        }
         for(Node* node = head; node != nullptr; node = node->next->next){
             Node* nodeNew = node->next;
             newNode->random = (node->random != nullptr) ? node->random : nullptr;
             //修改新链表random的指向
        }
         Node* headNew = head->next;
         for(Node* node = head; node != nullptr; node = node->next){
             Node* nodeNew = node->next; 
             node->next = node->next->next; //修改原链表的next。
             nodeNew->next = (nodeNew->next != nullptr) ? nodeNew->next->next : nullptr; 
             //修改新链表的next指向
        }
         return headNew;
    }
 };

JZ76 删除链表中重复的结点

注意读题，是排序的链表，所以我们可以使用双指针法，从左往右，如果left 所指的值和 right 所指是否相等，如果相等那么right 右移， 看看新的right 是否也符合相等条件，直至不符合条件，让前面的prev （解答中的node）指向新 right 即可，就是因为我们需要修改前面的指向，所以需要node 变量来记录之前的位置。也恰好是因为prev 不方便，所以我们使用哨兵位头节点来简化。如果不等，那么直接node，left，right都向右移动一个。

 ​
 /*
 struct ListNode {
     int val;
     struct ListNode *next;
     ListNode(int x) :
         val(x), next(NULL) {
     }
 };
 */
 class Solution {
 public:
     ListNode* deleteDuplication(ListNode* pHead) {
         ListNode* newHead = new ListNode(-1);
         newHead->next = pHead;
         for(ListNode* node = newHead; node->next && node->next->next;){
             ListNode* left = node->next;
             ListNode* right = left->next;
             if(left->val != right->val){
                 node = node->next, left = left->next, right = right->next;
            }else{
                 while(right && left->val == right->val) right = right->next;
                 node->next = right;
            }
        }
         return newHead->next;
    }
 };

AMor_05
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Verilog有限状态机三段式描述方法【原创*改进】
weixin_34345560的博客
06-17 6718
1、好的状态机标准 好的状态机的标准很多，最重要的几个方面如下： 第一，状态机要安全，是指FSM不会进入死循环，特别是不会进入非预知的状态，而且由于某些扰动进入非设计状态，也能很快的恢复到正常的状态循环中来。这里面有两层含义：其一要求该FSM的综合实现结果无毛刺等异常扰动；其二要求FSM要完备，即使受到异常扰动进入非设计状态，也能很快恢复到正常状态。 第二，状态机的设计要满足设计的面积和速度...
C++学习资料\计算机二级复习资料.
04-18
计算机二级考试复习资料主要涵盖了C++编程语言及相关的数据结构和算法知识，这些知识点对于初学者至关重要。以下是对部分题目涉及知识点的详细解释： 1. **算法的基本特性**：算法的有穷性、确定性、可行性、输入和...
[Daimayuan] 三段式（C++，数组前缀和）
m0_74036684的博客
05-20 545
对于连续区间和问题，常常用前缀和概念优化算法。
【代码源】每日一题 三段式
m0_63658130的博客
05-08 591
代码源 div2每日一题 三段式
【C++求解数学题】大圆圈里面三角形个数相等
算法与编程之美
12-26 531
本文介绍的问题来自二年级（上）数学的一道练习题。
C/C++的编译基础知识
yudelian的博客
03-29 927
目录 一、编译的过程都有哪些 二、程序一定要从main函数开始运行吗？ 三、make与cmake的区别 一、编译的过程都有哪些 C语言编译过程详解 - CarpenterLee - 博客园 预处理、编译、汇编、链接 预处理：预处理用于将所有的#include头文件以及宏定义替换成其真正的内容，预处理之后得到的仍然是文本文件； gcc -E -I./inc test.c -o test.i 编译：将程序编译成汇编 gcc -S -I./inc test.c -o test.s..
【链表复习】C++ 链表复习及题目解析（1）
AMor_05的博客
06-12 377
链表在面试题和笔试题中出现的频率相当的高，所以我们应该着重的复习链表和经典的链表相关题目。本文主要介绍链表的结构和分类以及相关题目（1）
【链表复习】C++ 链表复习及题目解析 (2)
AMor_05的博客
06-14 633
本文继续延续前文，为大家带来几道经典的链表中等难度的题目。
C/C++面试常见题目2010
11-23
【C/C++面试常见题目2010】的文档涵盖了C/C++编程语言的基础知识、面试常见问题以及一些编程技巧，对于应聘C/C++岗位的应届生来说，这是一个非常有价值的复习资料。以下是对其中一些关键知识点的详细解释： 1. **`...
CSP2020入门组初赛试题解析（单项选择题）-PPT
08-15
《CSP2020入门组初赛试题解析——计算机科学基础篇》 CSP（中国计算机学会编程能力认证）是一项旨在考核计算机编程基础及算法理解能力的比赛，入门组主要面向初学者，试题涵盖计算机科学的基本概念和技术。本篇文章...
IBM笔试题目-汇总整理版
03-26
以下是针对这些题目的详细解析： 1. 链表环判断：可以通过快慢指针（Floyd 算法）来检测链表是否有环。快指针每次移动两个节点，慢指针每次移动一个节点。如果存在环，两者最终会在环内相遇；若无环，快指针将先...
腾讯公司最新C/C++笔试题
10-15
以下是对这些题目所涉及知识点的详细解析： 1. 宏定义Max(a, b)：这个问题考察了宏定义和条件运算符的使用。宏定义不能包含if语句，但可以使用条件运算符（三元运算符）来实现。给出的解决方案是 `(a > b) ? a : b`...
408数据结构-图的应用1-最小生成树 自学知识点整理
Engels_Si_Fish的博客
06-22 629
25考研知识点个人向总结。
数据结构之B数
AOMGyz的博客
06-22 280
B树还有一些变体，如B+树和B*树，它们在某些方面对B树进行了改进和优化，以适应特定的应用场景。例如，B+树将所有数据都存储在叶子节点上，并通过链表连接叶子节点，这更适合于范围查询和文件系统的索引。B树，也称为B-树，是一种自平衡的多路搜索树，主要用于磁盘或其他直接访问辅助设备。其设计目标是优化磁盘I/O操作，以提供高效的插入、删除和查找操作。
探索数据结构：集合、线性结构、树状结构和图形结构
一个普通人
06-22 1067
在计算机科学中，数据结构是用于组织和存储数据的基础。不同的数据结构有不同的特点和适用场景。今天，我们将深入探讨四种主要的数据结构：集合、线性结构、树状结构和图形结构。通过对它们的理解，您可以更好地选择和应用这些结构来解决实际问题。
数据结构（基础知识）
最新发布
z0108_999的博客
06-22 377
数据是信息的载体，是描述客观事物属性的数，字符及所有能输入到计算机中并被计算机程序识别和处理的符号的集合：是数据的基本单位，在程序中常作为一个整体来考虑：是具有相同构成的数据元素的集合，是数据的一个子集。
【408考点之数据结构】表达式求值和括号匹配
gygkhd的博客
06-22 304
表达式求值是计算机科学中的一个基本问题，涉及将数学表达式转换为计算机可以理解和处理的形式。通常，我们使用栈来辅助求值过程，特别是在处理中缀表达式转后缀表达式和后缀表达式求值时。）是我们通常书写数学表达式的形式。为了方便计算机处理，我们将其转换为后缀表达式（逆波兰表达式，RPN）。括号匹配是验证括号在表达式中是否成对出现和正确嵌套的过程。最后栈为空，匹配成功。
嵌入式学习——数据结构（双向无头有环链表、内核链表、栈）——day48
qq_47798402的博客
06-21 308
先进后出 first in last out。增：栈顶指针向内存高地址移动（0x1000低地址 ——0x2000高地址）快指针每走一步，判断是否为空或者是否与慢指针相遇。只允许从一端进行插入和删除的数据结构称为栈。利用快慢指针判断是否相遇。2. 函数的形参、返回值。浏览器返回上一层操作。满、空栈：栈顶所在位置是否存有数据。减：栈顶指针向内存低地址移动。1. 判断单向链表是否有环。
链表class 实现链表、c++
02-02
链表（Linked List）是一种常见的数据结构，通过节点将元素按顺序连接起来。链表的每个节点包含数据部分和指向下一个节点的指针。 在C语言中，我们可以使用结构体来定义一个链表节点，并使用指针来表示不同节点的连接关系。 首先，我们定义一个链表节点的结构体： ```c typedef struct Node { int data; // 数据部分 struct Node* next; // 指向下一个节点的指针 } Node; ``` 接着，我们可以定义一个链表的结构体，存储链表的头节点和尾节点： ```c typedef struct LinkedList { Node* head; // 链表的头节点 Node* tail; // 链表的尾节点 } LinkedList; ``` 链表的实现包括一系列操作，比如插入、删除、查找等。 插入操作：在链表的指定位置插入一个新的节点： ```c void insert(LinkedList* list, int position, int data) { // 创建新的节点 Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; // 插入到链表中 if (position == 0) { // 插入到链表的头部 newNode->next = list->head; list->head = newNode; } else { // 插入到指定位置 Node* currentNode = list->head; for (int i = 0; i < position - 1 && currentNode != NULL; i++) { currentNode = currentNode->next; } if (currentNode != NULL) { newNode->next = currentNode->next; currentNode->next = newNode; } } } ``` 删除操作：删除链表中指定位置的节点： ```c void remove(LinkedList* list, int position) { // 删除链表中的节点 if (position == 0) { Node* currentNode = list->head; list->head = currentNode->next; free(currentNode); } else { Node* currentNode = list->head; Node* previousNode = NULL; for (int i = 0; i < position && currentNode != NULL; i++) { previousNode = currentNode; currentNode = currentNode->next; } if (currentNode != NULL) { previousNode->next = currentNode->next; free(currentNode); } } } ``` 查找操作：根据节点的值查找节点所在位置： ```c int search(LinkedList* list, int data) { int position = 0; Node* currentNode = list->head; while (currentNode != NULL) { if (currentNode->data == data) { return position; } position++; currentNode = currentNode->next; } return -1; // 表示未找到 } ``` 以上是链表的一些基本操作示例，通过结构体和指针，我们可以很方便地实现一个链表的类（class）来进行链表操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值