王道考研408 数据结构 2.3 链表练习题

于 2022-09-28 11:12:41 发布
阅读量1.3k 收藏 11
点赞数 2
分类专栏： 好帅的专栏啊 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46524058/article/details/127085890
版权

2.3

pre
typedef struct Lnode{
    ElemType data;
    struct Lnode *next;
}LNode,*LinkList;
typedef struct DNode{
    ElemType data;
    struct DNode *prior,*next;
}DNode, *DLinklist;
2.3.02

在带头结点的单链表L中，删除所有值为x的结点，并释放其空间，假设值为x的结点不唯一，试编写算法以实现上述操作。

void del_x(LinkList &L, ElemType x)
{
    LNode *p = L->next, *pre = L, *q;//q是临时节点，好像就要用指针
    while(p!=NULL){
        if(p->data == x){
            q = p;
            p = p->next;
            pre->next = p;
            free(q);
        }
        else{
            pre = p;
            p = p->next;
        }//else
    }//while
}
2.3.03

设L为带头结点的单链表，编写算法实现从尾到头反向输出每个结点的值

void print_r(LinkList &L)
{
    if(L->next!=NULL) print_r(L->next);
   	if(L!=NULL) printf("%d",L->data);
}
void reverse(LinkList &L)
{
    if(L!=NULL) print_r(L);
  	return;
}
2.3.05

试编写算法将带头结点的单链表就地逆置，也就是空间复杂度为O(1)

//解法一，拆下来以后用头插法反插
LinkList reverse(LinkList &L)
{
    LNode *p,*r,*pre;
    p = L->next;L->next=NULL;
    while(p->next!=NULL){
        q = p->next;
        p->next = L->next;
        L->next = p;
        p = q;
    }
    return L;
}
//解法二，反向插，最后将位置指向L，两个时间复杂度都是O(n)，空间复杂度为O(1)
LinkList reverse(LinkList &L)
{
    LNode *p,*r,*pre;
    p = L->next; r = p->next; p->next = NULL; 
 	while(r!=NULL){
        pre = r->next;
        r->next = p;
        p = r;
        r = pre;
    }   
    L->next = p;
    return L;
}
2.3.08

给定两个单链表，编写算法找出两个链表的公共结点

分析：如果存在公共结点，那两个链表的结尾都是相同的，所以可以先计算两个链表的长度，再减去插值寻找公共结点，时间复杂度为O(length1+length2)

LinkList find_1st(LinkList &L1, LinkList &L2)
{
    int len1 = Length(L1), len2 = Length(L2);
    int dist;
    LinkList p,q;
    if(len1>len2){
        p = L1->next; q = L2->next;
        dist = len1-len2;
    }
    else{
        p = L2->next; q = L1->next;
        dist = len2-len1;
    }
    while(dist--){
        p = p->next;
    }
    while(p!=NULL){
        if(p==q)//真的可以这么写吗？
            return p;
        else{
            p = p->next;
            q = q->next;
        }
    }
    return NULL;
}
2.3.11

将一个带头结点的单链表A分解为两个带头结点的单链表B和C，使得B表中含有原表中序号为奇数的元素，而C表中含有原表中序号为偶数的元素，且C表中顺序反过来，并保持相对顺序

思路：没啥区别，练练链表的手。有个很有意思的地方，就是这个怎么返回两个链表的同时读入一个链表，答案的做法是保留原来输入的链表作为其中一个结果进行输出，另一个用函数返回值进行返回。

LinkList divide(LinkList &A )
{
    LinkList B = (LinkList)malloc(sizeof(LNode));
    B->next = NULL;
    LNode *p=A->next, *q;
    LNode *tmp = A;//指向A的尾结点
    while(p!=NULL){
        tmp->next = p; tmp = p;
        p = p->next;
        if(p!=NULL){
            q = p->next;
            p->next = B->next;
            B->next = p;
            p = q;
        }
    }
    tmp->next = NULL;
    return B;
}
LinkList divide_myself(LinkList &A)
{
    LinkList B = (LinkList)malloc(sizeof(LNode));
    B->next = NULL;
    LNode *pr = A;
    LNode *cr = A->next;
    while(cr!=NULL){
        cr = cr->next;pr = pr->next;
        if(cr!=NULL){
            pre->next = cr->next;
            cr->next = B->next;
            B->next = cr->next;
            cr = pre->next;
        }
    }
    cr->next =NULL;//如果是奇数的情况下进行的定义
	return B;   
}
2.3.16

两个整数序列A=a1,a2,…,am和B=b1,b2,…,bn已经存入两个单链表中，设计一个算法判断B是否是A的连续子序列

int child_series(LinkList &A, LinkList &B)
{
    LNode *a = A, *b = B;
    LNode *p = a;//用于存档
    while(a&&b){
        if(a->data == b->data){
            a = a->next;
            b = b->next;
        }
        else{
            b = B;//回到表头
            p = p->next;
            a = p;
        }   
    }//while
    if(b == NULL) return 1;
    else return 0;
}
2.3.20

设头指针为L的带有表头结点的非循环双向链表,其每个结点中除有prior(前驱指针),data(数据)和next(后继指针)域外,还有一个访问频度域freq.在链表被启用前,其值均初始化为零,每当在链表中进行一次Locate(L,x)运算时,令元素值为x的结点中freq域的值增1,并使此链表中结点保持按访问频度非增(递减)的顺序排列,同时最近访问的结点排在频度相同的结点前面,以便使频繁访问的结点总是靠近表头.试编写符合上述要求的Locate(L,x)运算的算法,该运算为函数过程,返回找到结点的地址,类型为指针型.

void Locate(LinkList &L, ElemType x)
{
    LNode *s = L;
    LNode *sr = L, tmp;
    while(s!=NULL){
        if(s->data != x) s = s->next;
        else s->freq++;
    }
    if(s==NULL)//not found
        return -1;
    else//change the place
    { 
        while(sr->freq>s->freq&&sr!=NULL) sr = sr->next;
        if(sr!=NULL){//exist prior place
        	s->pred->next = s->next;
            s->next->pred = s->pred;
            sr->pred->next = s;
           	s->pred = sr->pred; 
            s->next = sr;
            sr->pred = s;
        }// end if
    }//end else
}
//也可以考虑从s开始往前遍历，这样的效率更高但是我不想再写一版了。
2.3.22

已知一个带有表头结点的单链表,结点结构为 data link 假设该链表只给出了头指针list。在不改变链表的前提下,请设计一个尽可能高效的 算法,查找链表中倒数第k个位置，如果成功则输出该点的data域的值，并返回1，否则返回0

  1. 基本思路

    直接取两个节点，一个在后面k个位置，后面那个到NULL了前面那个刚好再倒数第k个位置。

  2. 代码

int find_reverse_k(int k, LinkList &L)
{
    LNode *pre = L, *lat = L;
    for(int i = 0; i<k; i++){
        lat = lat->next;
        if(lat == NULL) return 0;
    }
   	while(lat!=NULL){
        lat = lat->next;
        pre = pre->next;
    }
   	printf("%d",pre->data);
    return 1;
}
2.3.25

设线性表L=(a1,a2,a3,…,an-2,an-1,an)，采用带头节点的单链表保存。设计算法，重新排列L中的节点，得到线性表L’=(a1,an,a2,an-1,a3,an-2,…)。

  1. 思路

    我想的是先建立头结点，然后先用尾插法把后半部分给插上，再正向进行一个隔一个的差。这样的时间复杂度是O(n)，空间复杂度是O(1)

  2. (typora的换行真的是一坨沈阳美食家)代码

LinkList reshape(LinkList &L)
{
    LinkList B = (LinkList)malloc(sizeof(LNode));
    LNode *tmp;
    B->next = NULL;
    LNode *mid=L->next, *fin=L->next;
    int length=0;//the length of line
    //first find the mid place
    while(fin!=NULL){
        mid = mid->next;
        fin = fin->next;
        if(fin!=NULL){
            fin = fin->next;
            length+=2;
        }
        else length+=1;
    }
    // mid is deemed to be the later part and without the mid point
  	while(mid!=NULL)
    {
        tmp = mid;
 		mid->next = B->next;
        B->next = mid;
       	mid = tmp->next;
    }
    // after this, it is (an,an-1,...a(n/2))
    tmp = L->next; fin = tmp->next; mid = B;
    for(i = 0; i<(length+1)/2; i++){
        tmp->next = mid->next;
        mid->next = tmp;
        mid = mid->next->next;
        tmp = fin;
        fin = fin->next;
    }
    return B;
}
//当然，也可以像答案那样直接把后半部分进行逆置，然后前后加，也可以得到一样的结果
void change_list(Node *h)
{
    Node *p,*q,*r,*s;
    p = q = h;
    while(q->next != NULL){
        p = p->next;
        q = q->next;
    	if(q->next != NULL) q = q->next;
    }
    q = p->next;//p所指节点为中间节点，q为后半段链表的首节点，我的做法提前next了，所以不一样
    p->next = NULL;
    while(q!=NULL){//将链表后半段逆置
        r = q->next;
        q->next = p->next;
        p->next = q;
        q = r;
    }
    s = h->next;
    q = p->next;
    p->next = NULL;
    while(q!=NULL)
    {
        r = q->next;
        q->next = s->next;
        s->next =q;
        s = q->next;
        q = r;
    }
}
后记

链表有点难，但是很suang口，写到后面还是有点high的

熠熠发光的白
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
考研王道数据结构代码.zip
11-26
"考研王道数据结构代码.zip"这个压缩包包含了2020年王道数据结构课程的课后习题代码，对于考生来说是一个宝贵的参考资料。 王道数据结构教材以其清晰易懂的讲解和丰富的例题著称，其配套的可执行代码可以帮助学生更...
在带头结点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为X的结点不唯一，试编写算法以实现上述操作
热门推荐
WANG的博客
06-30 1万+
标准答案有两种解法，解法一：    用p从头到尾扫描单链表，pre指向*p结点的前驱。若p所指结点的值为x，则删除，并让p指向下个结点，否则让pre和p指针同步后移一个结点。解法二：    采用尾插法建立单链表，用p指针扫描L的所有结点，当其值不为x时将其链接到L之后，否则将其释放。我个人的解法更偏向于使用p指针指向头指针，判断p-next是否为空或者值为x，如果为空则return，如果不为x则让...
王道：在带头结点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为X的结点不唯一，试编写算法以实现上述操作
江冷易水寒
08-05 2712
思路：设置两个节点pre和p，分别用来记录链表L的前驱节点和当前节点，当找到数据X时，将pre指向p的下一个节点,p移动到p的下一个节点（因为p将要被释放），如下图： 代码： void del_x(LinkList* L,int x){ LinkList* p = L->next; LinkList* pre = L; while(p != NULL){ if(p->data == x){ LinkList* q = p;
【数据结构应用题】线性表的链式表示（含统考真题）
Obliviate的博客
01-24 1678
【数据结构应用题】线性表的链式表示（含统考真题）
在带头结点的单链表中删除所有值为x的结点
zhaoxk88的博客
05-13 6691
个人代码如下所示，欢迎大佬指正。 #include<stdio.h> #include<stdlib.h> typedef struct LNode { int data; struct LNode* next; }Node,*Link; //删除值为x的结点 void Delete(Link& link, int x) { Node* p = link,*q; while (p->next!=NULL) {
设l为带头结点的单链表,编写算法实现从尾到头反向输出
江冷易水寒
08-06 8131
思路： 方法一：将链表压栈再输出，时间复杂度为O(n),空间复杂度为O(n) 方法二：用头插法重新建立单链表在输出，时间复杂度为O(n),空间复杂度为O(1) 方法三：用递归，本质上也用到了栈，所以空间复杂度为O(n),时间复杂度为O(n) 代码: #include<iostream> #include"initList/initList.h" #include<stack> using namespace std; // 方法一：用栈 void reversePrin
王道考研数据结构PPT
01-12
王道考研数据结构PPT会深入讲解这些知识点，并辅以实例和习题，帮助学生掌握数据结构的核心原理和应用技巧，为考研做好充分准备。在学习过程中，不仅要注意理论的理解，还要注重编程实践，通过编写代码来加深理解。
王道考研2019数据结构计算机课程辅导书-数据结构
01-31
《王道考研2019数据结构计算机课程辅导书》是专为计算机专业考研者设计的一本详实的复习资料，旨在帮助考生深入理解和掌握数据结构这一核心课程。该书以其全面的内容、清晰的讲解和丰富的例题，成为了考研学子们的...
2022王道考研-数据结构笔记.zip
最新发布
06-17
2022王道考研的数据结构笔记会深入讲解这些内容，并结合考研的实际需求，提供大量例题和实战练习，帮助考生掌握数据结构的核心知识，为考试做好充分准备。ljg_resource1可能是包含这些笔记的具体章节或者习题集，是...
算法-链表 在带头结点的单链表L中，删除所有值为X的结点，并释放其空间。
weixin_41263532的博客
12-08 2764
在带头结点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为X的结点不唯一 //方法一：从头到尾扫描单链表 void delete(LinkList &L,Elemtype x) { //判断 //实现过程 LinkNode *p=L->next; LinkNode *pre=L; LinkNode *q; //前驱结点和当前结点一起出发 while(p) { if(p->data==x)
线性表练习之Example018-删除单链表中所有值为 x 的节点
二木成林
03-28 2489
在带头结点的单链表 L 中，删除所有值为 x 的结点，并释放其空间，假设值为 x 的结点不唯一，试编写算法实现上述操作。
通过带头结点的单链表L实现从尾到头反向输出每个结点的值
zhaoxk88的博客
05-13 2363
个人代码如下，采用头插法建立一个新链表，时间复杂度O(N)，空间复杂度O(N)。 #include<stdio.h> #include<stdlib.h> typedef struct LNode { int data; struct LNode* next; }Node,*Link; //初始化一个带头结点的链表 void Init(Link& link) { link = (Link)malloc(sizeof(Node)); li
在带头结点的单链表L中，删除所有值为x的结点，并释放其空间
m0_54822271的博客
05-26 1146
第一种遍历整个L，遇到data为x就删除， 需要三个指针，pre初始值指向头结点，保持指向为p的前驱结点。 p指向首元结点，用来遍历整个链表。 q用来做删除结点操作指针 Del_x(Linklist &L,Elemtype x){ Lnode *p=L->next,*pre=L,*q; while(p!=NULL){ if(p->data==x){ q=p; // q指向该结点 p=p->next; pre->next=p
数据结构【链表01】----删除单链表中所有值为x的节点
realttr的博客
03-07 7644
问题描述： 在带头结点的单链表L中，删除所有值为x的节点，并释放其内存空间，假设值为x的节点不唯一，试编写算法实现上述代码。 问题分析 使用pre指针指向头节点，用pre->next逐个扫描，如果pre->next节点的值为x，pre指针指向pre->next->next，删除pre->next指针，然后释放pre->next这个节点。如果pre->next的值不为x则pre往后移动一个节点 为了简化算法，可以引用p指针表示pre节点的后继指针，为了释放p指针的内存
数据结构编程题
weixin_43482612的博客
03-21 5456
考研数据结构编程题（附完整代码）1、给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5，3，2，3}中未出现的最小正整数是1；数组{1，2，3}中未出现的最小正整数是4。要求： 1、给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5，3，2，3}中未出现的最小正整数是1；数组{1，2，3}中未出现的最小正整数是4。要求： （1）给出算法的基本设计思想。 要求在时间上尽可能高
数据结构考研学习笔记之线性表应用题
sf9090的博客
05-07 2952
1.设计一个递归算法，删除不带头结点的单链表L中的所有值为x的结点。 解：设f（L,x）的功能是删除以L为首结点指针的单链表中所有值等于x的结点，显然f(L->next,x)的功能是删除以L->next为首结点指针的单链表中所有值等于x的结点。由此，可以推出递归模型如下。 终止条件：f(L,x)≡不做任何事情； 若L为空表 递归主体：f(L,x)...
设L为带头节点的单链表，编写算法实现从头到尾反向输出每个节点的值
byuvyh的博客
03-30 3684
算法思想:用数组进行反转，然后再来加到链表中 //这里使用对的数组反转来进行逆置 #include<stdio.h> #include<stdlib.h> //反向输出每个节点的值，带头节点的单链表 typedef struct Lnode{ int data;//数据域 struct Lnode *next;//指针域 }Lnode,*LinkList; int a[7]={1,2,3,4,5,6}; int n=6; //链表首先就要初始化，如何让数组转化为链表
在带头节点的单链表L中，删除所有值为X的元素，释放其空间，假设值为X的节点不唯一
byuvyh的博客
03-29 918
这个题没什么算法思想，就是要把数据结构最基本的删除方式记住，因为删除的时候，肯定要先初始化链表，初始化就有两种方式，头插法和尾插法，这里使用的尾插法。删除主要就是找前驱节点，如果不知道前驱节点还可以另外一种假替换的方式进行删除x,后面会详细介绍 #include<stdio.h> #include<stdlib.h> typedef struct Lnode{ int data;//数据域 struct Lnode *next;//指针域 }Lnode,*LinkList
数据结构-链表大题2
qq_43063278的博客
07-24 187
在带头结点的单链表L中，删除所有结点为x的结点，并释放其空间，假设值为x的结点不唯一。 void Del_x(LinkList &L,Elemtype x){ Node*p=L->next;//从第一个结点开始往后查找； Node*pre=L;//p的前驱 Node*q;//暂存要删除的点 while(p!=NULL){ if(p->data==x){ q=p;//q指向p p=p->next;//p指向q后面的结点 pre->next=p;//
数据结构学习笔记（王道）
12-29
看到好多人要，考完研了就修改了一下发上来=w= 祝大家都能成功上岸，考上自己心仪的大学=w=

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值