数据结构代码集训day9（适合考研、自学、期末及专升本）

最新推荐文章于 2024-08-29 16:08:24 发布
最新推荐文章于 2024-08-29 16:08:24 发布
阅读量961 收藏 16
点赞数 23
文章标签： 数据结构 考研 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61522765/article/details/141650579
版权

代码题均来自B站up：白话拆解数据结构。

今日习题：

        （1）将两个递增的有序链表合并为一个递增的有序链表，不能有重复的元素，不能占用其他内存空间；

        （2）将带头单链表A分解为带头节点的单链表A和B，使得A表含原表中序号为奇数的元素，而B表中含有原表中序号为偶数的元素，且保持相对元素不变；

        （3）将（2）中的单链表A还是拆分成两个表，但在上述条件下，保持a表不变，b表元素逆置。

题1

        第一题和昨天第二题那道题完全一样，就是多了一个要求：不能有重复的元素，删除掉就行了。

Linklist sort_2to1list(Linklist &L1,Linklist &L2){

    Lnode *p,*q;

    p=L1->next;

    q=L2->next;

    while(q){

        Lnode *p_pre=L1;

        Lnode *q_next=q->next;

        p=L1->next;

        while(p&&p->data<q->data){  //找插入位置

            p_pre=p;

            p=p->next;

        }

        q->next=p;

        p_pre->next=q;

        q=q_next;

    }   //上面部分代码和昨天完全一致

   

    Lnode *s=L1,*t=L1->next;

    while(t){       // 找重复值

        if(s->data==t->data){

            s->next=t->next;

            free(t);

            t=s->next;

        }else{

        s=s->next;

        t=t->next;

        }

    }

    L2->next=NULL;

    return L1;

}

        我这里把值重复的单独做了删除操作，也有简便的写法。

Linklist sort_2to1list(Linklist &L1,Linklist &L2) {

    Lnode *p, *q;

    p = L1->next;

    q = L2->next;

    while(q) {

        Lnode *p_pre = L1;

        Lnode *q_next = q->next; // 保存 q 的下一个节点

        p = L1->next;

        // 找到合适的位置插入 q

        while (p && p->data < q->data) {

            p_pre = p;

            p = p->next;

        }

        // 如果在适当的位置插入 q

        if (!p || p->data != q->data) {

            q->next = p_pre->next;

            p_pre->next = q;

        } else {

            // 如果有相同的数据，直接跳过，不插入重复元素

            free(q);  // 释放 q 节点的内存

        }

        q = q_next;  // 继续处理下一个 q 节点

    }

   

    // 不需要再额外进行去重，因为插入时已经去重

    L2->next = NULL;

    return L1;

}

         实践：

        完整代码如下：

#include <iostream>
#include <cstdio>
#include <ctime>

using namespace std;

// 单链表结构体定义
typedef struct Lnode{
    int data;
    Lnode *next;
}Lnode,*Linklist;

Linklist list_insertbytail(Linklist &L){
    Lnode *s;
    int x;
    L = (Lnode*)malloc(sizeof(Lnode));
    L->next = NULL;
    Lnode *r = L;
    cin >> x;
    while(x!=9999){
        s = (Lnode*)malloc(sizeof(Lnode));
        s->data=x;
        s->next=NULL;

        r->next = s;
        r=r->next;
        cin >> x;
    }
    return L;
}

// 将两个递增的有序链表合并为一个递增的有序链表，不能有重复的元素，不能占用其他内存空间
Linklist sort_2to1list(Linklist &L1,Linklist &L2){
    Lnode *p,*q;
    p=L1->next;
    q=L2->next;
    while(q){
        Lnode *p_pre=L1;
        Lnode *q_next=q->next;
        p=L1->next;
        while(p&&p->data<q->data){  //找插入位置
            p_pre=p;
            p=p->next;
        }
        q->next=p;
        p_pre->next=q;
        q=q_next;
    }   //上面部分代码和昨天完全一致
    
    Lnode *s=L1,*t=L1->next;
    while(t){       // 找重复值
        if(s->data==t->data){
            s->next=t->next;
            free(t);
            t=s->next;
        }else{
        s=s->next;
        t=t->next;
        }
    }
    L2->next=NULL;
    return L1;
}

//另一种写法，简洁

Linklist sort_2to1list(Linklist &L1,Linklist &L2) {
    Lnode *p, *q;
    p = L1->next;
    q = L2->next;
    while(q) {
        Lnode *p_pre = L1;
        Lnode *q_next = q->next; // 保存 q 的下一个节点
        p = L1->next;
        // 找到合适的位置插入 q
        while (p && p->data < q->data) {
            p_pre = p;
            p = p->next;
        }
        // 如果在适当的位置插入 q
        if (!p || p->data != q->data) {
            q->next = p_pre->next;
            p_pre->next = q;
        } else {
            // 如果有相同的数据，直接跳过，不插入重复元素
            free(q);  // 释放 q 节点的内存
        }
        q = q_next;  // 继续处理下一个 q 节点
    }
    
    // 不需要再额外进行去重，因为插入时已经去重
    L2->next = NULL;
    return L1;
}

int main(){
    Linklist L1,L2;
    list_insertbytail(L1);
    list_insertbytail(L2);
    Lnode *p = L1->next;
    Lnode *q = L2->next;
    printf("origin listL1:");
    while (p != NULL) {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
    printf("origin listL2:");
    while (q != NULL) {
        printf("%d ",q->data);
        q = q->next;
    }
    printf("\n");

    sort_2to1list(L1,L2);
    printf("new list:");

    Lnode *qs = L1->next;
    while (qs != NULL) {
        printf("%d-> ",qs->data);
        qs = qs->next;
    }
    printf("NULL");
    return 0;
}

题2

        直接带着代码看吧！

Linklist Decompose(Linklist &L){

    if(!L||!L->next)   return L;

    Linklist L2;        // 新建一个头结点

    L2 = new Lnode;

    L2->next=NULL;

    Lnode *p,*q,*r,*s;        // 定义一些工作指针

    p=L->next;

    q=p->next;

    L2->next=q;

    p->next=NULL;        // 断开，作为表1

    r=q->next;

    q->next=NULL;        // 断开，作为表2

    int i =1;        // 记录奇数还是偶数

    if(!r)   return L2;               // 

    while(r){        // r指针用来遍历还未插入的链表部分

        s=r->next;        // 每次循环更新s指针，s指针始终指向r指针的后面

        if(i%2==1){

           p->next=r;

           r->next=NULL;        // 断开它，不然两个链表会交叉着链接

           p=p->next;

        }

        else

        {

            q->next=r;

            r->next=NULL;        //  // 断开它，不然两个链表会交叉着链接

            q=q->next;

        }

        r=s;        // 更新r指针和计数器

        i++;

    }

    return L2;        // 返回表2即可，L1加了引用会保持这种改变

}

         由于是一个表变成两个带头结点的表，所以要先创建第二个表的头结点，然后初始化一些指针，如下图：

        这样的做法就是默认链表最少有两个结点，然后从第三个结点开始（第三个结点是单数开始），然后单数连L，偶数连L2

        这里展示一下连4结点的操作（奇数结点）：就是if里面的语句

        演示结束，实践一下：

        看看特殊情况，就是我们定的规矩，3个结点的情况：

        代码如下：

#include <iostream>
#include <cstdio>
#include <ctime>

using namespace std;

// 单链表结构体定义
typedef struct Lnode{
    int data;
    Lnode *next;
}Lnode,*Linklist;

Linklist list_insertbytail(Linklist &L){
    Lnode *s;
    int x;
    L = (Lnode*)malloc(sizeof(Lnode));
    L->next = NULL;
    Lnode *r = L;
    cin >> x;
    while(x!=9999){
        s = (Lnode*)malloc(sizeof(Lnode));
        s->data=x;
        s->next=NULL;

        r->next = s;
        r=r->next;
        cin >> x;
    }
    return L;
}

// 将带头单链表A分解为带头节点的单链表A和B，使得A表含原表中序号为奇数的元素，而B表中含有原表中序号为偶数的元素，且保持相对元素不变
Linklist Decompose(Linklist &L){
    if(!L||!L->next)   return L;
    Linklist L2;
    L2 = new Lnode;
    L2->next=NULL;

    Lnode *p,*q,*r,*s;
    p=L->next;
    q=p->next;
    L2->next=q;
    p->next=NULL;
    r=q->next;
    q->next=NULL;
    int i =1;
    if(!r)   return L2;
    while(r){
        s=r->next;
        if(i%2==1){
           p->next=r;
           r->next=NULL;
           p=p->next;
        }
        else 
        {
            q->next=r;
            r->next=NULL;
            q=q->next;
        }
        r=s;
        i++;
    }
    return L2;
}


int main(){
    Linklist L;
    list_insertbytail(L);
    Lnode *p = L->next;
    printf("origin list:");
    while (p != NULL) {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
    Lnode *q=Decompose(L);
    printf("new L1:");

    Lnode *s = L->next;
    while (s != NULL) {
        printf("%d-> ",s->data);
        s = s->next;
    }
    printf("NULL");
    printf("\n");

    printf("new list L2:");


    while (q ->next!= NULL) {
        printf("%d-> ",q->next->data);
        q = q->next;
    }
    printf("NULL");
    return 0;
}

 题3

        和题2差不多，很相似，偶数表采用头插法就行了，easy。

Linklist Decompose2(Linklist &L){

    if(!L||!L->next)   return L;

    Linklist L2;

    L2 = new Lnode;

    L2->next=NULL;

    Lnode *p,*q,*r,*s;

    p=L->next;

    q=p->next;

    L2->next=q;

    p->next=NULL;

    r=q->next;

    q->next=NULL;

    int i =1;

    if(!r)   return L2;

    while(r){

        s=r->next;

        if(i%2==1){

           p->next=r;

           r->next=NULL;

           p=p->next;

        }        // 上述都一致

        else

        {        // 头插法

            L2->next=r;

            r->next=q;

            q=r;

        }

        r=s;

        i++;

    }

    return L2;

}

        实践一下：

        看看特殊情况：三个结点

         代码如下：

#include <iostream>
#include <cstdio>
#include <ctime>

using namespace std;

// 单链表结构体定义
typedef struct Lnode{
    int data;
    Lnode *next;
}Lnode,*Linklist;

Linklist list_insertbytail(Linklist &L){
    Lnode *s;
    int x;
    L = (Lnode*)malloc(sizeof(Lnode));
    L->next = NULL;
    Lnode *r = L;
    cin >> x;
    while(x!=9999){
        s = (Lnode*)malloc(sizeof(Lnode));
        s->data=x;
        s->next=NULL;

        r->next = s;
        r=r->next;
        cin >> x;
    }
    return L;
}


// 还是拆分成两个表，a表不变，b表逆置
Linklist Decompose2(Linklist &L){
    if(!L||!L->next)   return L;
    Linklist L2;
    L2 = new Lnode;
    L2->next=NULL;

    Lnode *p,*q,*r,*s;
    p=L->next;
    q=p->next;
    L2->next=q;
    p->next=NULL;
    r=q->next;
    q->next=NULL;
    int i =1;
    if(!r)   return L2;
    while(r){
        s=r->next;
        if(i%2==1){
           p->next=r;
           r->next=NULL;
           p=p->next;
        }
        else 
        {
            L2->next=r;
            r->next=q;
            q=r;
        }
        r=s;
        i++;
    }
    return L2;
}


int main(){
    Linklist L;
    // list_insertbyhead(L);
    list_insertbytail(L);
    Lnode *p = L->next;
    printf("origin list:");
    while (p != NULL) {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
    Lnode *q=Decompose2(L);
    printf("new L1:");

    Lnode *s = L->next;
    while (s != NULL) {
        printf("%d-> ",s->data);
        s = s->next;
    }
    printf("NULL");
    printf("\n");

    printf("new list L2:");


    while (q ->next!= NULL) {
        printf("%d-> ",q->next->data);
        q = q->next;
    }
    printf("NULL");
    return 0;
}

摆烂的小白
关注
  • 23
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2016山东省NOI省队集训DAY2 题目题解数据标程
04-18
本资源是关于2016年山东省全国信息学奥林匹克（NOI）省队集训第二天的训练题目解析及数据标程。信息学奥林匹克是一项针对中学生的编程竞赛，旨在提升青少年在计算机科学领域的技能，尤其是算法设计与问题解决能力。...
2016山东省NOI省队集训DAY5 题目题解数据标程 NOIP省选集训
04-18
【标题】"2016山东省NOI省队集训DAY5 题目题解数据标程 NOIP省选集训"所涉及的主要知识点包括： 1. NOI（全国青少年信息学奥林匹克竞赛）：NOI是中国最高级别的青少年信息学竞赛，旨在选拔优秀学生参加国际信息学...
2016山东省NOI省队集训DAY6 题目题解数据标程 NOIP省选集训
04-18
参赛者需要掌握C++、Python等编程语言，算法设计与分析，数据结构，以及问题解决能力。 2. NOIP（全国青少年信息学奥林匹克联赛）：NOIP是NOI的预选赛，面向初中和高中生，分为普及组和提高组，通过初赛、复赛两个...
2016山东省NOI省队集训DAY7 题目题解数据标程 NOIP省选省队集训
04-18
《2016山东省NOI省队集训DAY7 题目题解数据标程 NOIP省选省队集训》是针对全国青少年信息学奥林匹克（NOI）及山东省选拔赛省队集训的一项重要教学资料。这个压缩包包含了集训的第七天的相关内容，旨在帮助参赛学生...
2016山东省NOI省队集训DAY4 题目题解数据标程 NOIP省选集训
04-18
4. problem_DAY4.pdf：这可能是一份详细的题目集，包含第四天集训的所有题目，涵盖了算法设计、数据结构运用、逻辑推理等多个方面。选手需要阅读题目，理解要求，然后编写程序解决问题。 5. 命题思路.pptx：这份...
数据结构
2301_80184169的博客
08-28 568
4.执行代码,复现段错误,产生包含出错信息的core文件(检查core文件是否生成)3.ulimit -c unlimited 不限制core文件的生成的大小。使用这种方法能够很好的解决段错误，在纠正和优化代码时效率显著提升。1.首先按照如下的方法配置Ubuntu，允许生成core文件。5.gdb a.out core 查看段错误产生的位置。2.重新编译代码并加入-g选项(允许进行GDB调试)
25版王道数据结构课后习题详细分析 第五章 树与二叉树 5.4 树、森林
2406_86301373的博客
08-26 576
解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 868
数组，双链表实现队列，附完整代码
数据结构（邓俊辉）学习笔记】串 10——BM_BC算法：坏字符
weixin_44399845的博客
08-28 863
BM_BC算法：坏字符
Java-数据结构-包装类和认识泛型 !!!∑(ﾟДﾟノ)ノ
2303_80388948的博客
08-27 1201
对于泛型就是：使用与许多许多类型。从代码上来说呢，就是对类型实现了参数化。对于引出泛型，我们来实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。在这里呢，我们用 Object类 来进行创建数组，Object是所有类的父类，但是呢，我们在这里呢就有一些问题，我们来看看：1、在这里呢，我们这个数组当中可以存放任何类型2、我们每次进行的到值时候呢，都要进行强转。
集合及数据结构第十三节（下）———— 枚举与Lambda表达式
2301_79418684的博客
08-27 1195
枚举与枚举的使用 1. 什么是C语言 2. 数据类型 3. 变量、常量 4. 字符串+转义字符+注释 5. 选择语句 6. 循环语句 7. 函数 8. 数组 9. 操作符 10. 常见关键字 11. define 定义常量和宏 12. 指针 13. 结构体
Java算法之插入排序（Insertion Sort）
最新发布
weixin_38959316的博客
08-29 305
插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这个过程像打牌时整理手中的牌一样，逐步将数据排列成有序。插入排序虽然在实际应用中的效率不如一些更高级的排序算法，但它的原理简单，易于实现，且对于部分有序的数据集表现良好。
数据结构（邓俊辉）学习笔记】串 06——KMP算法：构造next[]表
weixin_44399845的博客
08-27 767
KMP算法：构造next[]表
初识数据结构
qixi_ao的博客
08-26 581
数据结构
【JAVA】后端开发中的数据结构：基础知识与应用场景
一个不断前行的程序者
08-25 1210
*数据结构是后端开发中的基础和核心。**通过了解数据结构的基本概念、常见类型以及在日常开发中的应用场景，我们可以更好地运用数据结构来提高程序的性能和可维护性。在后端开发中，掌握数据结构对于提升个人技能和职业发展具有重要意义。在实际工作中，我们应该根据具体需求和场景选择合适的数据结构，以实现高效、稳定的系统设计。
数据结构——单向链表
m0_61965705的博客
08-28 728
算法：快指针先走k步，慢指针和快指针每次走1步(快指针总是领先慢指针k步)，当快指针走到末尾时,慢指针即指向链表倒数第k个节点。无头单向链表，节点插入在头的话，每次头结点都会变，所以有了有头链表，头结点的pNext总是指向链表的第一个节点。算法：快指针pFast每次走2步，慢指针pSlow每次走1步，快指针到达末尾时，慢指针所在的位置即为中间位置。因为快指针第一次比慢指针多1，第二次快指针比慢指针快2，依次类推，环长一定是一个自然数，所以一定能相遇。每次选出最小的，第二小的...最大的，
数据结构 链表
2301_79898193的博客
08-28 332
1.链表可以动态的增加或者减少节点，而顺序表在一开始就定义了大小，扩展或缩小数组会涉及内存的重新分配，效率低下；2.插入和删除效率 链表更容易时间复杂度为O（1），顺序表需要整个移动大量资源时间复杂度为O(n);3.链表的内存可以是碎片化不连续的内存，而顺序表一定是需要连续的内存，会出现浪费行为。数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。4.链表的插入和删除效率很高。
树数据结构（Tree Data Structures）的全面指南：深度解析、算法实战与应用案例
Chauvin的博客
08-27 1848
树数据结构（Tree Data Structures）作为计算机科学中的基石之一，以其独特的层次结构和分支特性，在众多领域发挥着关键作用。从文件系统的组织到数据库的索引，从编译原理的语法分析到人工智能的决策制定，树数据结构无处不在。本文将深入探讨树数据结构的基本概念、类型、遍历方式及其在实际应用中的广泛案例。
数据结构（邓俊辉）学习笔记】串 07——KMP算法：分摊分析
weixin_44399845的博客
08-27 571
KMP算法：分摊分析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值