链表相关练习题（C++）

最新推荐文章于 2023-05-08 06:15:00 发布
最新推荐文章于 2023-05-08 06:15:00 发布
阅读量4.7k 收藏 18
点赞数 4
分类专栏： 数据结构与基本算法 文章标签： 链表 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/djangobuaa/article/details/51223069
版权
一、链表
1、在节点值有序的单循环链表中插入指定结点，使插入后的链表依然有序。
解法：一下解法只是单链表，不是循环链表。

class  InsertValue {
public :

    ListNode* buildLinkedList(vector< int > &A,vector< int > &nextPoint) {
         int  len = A.size();
        ListNode* h = new ListNode(A[ 0 ]);        
         if  (len ==  1 ) {
            h->next = h;
             return  h;
        }             
         else  {
            ListNode* p = h;

             for  ( int  i =  1 ,k =  0 ;i < len;i++) {
                p->next =  new  ListNode(A[nextPoint[k]]);
                p = p->next;
                k = nextPoint[k];
        }
      }
         return  h;
    }

    ListNode* insert(vector< int > A, vector< int > nxt,  int  val) {
        ListNode* insertNode =  new  ListNode(val);
         if  (A.empty()) {
            insertNode->next = insertNode;
             return  insertNode;
        }

        ListNode* head = buildLinkedList(A,nxt);        
        ListNode* p = head;
        ListNode* q = head->next;

         for ( int  i =  1 ; i < A.size(); i++) {
             if  ((val >= p->val && val <= q->val) || (val <= p->val && val >= q->val)) 
                 break ;
            p = q;
            q = q->next;
        }                
        insertNode->next = q;
        p->next = insertNode;                   
         return  head;
    }
};

2、对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。
解法：遍历链表，将链表分成两个子链表，其中一个链表的元素值都比阈值小，另一个比阈值都大，再将两个链表连接起来即可。
class  Divide {
public :
    ListNode* listDivide(ListNode* head,  int  val) {
         if  (!head) 
             return  NULL;
         if  (!head->next)
             return  head;

        ListNode *head1,*head2,*h1,*h2,*p,*q;
        head1 = head2 = h1 = h2 = NULL;
        p = head;
        q = head->next;

        while (p) {
             if  (p->val <= val) {
                 if  (!head1) {
                    head1 = p;
                    h1 = head1;
                }
                 else  {
                    h1->next = p;
                    h1 = h1->next;
                }                                
            }
             else  {
                 if  (!head2) {
                    head2 = p;
                    h2 = head2;
                }
                 else  {
                    h2->next = p;
                    h2 = h2->next;
                }                                                                        
            }
            p->next = NULL;  
            p = q;
            if (q != NULL)
                q = q->next;
        }

         if  (head1->val <= val) {
            h1->next = head2;
             if  (h2 != NULL)
                h2->next = NULL;
             return  head1;
        }            
         else  {
            h2->next = head1;
             if  (h1 != NULL)
                h1->next = NULL;
             return  head2;
        }
    }
};

3、打印两个有序链表的公共部分
解法：同时遍历两个链表，逐个比较。相等则打印，两个指针同时后移；不相等则哪一个较小就将其对应指针后移，另一个指针不动；其中一个指针为空时停止比较。
class Common {
public :
     vector< int > findCommonParts(ListNode* headA, ListNode* headB) {
         vector< int > common;
         if (!headA || !headB)
             return common;       
         ListNode *p,*q;
         p = headA;
         q = headB;
         while (p && q) {
             if (q->val == p->val) {
                 common.push_back(q->val);
                 q = q->next;
                 p = p->next;
             }
             else if (q->val > p->val)
                 p = p->next;
             else
                 q = q->next;               
         }
最低0.47元/天 解锁文章
DjangoBUAA
关注
  • 4
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表经典练习题
erwuhuoche的博客
04-16 2万+
链表经典练习题 一、从尾到头打印单链表 因为单链表是有指向的，前一节点只能指向下一节点，因此为了实现从尾到头打印链表可以使用一种非常简单的方法就是递归，先遍历再输出。 代码实现： void LinkListReversePrint(LinkNode* head){ 85 if(head == NULL){ 86 return;//空链表 8...
C/C++数据结构之链表题目答案与解析
Infernal_Puppet的博客
11-11 1763
在前面我们讲解了一些关于链表的内容，其中还有一些关于链表的习题，今天我们主要对这些题目进行解析。数据结构的学习非常的重要，我们想要学习好数据结构需要我们多多的刷题，希望大家可以在平时多多刷题来提升自己，最后希望大家可以三连一下。
C/C++每日一练(20230508) 链表专题
汉阳Hann's Home
05-08 723
1. 相交链表🌟🌟🌟 　 2. 排序链表🌟🌟 　 3. 重排链表🌟🌟
链表相关的题目
2021wuwei
05-08 404
1.反转单链表：链接 思路一 struct ListNode* reverseList(struct ListNode* head){ // 翻转指针方向 if(head==NULL) { return NULL; } // 初始条件 struct ListNode*n1=NULL,*n2=head,*n3=head->next; // 结束条件 while(n2) { // 迭代过
链表 leetcode题目总结 c++
Arthur_Holmes的博客
07-25 718
链表 链表和数组最大的区别在于，链表不支持随机访问，不像数组可以对任意一位的数据进行访问，链表只能从头一个一个往下访问，寻找下一个元素，像穿针引线似的。也正因为链表的这种特点，增大了链表题目的难度。 本文主要讨论的是单链表，单链表中的链表结点结构体定义如下 struct ListNode { int val; ListNode *next; Lis...
链表的各种题目整理(C语言实现)
yinshiwei2000lh的专栏
11-07 1501
链表的各种题目整理(C语言实现)   这里处理的全部是单链表: typedef struct node { char *data; struct node *next; } node_t; 我们约定一个打印链表的函数: void list_display(node_t *head) { for (; head; head = he
C++编程练习题大全(带答案).pdf
03-06
409页C++练习题，涵盖了入门习题，提高习题，同时也包含了大量基础算法及一些链表、队列等算法习题，方便在入门C++的同时，对一些算法进行了解。
2.1_链表基本练习题.CPP
10-28
从键盘输入一组整型元素序列，建立链表。要求输入元素递增，如果不递增提示重新输入刚才错误的数据。 实现该链表的遍历。 在该链表中进行顺序查找某一元素,查找成功返回1,否则返回0。 把元素x插入递增有序表中，...
蓝桥杯c++-蓝桥杯竞赛练习之基础练习题数列特征.zip
最新发布
04-15
【标题】"蓝桥杯c++-蓝桥杯竞赛练习之基础练习题数列特征" 涉及的是一系列针对C++编程语言和数列特征的竞赛练习题目，主要适用于准备参加蓝桥杯编程竞赛的学员。蓝桥杯是一项国内知名的编程竞赛，旨在提升参赛者的...
c++链表习题
10-18
单链表的删除 ，插入。删除具体数。删除非递减有序数列的相同元素。
16种链表的练习
08-17
16种链表的练习 1.c 有头 无序 不循环 单向 2.c 有头 有序 不循环 单向 3.c 无头 无序 不循环 单向 4.c 无头 有序 不循环 单向 5.c 有头 无序 循环 单向 6.c 有头 有序 循环 单向 7.c 无头 无序 循环 单向 8.c 无头 有序 循环 单向 9.c 有头 无序 不循环 双向 10.c 有头 有序 不循环 双向 11.c 无头 无序 不循环 双向 12.c 无头 有序 不循环 双向 13.c 有头 无序 循环 双向* 14.c 有头 有序 循环 双向 15.c 无头 无序 循环 双向 16.c 无头 有序 循环 双向 listVerOutput.c 将有头 无序 不循环 单向链表的指针指向逆序并输出。
C语言链表综合练习题
12-21
链表练习，可以帮助大家提高C语言链表处练习
C++中有关模板的试题题型练习题
06-27
C++中有关模板的试题题型练习题是C++模板类型题型的综合应用，涵盖了函数模板、类模板的设计方法和实现。下面对标题、描述、标签和部分内容进行详细的解释和分析。 一、函数模板设计 函数模板是C++模板技术的核心...
数据结构之链表练习题(leetCode）
容铎的博客
05-01 1712
数据结构之链表练习题(leetCode）
C++算法题：关于链表的算法
feikudai8460的博客
05-10 323
单向链表节点结构： struct ListNode { int key; ListNode *next; ListNode(int k = 0, ListNode *p = NULL) { key = k; next = p;} }; 问题1：输入一个链表的头结点，反转该链表，并返回反转后链表的头结点。 ListNode* ReverseList(ListNode *pHead) { ListNode *pPre = NULL;
链表经典练习题合集2（Java版）
qq_58284486的博客
03-18 1302
本篇主要为leetcode上链表部分中等及困难难度练习题，链表部分的习题画图十分重要，只要链表结构画出来，再写代码解决问题就容易很多。做完这些难度高的习题后发现，其实中等难度的习题只是将两个甚至三个以上的知识点融汇到一个题目中，当掌握链表的基本处理方法后，并用心去钻研，解决这些习题其实也不是想象中的那么难. 本篇中的例题代码均已更新在gitee代码仓库中，仓库链接：gitee代码仓库 希望我的解决思路可以给大家带来帮助，也希望大家可以指出我思路或者逻辑上的不足☺☺ 目录 两数相加 删除链表.
链表经典练习题合集（Java版）
qq_58284486的博客
03-15 2488
最近开始了数据结构的学习，数据结构是比较抽象的，需要不断的进行画图总结，不断地刷相关的题来加强自己对于数据结构的理解，我会不断地更新博客以及上传自己的做题记录以及题解，希望可以给大家带来帮助，也希望大家可以指出我存在的问题，共同进步☺ 这是我的gitee链接，所有的代码都已上传至gitee中：gitee代码仓库 目录 移除链表元素 反转链表 链表的中间结点 链表中倒数第k个结点 合并两个有序链表 移除链表元素 原题链接：203.移除链表元素 题目描述： 给你...
链表的实现及其相关习题
天上有好多星星
01-10 227
@TOC链表的实现及其相关习题 前言 1.链表的实现: 下文我通过递归实现 (在寻找Last元素时while循环也是可以的） 2.常见链表相关习题：【均来自LeetCode题库】 （1）反转链表。 （2）回文链表 （3）环形链表 （4）删除链表指定元素 （5）相交链表 (6)合并两个有序链表（排好序的） 二、常见链表相关习题: 1.单向链表的实现 public class MyLinkList{ //头节点 ..
K - 双向链表练习题
03-25
A：好的，下面是K - 双向链表练习题的解答。 题目描述： 设计一个数据结构，要求实现双向链表的基本操作：插入、删除、反转等，并实现一个方法向链表中添加一个元素。同时，该数据结构需要支持以下操作： 1. get(k)：返回链表中第 k 个节点的值。如果 k 小于 1 或大于链表的长度，则返回 -1。 2. addAtHead(val)：在链表的头部插入一个值为 val 的节点。 3. addAtTail(val)：在链表的尾部插入一个值为 val 的节点。 4. addAtIndex(index,val)：在链表中的第 index 个节点前插入一个值为 val 的节点。如果 index 等于链表的长度，则在链表的末尾添加该节点。如果 index 大于链表的长度，则不会插入。 5. deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。 解题思路： 题目要求我们设计一个双向链表数据结构，并提供选定的一些操作。这是一个经典的链表问题，我们需要先设计链表节点的结构体，并在节点中保留前驱和后继指针，便于双向操作。然后，我们可以定义一个链表类，在该类中定义一些方法来实现链表的基本操作。 本题需要实现的方法包括： 1. get(k)：遍历链表，找到第 k 个节点并返回该节点的值。 2. addAtHead(val)：创建一个新节点，将该节点作为头节点，并更新头节点的前驱指针。 3. addAtTail(val)：创建一个新节点，将该节点作为尾节点，并更新尾节点的后继指针。 4. addAtIndex(index,val)：遍历链表，找到第 index - 1 个节点，创建一个新节点，并将其插入到该节点的后面。如果 index 为零，则将新节点插入到头部。如果 index 等于链表的长度，则将新节点插入到末尾。 5. deleteAtIndex(index)：遍历链表，找到第 index - 1 个节点，并将其后继指针指向第 index + 1 个节点。如果 index 为零，则更新头节点。如果 index 等于链表的长度 - 1，则更新尾节点。 代码实现： 下面是基于C++的实现代码，其中Node是一个链表节点的结构体，List是链表类的定义： ```cpp #include<iostream> using namespace std; // 链表节点结构体 struct Node { int val; // 节点的值 Node* pre; // 前驱指针 Node* nxt; // 后继指针 Node(int _val):val(_val),pre(nullptr),nxt(nullptr){} // 构造函数 }; // 链表类 class List{ private: Node* head; // 头节点 Node* tail; // 尾节点 int size; // 链表长度 public: List():head(nullptr),tail(nullptr),size(0){} // 构造函数 int get(int k){ if(k < 1 || k > size) // 判断k是否合法 return -1; Node* p = head; for(int i=1; i<k; i++) // 遍历链表，找到第k个节点 p = p->nxt; return p->val; // 返回节点的值 } void addAtHead(int val){ Node* p = new Node(val); // 创建新节点 if(size == 0){ // 链表为空的情况 head = p; tail = p; }else{ // 链表非空的情况 p->nxt = head; // 插入节点 head->pre = p; head = p; } size++; // 更新链表长度 } void addAtTail(int val){ Node* p = new Node(val); // 创建新节点 if(size == 0){ // 链表为空的情况 head = p; tail = p; }else{ // 链表非空的情况 tail->nxt = p; // 插入节点 p->pre = tail; tail = p; } size++; // 更新链表长度 } void addAtIndex(int index, int val){ if(index > size) // index不合法，不插入 return; if(index <= 0) // 如果index小于等于0，插入到头部 addAtHead(val); else if(index == size) // 如果index等于size，插入到尾部 addAtTail(val); else{ // 如果index在链表中 Node* p = head; for(int i=1; i<index; i++) // 找到第index-1个节点 p = p->nxt; Node* q = new Node(val); // 创建新节点 q->nxt = p->nxt; // 插入节点 p->nxt->pre = q; p->nxt = q; q->pre = p; size++; // 更新链表长度 } } void deleteAtIndex(int index){ if(index < 0 || index >= size) // index不合法，不删除 return; if(index == 0){ // 如果要删除的是头节点 head = head->nxt; // 更新头节点 if(head == nullptr) // 如果链表为空，尾节点也需要更新 tail = nullptr; else head->pre = nullptr; }else if(index == size-1){ // 如果要删除的是尾节点 tail = tail->pre; // 更新尾节点 tail->nxt = nullptr; }else{ // 如果要删除的是中间节点 Node* p = head; for(int i=1; i<index; i++) // 找到第index-1个节点 p = p->nxt; p->nxt = p->nxt->nxt; // 删除节点 p->nxt->pre = p; } size--; // 更新链表长度 } }; int main(){ List l; l.addAtHead(1); l.addAtTail(3); l.addAtIndex(1,2); // 链表变为[1,2,3] cout<<l.get(1)<<" "; // 返回2 l.deleteAtIndex(1); // 现在链表是[1,3] cout<<l.get(1)<<" "; // 返回3 return 0; } ``` 总结： 双向链表实现相对较多的语言，相对单向链表更适合一些场景；比如说LUR Cache。对于双向链表的实现，我们需要注意节点间指针的指向关系，以及头节点和尾节点的处理。感兴趣的读者可以继续尝试其他链表问题，如链表的分割、链表的反转等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值