【考研数据结构代码题】day11-day20

最新推荐文章于 2024-04-27 23:57:08 发布
最新推荐文章于 2024-04-27 23:57:08 发布
阅读量636 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/arthur_diyun/article/details/128025190
版权

十一、尾插法 

思想：r->next=S; r=S;
**/

LinkList insert_tail(LinkList &L){
    LNode *S, *r=L;
    int x;
    L=(LinkList)malloc(sizeof(LNode));
    scanf("%d",&x);
    while(x!=NULL){
        S=(LinkList)malloc(sizeof(LNode));
        S->data=x;
        r->next=S;
        r=S;
    }
    r->next=NULL;
}


    

    
/**
十二、将带头结点的单链表就地逆置


思想：使用头插法依次将结点重新插入单链表
逆置就想到头插法
防止断链：r指针标记，保留p的后继，直到r为空
**/
法一：

LinkList reverse_linklist(LinkList &L){
    LNode *P=L->next, *r=p->next;
    L->next=NULL;//头结点指向空
    while(p!=NULL){
        r=p->next;//保留后继，防止断链
        //头插法
        p->next=L->next;
        L->next=p;
        //p，r向后移动
        p=r;
    }
    return L;
}

法二：改变链表指针方向：将p的后继，指向p的前驱
使用三个指针pre，p，r，

LinkList reverse_linklist(LinkList &L){
    LNode *pre=L->next,
    *P=pre->next,
    *r=p->next;
    pre->next=NULL;//第一个结点的后继指向空
    while(r!=NULL){
        p->next=pre;
        pre=p;
        p=r;
        r=r->next;
    }
    L->next=p;//最后，r指向空，头结点指向最后一个结点
    return L;
}


/**
十三、带头结点的单链表，结点值无序，编写函数删除大小介于s与t之间的元素


思想：1.找 2.删除
遍历链表，删除在最小值和最大值之间的数
**/

void Dels_t_Link(LinkList &L int s,int t){
    LNode *pre=L, *p=L->next;

    while(p!=NULL){
        if(p->data>=s && p->data<=t){
            pre->next=p->next;
            free(p);
            p=p->next;
        }
        else{//如果不是，两个指针都向后移
            pre=p;
            p=p->next;
        }
    }
    
}


/**
十四、给定两个单链表，编写算法找出两个单链表的公共结点  双指针问题


若有公共结点，链表形状是Y型，而不是X型

○ → ○ → ○ → ○ ↘          
                                 ○ → ○ → ○
        ○ → ○ → ○ ↗
思考：1.如何判断链表有公共结点? ----》 p,q同时到达表尾时，p=q 说明有公共结点；没有p=q 说明不存在公共结点
    2.如何同时到达表尾？ 长度相等好办，长度不相等呢？   ----》 若LA较长，LA表的p指针先移动k次(k=LA.length-LB.length)然后p,q再同步向后移动
**/
法一：暴力法；两次循环 时间复杂度O(LA x LB)

search_commmon(LinkList &LA,LinkList &LB){
        while(p!=NULL){
            while(q!=NULL){
            if(p=q){    //p=q,说明两个表的结点相遇/重合
                return p;
            q=q->next;
            }
            p=p->next;//一轮之后，没找到，p后移一个单位
        }
    }


    
法二：线性的方法优化后：O(2LA + LB) 也就是 O(LA+LB)

LinkList search_commmon(LinkList &LA,LinkList &LB){
    int k;
    int lenA=length(LA);
    int lenB=length(LB);
    if(lenA-lenB){
        k=lenA-lenB;    //求出两个链表之差
    }else {
        k=lenB-lenA;
    }
    p=LA->next;
    q=LB->next
    while(k--){ //p先移动k位
        p=p->next;
    }
    while(p!=NULL){
        if(p=q) return p; //若p=q，则找到了公共结点
        else{             //若不等，则同步向后移动
            p=p->next;
            q=q->next;
        }
    }
    return 0;   //如果最后都没用p=q，说明没有公共结点
}


/**
十五、将带头结点的单链表A 分解为两个带头结点的单链表A和B；


使得A表中含有原表中序号为奇数的元素，B表中含有原表中序号为偶数的元素，且保持其相对顺序不变
分析：要保持顺序不变，自然想到尾插法
思想：不断地使用尾插法，依次生成链表A、B
**/

LinkList create(LinkList &L){
    int i=0;
    B = (LinkList)malloc(sizeof(LNode));
    LNode *ra,*rb=B;  //A和B的表尾指针
    p=A->next;

    while(p!=NULL){
        i++;
        if(i%2==0){ //如果是偶数，插入B中
            rb->next=p;
            rb=p;
        }
        else{   //如果是奇数，插入到A中
            ra->next=p;
            ra=p;
        }
        p=p->next;
    }
    ra->next=NULL;
    rb->next=NULL;
    return B;
}


   /**
十六、将带头结点单链表C={a1,b1,a2,b2,...an,bn}拆分成两个单链表


使得A={a1,a2,...an},B={bn,...b2,b1}
分析：对于A使用尾插法；对B采用头插法
        头插防断链；尾插留指针
**/

LinkList create(LinkList &hc){
    LNode *ra=hc;   //尾插法的尾指针
    LNode *p=hc->next;  //遍历指针

    A=(LinkList)malloc(sizeof(LNode));
    B=(LinkList)malloc(sizeof(LNode));
    A->next=NULL;
    B->next=NULL;
    while(p!=NULL){//头插尾插交替进行，不必使用i
        ra->next=p;//尾插法插入A
        ra=p;
        p=p->next;
        if(p!=NULL){
            r=p->next;  //标记防断链
            p->next=B->next; //头插法插入B
            B->next=p;
            p=r;
        }       
    }
    ra->next=NULL;
}


/**
十七、递增有序的单链表中，删除重复的结点

分析：递增有序，则重复元素是相邻的
    1.找    2.删(需要知道前驱pre)  双指针（也可以用后继，如法二）
**/

法一：双指针pre、p
void del_same(LinkList &L){
    LNode *pre=L->next, *p=pre->next;
    while(p!=NULL){
        if(pre->data==p->data){
            pre->next=p->next;
            free(p);
            p=p->next;
        }
        else{   //两个指针同时向后移一位
            pre=p;
            p=p->next;
        }
    }
}

法二：一个指针p (实际还是双指针的思想，需令q=p->next)

void del_same(LinkList &L){
    LNode *p=L->next,*q;
    while(p->next!=NULL){
        q=p->next;
        if(p->data==q->data){
            p->next=q->next;
            free(q);
            p=p->next;
        }
        else{
            p=p->next;//相较法一，这里就只需移动一个指针了
        }
    }
}


/**
十八、两个按元素值递增次序排列的单链表，编写算法将两个单链表归并为一个元素值递减排列的单链表，要求利用原本的单链表结点存放归并后的单链表


思想：不断地将较小数头插法插入入合并链表，被插入结点的的指针后移一位，直到某一条链表为空
**/

LinkList Merge(LinkList &LA,LinkList &LB){
    LNode *p=LA->next,*q=LB->next;
    A->next=NULL;
    while (p!=NULL){
        while(q!=NULL){
            if(p->data > q->data){ //将B中较小数头插入A, q后移继续比较
                r=q->next;//防止断链
                q->next=LA->next;
                LA->next=q;
                q=r;//q向后移动
            }
            else{ //若p->data较小，p结点头插入A，p后移一位，继续比较
                r=p->next;
                p->next=LA->next;
                LA->next=p;
                p=r;
            }
        }    
    }
    //q==NULL,但p！=NULL;将A中剩余部分依次头插入A，或者改变指针方向
    while(p!=NULL){
        r=p->next;
        p->next=LA->next;
        LA->next=p;
        p=r;
    }
    //若p=NUUL;但q!=NULL；将B中剩余的依次头插入A，或者改变指针方向
    while(q!=NULL){
        r=q->next;
        q->next=LA->next;
        LA->next=q;
        q=r;
    }
}


/**
十九、A和B是两个单链表，其中元素递增有序，设计算法从A、B中的公共元素产生单链表C，要求不破坏A、B的结点（即不能改变其指针，只能申请新结点）

思想：表A、B有序，依次比较A、B元素。小的指针往后移，
若相等则创建新的结点，其元素值等于两结点的值。
使用尾插法插入到新表中，并将两个指针同时后移一位，直到表尾（若有剩余，无需处理）
**/

LinkList common(LinkList A,LinkList B){
    LNode *p=A->next,*q=B->next;
    LNode *r;
    LinkList C = (LinkList)malloc(sizeof(LNode));
    r=C;
    while(p!=NULL && q!=NULL){
        if(p->data<q->data){
            p=p->next;
        }
        else if(p->data>q->data){
            q=q->next;
        }
        else if(p->data==q->data){  //若两个元素相等
            S=(LinkList)malloc(sizeof(LNode));
            S->data=p->data;
            r->next=S;
            r=S;
            p=p->next;  //两个指针同时向后移
            q=q->next;
        }
        r->next=NULL;
        return C;   
    }
 
}

/*************
二十、两个链表A、B分别表示两个集合，其元素递增有序排列。编写函数求A、B的交集，并存放于A链表中

分析：A中只能存放公共元素，不符合要求的结点要释放掉 边比较边释放空间
算法思想：
1.依次扫描A、B结点，比较扫描结点data域的值，将较小的指针向后移（并释放空间）
2.若两者相等，尾插入A，直到遍历表尾
3.若有剩余，则剩余元素不可能有交集，全部释放）
**/

LinkList common(LinkList &A,LinkList &B){
    LNode *p=A->next,*q=B->next, *r,*u;
    A->next=NUll;//尾插尾结点置空，p保留了A的后继，不用担心断链
    r=A;
    while(p!=NULL&&q!=NULL){
        if(p->data<q->data){
            u=p;
            p=p->next;
            free(p);
        }
        else if(p->data > q->data){
            u=q;
            q=q->next;
            free(u);
        }
        else if(p->data==q->data){  //如果两元素相等，保留p，释放q
            //保留p，尾插入A
            r->next=p;
            r=p;
            p=p->next;
            //释放q
            u=q;
            q=q->next;
            free(u);
        }
    }
    while(p!=NULL){ //若A有剩余
        u=p;
        p=p->next;
        free(u);
    }
    while(q!=NULL){ //若B有剩余
        u=q;
        q=q->next;
        free(u);
    }
    r->next=NULL;
    return A;
}

nknk233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
考研数据结构题库
01-25
数据结构题库 涵盖多种数据结构习题。。。。。。。。。
大师兄手把手教你写考研数据结构代码题（50天代码整理合集）f
热门推荐
Senbonzakura_py的博客
10-20 1万+
考研数据结构必会的代码题目
数据结构 考研 代码题
20岁爱吃必胜客
01-18 316
pointer指针==地址 空指针 零值 n 变量名 int i=2; int *p=&i; int *p; *p=&i; int **q=&p;间接间接 指针的指针 第二讲 malloc（） char *p; p=(char )malloc(10sizeof(char)); strcpy() 数组名 和 指针指向一段连续空间一样 数组名 指针 地址 一样的 struct teacher{ int no； char name[6]; int age; }; 考边界对齐 struc
考研之数据结构常见代码题01
m0_46389413的博客
04-26 2986
一、线性表 1.在一个递增有序的顺序表中插入元素Y，得到的顺序表仍然有序。 该算法的思想主要分有三步：找到插入位置、插入、整个顺序表的长度加一。 //find方法是用来寻找所插入元素的合适位置 int find(Sqlist L,int Y){ for(int i=0;i<L.length;i++){ //如果Y<L.data[i]则证明已经找到合适位置，然后跳出循环 if(Y<L.data[i]){
顺序表考研数据结构代码题（一）
m0_56195414的博客
04-13 65
2.对长度为n的顺序表L，编写一个时间复杂度为O（n）,空间复杂度为O（1）的算法，该算法删除线性表中所有值为x的数据元素。3.从有序顺序表中删除其值在给定值s与t之间（要求s<t）的所有元素，若s或t不合理或顺序表为空，则显示出错信息并退出运行。1.设计一个高效算法，将顺序表L的所有元素逆置，要求算法空间复杂度为O（1）5.将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表。4.从有序表中删除所有其值重复的元素，使表中所以元素的值均不同。顺序表考研数据结构代码题。
考研杭电计算机数据结构真题答案详解-有解释
10-10
考研杭电计算机数据结构真题答案详解-有解释。除去算法编程题。
考研王道数据结构代码.zip
11-26
里面是2020王道数据结构课后习题可执行代码。https://blog.csdn.net/qq_40285036 可以参考这个博客一起学习。
数据结构考研必看代码题
04-26
数据结构考研必看代码题，考研党必备
考研数据结构算法代码总结.pdf
05-12
考研数据结构算法总结
考研数据结构代码大全
10-26
考研期间总结的数据结构代码大全，包括列表，栈，队列，树，图，查找，字符串，排序等数据结构的实现C语言实现版本，需要的朋友可以参考一下。
目前最完整的数据结构1800题内含完整答案（考研专用）
09-08
目前整理的最完整的数据结构测试题，内含完整完整的答案和解析,考研党必用，考研复习最后冲刺用。
各大高校数据结构考研历年真题
07-25
这个集合了各大高校的数据结构的考研历年真题，以分章节的形式给出，很适合正在复习研究生考试的同学们。
考研数据结构代码整理
qq_40694323的博客
06-19 906
特别推荐：https://blog.csdn.net/out_of_memory_error/article/details/102332332
考研数据结构程序题常见代码【C语言实现】
Infinity_and_beyond的博客
10-10 3631
考研院校要求C语言实现数据结构，可前期做数据结构都是用Java实现，因此对于C不那么熟悉，花了一些时间重新捡起来C的语法，程序题通常不会考太过复杂的算法，因此自己将辅导书上一些母题进行了实现，其中层序遍历部分需要用到队列，查了一下发现C语言没有现成的头文件调入使用，因此这部分用了C++的语法，除此之外皆为C的语法，现整理如下 链表 结构体实现链表样例 #include<stdio.h> #include<stdlib.h> typedef struct Node{ int nu.
手撕考研数据结构（代码汇总篇）
Jiawen9的博客
06-02 3342
手撕考研数据结构（线性表、树、图、查找排序、算法），全部由c++实现
18版考研数据结构天勤课后习题代码-查找【完】
努力努力再努力0.0的博客
09-11 271
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> u...
19版考研数据结构王道课后习题代码-查找【完】
努力努力再努力0.0的博客
09-17 426
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
数据结构七：线性表之链式栈的设计
weixin_47040031的博客
04-27 796
从以上分析，我们可以知道链式栈只是单链表的一种特殊情况，限定了数据元素的插入和删除位置，链式栈是一种基于单链表实现的栈，在空间复杂度上，顺序栈在创建时就申请了数组空间，若栈经常处于不满状态将造成存储空间的浪费；链式栈所需空间是根据需要随时申请的，比之顺序栈仅仅是其每个结点需要额外的空间以存储其next指针域。在时间复杂度上，对于针对栈顶的基本操作（压入、弹出和栈顶元素存取），容易看出，顺序栈和链式栈的时间复杂性均为O(1)。
数据结构––串
最新发布
2301_80190473的博客
04-27 273
由一个或多个称为空格的特殊字符组成的串（长度是空格字符的个数）：子串的定位运算，是一种子串在主串中第一次出现的第一个字符的位置。：串中任意连续字符组成的子序列（空串是任意串的子串）：抽取串的一些字符，按照原字符串的顺序进行放置的新串。由零个或者任意多个字符组成的有限序列，是一种特殊的。串是一种特殊的顺序表，因此也可以分为顺序表和链表。：串中的有效元素的个数（不包括\0）：2个串的长度及对应的字符都相等。：不包括任何元素的串，长度为0。，每一个元素都是单独一个字符。空格也可以是一个字符。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值