2.3线性表的链式表示（1）

最新推荐文章于 2022-12-22 18:49:03 发布
最新推荐文章于 2022-12-22 18:49:03 发布
阅读量490 收藏 2
点赞数
分类专栏： 考研数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43699776/article/details/112984771
版权

1、设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点
在这里插入图片描述

void Del_X_3(Linklist &L,ElemType x){
	LNode *p;	//p指向待删除结点 
	if(L==NULL)	//递归出口	
		return;
	if(L->data==x){	// 若L所指结点的值为x 
		p=L;		//删除*L，并让L指向下一结点 
		L=L->next;
		free(p);
		Del_X_3(L,x);	//递归调用 
	}
	else				//若L所指结点的值不为x 
		Del_X_3(L->next,x);//递归调用 
}

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

void Del_X_1(Linklist &L,ElemType x){
	LNode *p=L->next,*pre=L,*q;//置p和pre的初始值 
	while(p!=NULL){
		if(p->data==x){
			q=p;			//q指向该节点 
			p=p->next;
			pre->next=p;	//删除*q结点 
			free(q);		//释放*q结点的空间 
		}
		else{				//否则pre和p同步后移 
			pre=p;
			p=p->next; 
		}
	}
}

在这里插入图片描述

void Del_X_1(Linklist &L,ElemType x){
	LNode *p=L->next,*r=L,*q;//r指向尾结点，其初值为头结点 
	while(p!=NULL){
		if(p->data!=x){	//*p结点值不为x时将其链接到L尾部 
			r->next=p;
			r=p;
			p=p->next;	//继续扫描 
		}
		else{			//*p结点值为x时将其释放 
			q=p;		 
			p=p->next;	//继续扫描 
			free(q);	//释放空间 
		}
	}
	r->next=NULL;		//插入结束后置尾节点指针为NULL 
}

3、设L是带头结点的单链表，编写算法实现从尾到头反向输出每个结点的值。
在这里插入图片描述

void Reverse(Linklist L){
	if(L->next!=NULL){
		Reverse(L->next);
	}
	if(L!=NULL) print(L->data);
}

4、试编写在带头结点的单链表L中删除一个最小值结点的高效算法。
在这里插入图片描述

LinkList Delete_Min(LinkList &L){
	LNode *pre=L,*p=pre->next;//p为工作指针，pre指向其前驱 
	LNode *minpre=pre,*minp=p;//保存最小值结点及其前驱 
	while(p!=NULL){
		if(p->data<minp->data){
			minp=p;			//找到比之前找到的最小值结点更小的结点 
			minpre=pre;
		}
		pre=p;		//继续扫描下一个结点 
		p=p->next;
	}
	minpre->next=minp->next;	//删除最小值结点 
	free(minp);
	return L;
}

5、试编写算法将带头结点的单链表就地逆置
在这里插入图片描述

LinkList Reverse1(LinkList L){
	LNode *p,*r;	//p为工作指针，r为p的后继，以防断裂 
	p=L->next;	//从第一个元素结点开始 
	L->next=NULL;//先将头结点L的next域置为NULL 
	while(p!=NULL){//依次将元素结点摘下 
		r=p->next;//暂存p的后继 
		p->next=L->next;//将p结点插入到头结点之后 
		L->next=p;
		p=r;
	} 
}

在这里插入图片描述

LinkList Reverse1(LinkList L){
	LNode *pre,*p=L->next,*r=p->next;
	p->next=NULL;//处理第一个节点 
	while(r!=NULL){//r为空，则说明p为最后一个结点 
		pre=p;	//依次继续遍历 
		p=r;	 
		p->next=pre;	//指针反转 
	}
	L->next=p;	//处理最后一个结点 
	return L; 
}

6、有一个带头结点的单链表L，设计一个算法使其元素递增有序。
在这里插入图片描述

void Sort(LinkList &L){
//本算法实现将单链表L的结点重排，使其递增有序 
	LNode *p=L->next,*pre;
	LNode *r=p->next;//r保持*p后继节点指针，以保证不断链 
	p->next==NULL;//构造只含一个数据结点的有序表 
	p=r;
	while(p!=NULL){
		r=p->next;	//保存*p的后继结点指针 
		pre=L;
		while(pre->next!=NULL&&pre->next->data<p->data)
			pre=pre->next;//在有序表中查找插入*p的前驱结点*pre 
		p->next=pre->next;//将*p插入到*pre之后 
		pre->next=p;
		p=r;//扫描原单链表中剩下的结点 
	} 
}

7、设在一个带头结点的单链表中所有元素结点的数据值无序，试编写一个函数，删除表中元素所有介于给定的两个值（作为函数参数给出）之间的元素（若存在 ）

void RangeDelete(LinkList &L,int min,int max)
{
	LNode *pr=L,*p=L->link;//p是检测指针，pr是其前驱 
	while(p!=NULL){
		if(p->data>min&&p->data<max){//寻找到被删结点，删除 
			pr->link=p->link;
			free(p);
			p=pr->link;
		}
		else{			//否则继续寻找被删结点 
			pr=p;
			p=p->link;
		}		
	}	
}

8、给定两个单链表，编写算法找出两个链表的公共结点
在这里插入图片描述

LinkList Search_Commom(LinkList L1,LinkList L2){
//本算法实现在线性时间内找到两个单链表的第一个公共结点 
	int len1=Length(L1),len2=Length(L2);//计算两个链表的表长 
	LinkList longList,shortList;//分别指向表长较长和较短的链表 
	if(len1>len2){				//L1表长较长 
		longList=L1->next;shortList=L2->next;
		dist=len1-len2;			//表长之差 
	}
	else{				//L2表长较长 
		longList=L2->next;shortList=L1->next;
		dist=len2-len1;	//表长之差 
	}
	while(dist--){	//表长的链表先遍历到第dist个结点，然后同步 
		longList=longList->next;
	}
	while(longList!=NULL){	//同步寻找共同结点 
		if(longList==shortList)//找到第一个公共结点 
			return longList;
		else{			//继续同步寻找 
			longList=longList->next;
			shortList=shortList->next;
		}
	}
	return NULL;
	
}

9、给定一个带表头结点的单链表，设head为头指针，结点结构为（data，next），data为整型元素，next为指针，试写出算法：按递增次序输出单链表各节点的数据元素，并释放结点所占存储空间。（不允许使用数组作为辅助空间）

在这里插入图片描述

void Min_Delte(LinkList &head)
{//head是带头结点的单链表的头指针，本算法按递增顺序输出单链表中的数据元素 
	while(head->next!=NULL){//循环到仅剩头结点 
		pre=head;	//pre为元素最小值结点的前驱结点的指针 
		p=pre->next;//p为工作指针 
		while(p->next!=NULL){
			if(p->next->data<pre->next->data)
			pre=p;		//记住当前最小值结点的前驱 
			p=p->next;
		}
		print(pre->next->data);//输出元素最小值结点的数据 
		u=pre->next;	//删除元素值最小的结点，释放结点空间 
		pre->next=u->next;
		free(u);
	}
	free(head);//释放头结点 
}

10、将一个带头节点的单链表A分解为两个带头节点的单链表A和B，使得A表中含有原表中序号为奇数的元素，而B表中含有原表中序号为偶数的元素，且保持其相对顺序不变

void Min_Delte(LinkList &head)
{//head是带头结点的单链表的头指针，本算法按递增顺序输出单链表中的数据元素 
	while(head->next!=NULL){//循环到仅剩头结点 
		pre=head;	//pre为元素最小值结点的前驱结点的指针 
		p=pre->next;//p为工作指针 
		while(p->next!=NULL){
			if(p->next->data<pre->next->data)
			pre=p;		//记住当前最小值结点的前驱 
			p=p->next;
		}
		print(pre->next->data);//输出元素最小值结点的数据 
		u=pre->next;	//删除元素值最小的结点，释放结点空间 
		pre->next=u->next;
		free(u);
	}
	free(head);//释放头结点 
}

11、设C={a1,b1,a2,b2,…,an,bn}为线性表，采用带头节点的hc单链表存放，设计一个就地算法，将其拆分为2个线性表，使得A={a1,a2,…,an},B={bn,…,b2,b1}

LinkList DisCreat(LinkList &A)
{
	LinkList B=(LinkList)malloc(sizeof(LNode));//创建B表表头 
	B->next=NULL;		//B表的初始化 
	LNode *p=A->next,*q;//p为工作指针 
	LNode *ra=A;	//ra始终指向A的尾节点 
	while(p!=NULL){
		ra->next=p;ra=p;	//将*p链到A的表尾 
		p=p->next;
		p->next=B->next;	//头插后，*p将断链，因此q记忆*p的后继 
		B->next=p;		//将*p插入到B的前端 
		p=q;
	} 
	ra->next=NULL;		//A尾结点的next域置空 
	return B;
}

12、在一个递增有序的线性表中，有数值相同的元素存在。若存储方式为单链表，设计算法去掉数值相同的元素，使表中不再有重复的元素

void Del_Same(Linklist &L){
//L是递增有序的单链表，本算法删除表中数值相同的元素	
	LNode *p=L->next,*q;//p为扫描工作指针 
	if(p==NULL)
		return;
	while(p->next!=NULL){
		q=p->next;	//q指向*p的后继结点 
		if(p->data==q->data){	//找到重复值的结点 
			p->next=q->next;	//释放*q结点 
			free(q);		//释放相同元素值的结点 
		}
		else
			p=p->next;
	}
}

13、假设有2个按元素值递增排列的线性表，均以单链表形式存储。编写算法将这2个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来两个单链表的结点存放归并后的单链表

算法思想：两个链表已经按元素值递增次序排序，将其合并时，均从第一个结点起进行比较，将小的结点链入链表中，同时后移工作指针。该问题要求结果链表按元素值递减次序排列，故新链表的建立应采用头插法。比较结束后，可能会有一个链表非空，此时用头插法将剩下的结点依次插入新链表中即可。

void MergeList(LinkList &La,LinkList &Lb){
//合并两个递增有序链表（带头结点），并使合并后的链表递减排列 
	LNode *r,*pa=La->next,*pb=Lb->next;//分别是表La,Lb的工作指针 
	La->next=NULL;//La作为结果链表的头指针，先将结果链表初始化为空 
	while(pa&&pb){//当两链表均不为空时，循环 
		if(pa->data<=pa->data){
			r=pa->next;	//r暂存pa的后继指针 
			pa->next=La->next;
			La->next=pa;//将pa为当前待比较结点 
			pa=r;
		}
		else{
			r=pb->next;	//r暂存pb的后继结点指针 
			pb->next=La->next;
			La->next=pb;//将pb结点链于结果表中，同时逆置 
			pb=r;	//恢复pb当前待比较结点 
		}
		if(pa)
			pb=pa;//通常情况下会剩一个链表非空，处理剩下的部分 
		while(pb){//处理剩下的一个非空链表 
			r=pb->next;//依次插入到La中（头插法） 
			pb->next=La->next;
			La->next=pb;
			pb=r;
		}
		free(Lb);
	} 
}

14、设A和B是两个单链表（带头结点），其中元素递增有序。设计一个算法从A和B中的公共元素产生单链表C，要求不破坏A，B的结点

算法思想：表A、B都有序，可从第一个元素起依次比较A、B两表的元素，若元素值不等，则值小的指针往后移，若元素值相同，则创建一个值等于两结点的元素值的新结点，使用尾插法插入到新的链表中，并将两个原表指针后移一位，直到其中一个链表遍历到表尾

void MergeList(LinkList &La,LinkList &Lb){
//合并两个递增有序链表（带头结点），并使合并后的链表递减排列 
	LNode *r,*pa=La->next,*pb=Lb->next;//分别是表La,Lb的工作指针 
	La->next=NULL;//La作为结果链表的头指针，先将结果链表初始化为空 
	while(pa&&pb){//当两链表均不为空时，循环 
		if(pa->data<=pa->data){
			r=pa->next;	//r暂存pa的后继指针 
			pa->next=La->next;
			La->next=pa;//将pa为当前待比较结点 
			pa=r;
		}
		else{
			r=pb->next;	//r暂存pb的后继结点指针 
			pb->next=La->next;
			La->next=pb;//将pb结点链于结果表中，同时逆置 
			pb=r;	//恢复pb当前待比较结点 
		}
		if(pa)
			pb=pa;//通常情况下会剩一个链表非空，处理剩下的部分 
		while(pb){//处理剩下的一个非空链表 
			r=pb->next;//依次插入到La中（头插法） 
			pb->next=La->next;
			La->next=pb;
			pb=r;
		}
		free(Lb);
	} 
}
我辈当自强
关注
专栏目录
2.3 线性表的链式表示-知识分析以及选择题分析
qq_35452997的博客
03-08 339
1.链式存储的线性表，不需要使用地址连续的存储单元；其插入删除不需要移动元素，只需要修改指针； 2.线性表的链式存储又称单链表，其为非随机存取的存储结构，在查找某个特定的元素时，要从表头开始查找 3.双链表比起单链表的优势在于能够更加方便的访问前驱结点了 4.对于循环单链表而言，只设一个尾指针，这样对表头与表尾的操作均为O(1)； 1. 答案选：B 关于2：链式存储用指针表示逻辑结...
2.3 线性表的链式表示
SeNiLS的博客
11-09 100
一.单链表的定义 1.线性表的链式存储又称为单链表,它是指通过一组任意的存储单 元来存储线性表中的数据元素。为了建立数据元素之间的线性关系 对每个链表结点,除存放元素自身的信息外,还需要存放一个指向其 后继的指针。 2.单链表中结点类型的描述如下: typedef struct LNode //定义单链表结点类型 { ElemType data; //数据域 struct LNode *next; //指针域 }LNode,*LinkList; 3.利用单链表可以解决顺序表需要大量连续存储单元的缺
王道数据结构2022-线性表的链式表示-综合题(p41)02-在带头结点的单链表L中,删除带头结点的单链表L中所有值为x的结点 并释放其空间,假设值为x的结点不唯一,试编写算法以实现上述操作
好奇独角兽
08-27 318
在带头结点的单链表L中,删除带头结点的单链表L中所有值为x的结点并释放其空间,假设值为x的结点不唯一,试编写算法以实现上述操作 #include<stdio.h> #include<stdlib.h> typedef struct LNode { //定义单链表结点类型 int data;//数据域 struct LNode *next;//指针域 } LNode, *LinkList; //带头结点尾插法建立单链表 LinkList List_TailInsert(Lin
数据结构练习题——线性表（二）
煮酒blog
06-06 7400
一、判断正误 （ F ）1. 链表的每个结点中都恰好包含一个指针。 （ F ）2. 链表的物理存储结构具有同链表一样的顺序。 （ F ）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动将后续各个单元向前移动。 （ F ）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。 （ F ）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。 二、单项选择题 （ A ）1. 链式存储的存储结构所占存储空间： 分两...
有一个带头结点的单链表L，设计一个算法使其元素递增
byuvyh的博客
04-02 7138
算法思想： //其实可以和数组的对比起来，数组就是通过冒泡、选择、插入、快速，归并排序常见的排序来排，但是这里是链表 // 不能直接像数组那样在原有的链表上面进行排序，链表通常是有两种初始化方式，头插法，尾插法，头插法就是和原有的链表逆置，尾插和原有相同 LinkList Sort(LinkList &L){ //1.直接插入排序 Lnode *p=L->next,*pre; Lnode *r=p->next;//r作为p.
2021-01-21
zdn135860_的博客
01-21 808
数据结构可用三元式表示（D，S，P）。其中：D是数据对象，S是D上的关系集，P是对D的基本操作集。× （DSP是指抽象数据类型，数据结构用DS表示） 队列是数据对象特定的线性表。（字符串）× 一棵无向连通图的生成树是其极大的连通子图。（极小）× 完全二叉树必定是平衡二叉树。（平衡二叉树有序）× 若广义表LS满足GetHead(LS)==GetTail(LS)，则LS为( b )。 A. ( ) B. (( )) C. (( ),( )) D. (( ..
2.3 线性表的链式表示和实现（双向循环链表）
蓝天的博客
06-30 486
盛年不重来，一日难再晨。及时宜自勉，岁月不待人。 ——陶渊明 一、前言 学习了单链表，那么双向循环链表的意思就是一个结点有两个指针域，分别指向直接前驱结点和直接后继结点，并且尾结点指向头结点，这样的好处是什么呢？ ...
2.3 线性表的链式存储结构(链表)
jsxyg63的博客
09-20 1338
基本概念和特点 链表的定义 -线性表的链式存储结构称之为链表(linked list)。链表包括两部分构成：数据域和指针域。数据域保存数据元素，指针域描述数据元素的逻辑关系。 - 链表通常使用带头结点的表示。指向头结点的指针称之为头指针(head pointer)，指向最后一个结点（也就是尾结点）的指针称之为尾指针(tail pointer)。 - 链表不具备随机存取特性。 - 存储密度
2.3 线性表的链式表现和实现
最新发布
m0_59440926的博客
12-22 133
指的是构成链表的每个结点中设立两个指针域，一个指向其直接前趋的指针域prior，一个指向其直接后继的指针域next。这样形成的链表中有两个方向不同的链，故称为双向链表。
设计一个带头结点的单链表中所有的元素结点的数据值是无序的，编写一个函数，删除表中所有介于给定两个值（作为函数参数给出）之间的元素
byuvyh的博客
04-03 1255
算法思想：因为是无序的所以需要挨个进行比较然后使用链表中删除的方法 下面给出代码 void delete(LinkList &L,int min,int max){ Lnode *pre=L,*p=L->next; while(p!=NULL){ if(p->data>min&&p->data<max){ pre->next=p->next; free(p)
用串的链式存储实现插入，删除，查找，匹配等操作
06-17
用链式存储的方式实现字符串的插入操作。 用链式存储的方式实现字符串的创建操作。 用链式存储的方式实现字符串的删除操作。 用链式存储的方式实现字符串的匹配操作。 用链式存储的方式实现字符串的输出操作。
9,给定一个带表头结点的单链表,设head为头指针,结点结构为(data, next), data 为整型元素, next为指针,试写出算法:按递增次序输出单链表中各结点的数据元素, 并释放结点所占的
Anthony_4926
06-27 6308
9,给定一个带表头结点的单链表,设head为头指针,结点结构为(data, next), data为整型元素, next为指针,试写出算法:按递增次序输出单链表中各结点的数据元素,并释放结点所占的存储空间(要求:不允许使用数组作为辅助空间)。 思路：插入法从小到大排序，然后输出 排序见“6,有一个带头结点的单链表1,设计一个算法使其元素递增有序。” ...
2.2删除带头结点的L中所有值为x的结点
追随梦想，实现梦想
08-28 1279
方法1： /* 用于数据结构第二章线性表的综合应用题*/ //设计一个递归算法，删除带头结点的L中所有值为x的结点 #include #include #includestring.h> using namespace std; //2.1 typedef struct LNode { int data; struct LNode *next; }
一些单链表的题目（2）
youngurt的博客
05-25 1019
9、题目：给定一个带表头结点的单链表，设head为头指针，结点结构为(data,next)，data为整型元素，next为指针，试写出算法：按递增次序输出单链表中各结点的数据元素，并释放结点所占的存储空间（要求：不允许使用数组作为辅助空间）思路：对链表进行遍历，在每次遍历中找出整个链表的最小值元素，输出并释放结点所占空间；再次查找最小值，输出并释放空间，如此下去，直至链表为空，最后释放头结点所占的存储空间。时间复杂度为O(n²) void Min_Delete(LinkList &head){
已知一个带有表头的单链表，结点结构为data-link，假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点（k为正整数）。
zxydqq的博客
09-16 1万+
今天和大家分享一道2009年代码为408的一道真题： 已知一个带有表头的单链表，结点结构为data-link，假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点（k为正整数）。若查找成功，算法输出该结点的data域的值，并返回1，否则，只返回0.。 评分标准：如果能一次遍历找出k，得满分15，超过一次遍历最高得10分 下面我们直接来...
线性表带头结点的单链表的链式表示和实现
07-19 578
线性表的单链表存储结构struct LNode { ElemType data; LNode *next; }; typedef LNode *LinkList;带有头结点的单链表的12个基本操作void InitList(LinkList &L){ L = (LinkList)malloc(sizeof(LNode)); if (!L)exit(OVERFLOW);
p=p->next 表达了什么意思
热门推荐
老鱼的故事
04-25 4万+
问题：-&gt;是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“-&gt;”.举个例子：struct Data{int a,b,c;}; /*定义结构体*/struct Data * p;/*定义结构体指针*/struct Data A =...
单链表-删除单链表L中第一个值为x的结点的前驱结点（三指针法）
muyu_muyu的博客
12-16 5386
单链表的存储结构： typedef struct LinkList{ int data; LinkList * next; } 分析： 首先，我们要删除第一个值为x结点的前驱结点，则该链表要包含两个及以上结点才行。 在前面通常都是删除该节点，而这次是删除该节点的前驱结点。 所以不能向以往一样定义两个指针。而应该定义三个指针。 prepre , pre ,p; 思路： 1.定义三个指针prepre = L,pre = prepre->next; p = p
新手指南：2.1-2.3线性表详解：单链表构造与操作
在第2章的讲解中，着重介绍了线性表的基本概念，包括逻辑结构的两种主要形式：顺序表示（如数组）和链式表示（如单链表）。线性表的链式表示是通过节点（node）结构来实现的，每个节点包含数据域（data）和指针域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值