24考研王道408数据结构-第二章“线性表”课后算法题(P40链表专题)

最新推荐文章于 2024-07-18 13:20:33 发布
最新推荐文章于 2024-07-18 13:20:33 发布
阅读量185 收藏
点赞数
分类专栏： 考研 文章标签： 数据结构 考研 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52924358/article/details/132781957
版权

第一题：

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};
void deleteNode(listNode *&head,int x){
	if(head==NULL) return;
	listNode *P;
	if(head->val==x){
		P=head;
		head=head->next;
		free(P);
		deleteNode(head,x);
	}else{
		deleteNode(head->next,x);
	}
}

void disp(listNode *head){
	listNode *s=head;
	while(s){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={4,&node5};
	listNode node3={3,&node4};
	listNode node2={3,&node3};
	listNode node1={1,&node2};
	
	listNode *L=&node1;//指向头结点的指针
	disp(L);
	deleteNode(L,3);
	disp(L);
	return 0; 
}

在这里插入图片描述

第二题

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};
void deleteNode(listNode *&L,int x){
	listNode *p=L->next;
	listNode *pre=L;
	listNode *q;
	while(p!=NULL){
		if(p->val==x){
			q=p;
			p=p->next;
			pre->next=p;
			free(q);
		}else{
			pre=p;
			p=p->next;
		}
	}
}

void disp(listNode *head){
	listNode *s=head->next;
	while(s){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={4,&node5};
	listNode node3={3,&node4};
	listNode node2={3,&node3};
	listNode node1={1,&node2};
	listNode headNode={0,&node1};
	
	listNode *L=&headNode;//指向头结点的指针
	disp(L);
	deleteNode(L,3);
	disp(L);
	return 0; 
}

在这里插入图片描述
尾插法

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};
void deleteNode(listNode *&L,int x){
	listNode *p=L->next;
	listNode *r=L;
	listNode *pre;
	while(p!=NULL){
		if(p->val!=x){//当 p结点值不为x时将其链接到L的尾部 
			r->next=p;
			r=p;
			p=p->next;
		}
		else if(p->val==x){
			pre=p;
			p=p->next;
			free(pre);
		}
	}
	r->next=nullptr; 
}

void disp(listNode *head){
	listNode *s=head->next;
	while(s){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={4,&node5};
	listNode node3={3,&node4};
	listNode node2={3,&node3};
	listNode node1={1,&node2};
	listNode headNode={0,&node1};
	
	listNode *L=&headNode;//指向头结点的指针
	disp(L);
	deleteNode(L,3);
	disp(L);
	return 0; 
}

第三题：

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

void redisp(listNode *head){
	if(head->next!=NULL){
		redisp(head->next);//递归，有栈保存前一个结点的值 
	}
	if(head!=NULL&&head->val!=NULL){
		cout<<head->val;
	}
}
void ignore_head(listNode* head){
	if(head->next!=NULL){
		redisp(head->next);
	}
}

int main(){
	listNode node5={5,nullptr};
	listNode node4={4,&node5};
	listNode node3={3,&node4};
	listNode node2={3,&node3};
	listNode node1={1,&node2};
	listNode headNode={NULL,&node1};
	
	listNode *L=&headNode;
	
	redisp(L);
}

在这里插入图片描述

第四题：

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};
void deleMin(listNode *&head){
	listNode *p=head->next,*pre=head, *minp=p,*minpre=pre;
	while(p!=NULL){
		if(p->val<minp->val){
			minp=p;
			minpre=pre;
		}
		pre=p;
		p=p->next;
	}
	minpre->next=minp->next;
	free(minp);
} 

void disp(listNode *head){
	listNode *s=head->next;
	while(s){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={2,&node5};
	listNode node3={3,&node4};
	listNode node2={1,&node3};
	listNode node1={4,&node2};
	listNode headNode={NULL,&node1};
	
	listNode *L=&headNode;
	disp(L);
	deleMin(L);
	disp(L);
}

在这里插入图片描述

第五题：

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

listNode* reList(listNode* &head){
	listNode *curr=head->next;
	listNode *pre=head;
	listNode *p;
	head->next=NULL;
	while(curr!=NULL){
		p=curr->next;
		curr->next=pre;
		pre=curr;
		curr=p; 
	}
	listNode *newlist=pre;
	return newlist;
}

void disp(listNode *head){
	listNode *s=head;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={2,&node5};
	listNode node3={3,&node4};
	listNode node2={1,&node3};
	listNode node1={4,&node2};
	listNode headNode={NULL,&node1};
	
	listNode *L=&headNode;
	disp(L);
	listNode *newL=reList(L);
	disp(newL);
}

在这里插入图片描述

第六题：

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

void solution(listNode *&head){
	listNode *p=head->next; 
	listNode *pre;
	listNode *r=p->next;
	p->next=NULL;//只保留一个结点
	p=r;
	while(p!=NULL){//类似于直接插入排序 
		r=p->next;
		pre=head;
		while(pre->next!=NULL&&pre->next->val<p->val){
			pre=pre->next;//在有序表中从头开始遍历直到找到值小于结点p的结点 
		}
		p->next=pre->next;//将节点P插入有序表中 
		pre->next=p;
		p=r;
	}
}

void disp(listNode *head){
	listNode *s=head->next;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={2,&node5};
	listNode node3={3,&node4};
	listNode node2={1,&node3};
	listNode node1={4,&node2};
	listNode headNode={NULL,&node1};
	
	listNode *L=&headNode;
	disp(L);
	solution(L); 
	disp(L);
}

在这里插入图片描述

第七题：

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

void solution(listNode *&head,int minNum,int maxNum){
	listNode *p=head;
	listNode *pre;
	while(p->next!=NULL){
		if(p->next->val>=minNum && p->next->val<=maxNum){
			pre=p->next;
			p->next=p->next->next;
			free(pre);
		}else{
			p=p->next;
		}
	}
}

void disp(listNode *head){
	listNode *s=head->next;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={2,&node5};
	listNode node3={3,&node4};
	listNode node2={1,&node3};
	listNode node1={4,&node2};
	listNode headNode={NULL,&node1};
	
	listNode *L=&headNode;
	disp(L);
	solution(L,2,4); 
	disp(L);
}

在这里插入图片描述

第八题：

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};
int Length(listNode *head){
	listNode *p=head->next;
	int num=0; 
	while(p!=NULL){
		p=p->next;
		num++;
	}
	return num;
} 

listNode* solution(listNode *&headA,listNode* &headB){
	
	int lenA=Length(headA);
	int lenB=Length(headB);
	listNode* shortlist;
	listNode* longlist;
	int dist=0;
	if(lenA>lenB){
		shortlist=headB;
		longlist=headA;
		dist=lenA-lenB;
	}else{
		shortlist=headA;
		longlist=headB;
		dist=lenB-lenA;
	}
	for(int i=0;i<dist;i++){
		shortlist=shortlist->next;
	}
	while(shortlist!=NULL&&longlist!=NULL){
		if(shortlist==longlist){
			return longlist;
		}else{
			shortlist=shortlist->next;
			longlist=longlist->next;
		}
	}
}

void disp(listNode *head){
	listNode *s=head;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={2,&node5};
	listNode node3={3,&node4};
	listNode node2={1,&node3};
	listNode node1={4,&node2};
	listNode node0={9,&node1};
	listNode headNode={NULL,&node0};
	
	
	listNode nodeB2={8,&node2};
	listNode nodeB1={9,&nodeB2};
	listNode headNodeB={NULL,&nodeB1};
	
	listNode *LA=&headNode;
	listNode *LB=&headNodeB; 
	
	disp(LA);
	disp(LB);
	
	listNode *c;
	c=solution(LA,LB); 
	disp(c);
}

在这里插入图片描述

第九题：

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};
void solution(listNode* &head){
	listNode *p=head->next;
	listNode *r=p->next;
	listNode* pre;
	p->next=NULL;
	p=r;
	while(p!=NULL){//插入排序 
		pre=head;
		r=p->next;
		while(pre->next!=NULL&&pre->next->val<p->val){
			pre=pre->next;
		}
		p->next=pre->next;
		pre->next=p;
		p=r;
	}
}

void disp(listNode *head){
	listNode *s=head->next;
	listNode *temp;
	while(s!=NULL){
		temp=s;
		cout<<s->val<<"->";
		s=s->next;
		free(temp);
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={2,&node5};
	listNode node3={3,&node4};
	listNode node2={1,&node3};
	listNode node1={4,&node2};
	listNode headNode={NULL,&node1};
	
	listNode *L=&headNode;
	disp(L);
	solution(L);
	disp(L);
}

在这里插入图片描述

第十题：

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

listNode* reList(listNode* &head){
	listNode *newHeadB=new listNode;
	newHeadB->next=NULL;
	listNode *Bhead=newHeadB;
	listNode *p=head->next;
	listNode *pre=head;
	listNode *after;
	int num=1;
	while(p->next!=NULL){
		if(num%2!=0){
			pre=p;
			p=p->next;
			num++;
		}
		else if(num%2==0){
			after=p->next;
			pre->next=p->next;
			p->next=NULL;
			Bhead->next=p;
			Bhead=Bhead->next;
			p=after;
			num++;
		}
	}
	return newHeadB;
}

void disp(listNode *head){
	listNode *s=head->next;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={4,&node5};
	listNode node3={2,&node4};
	listNode node2={3,&node3};
	listNode node1={1,&node2};
	listNode headNode={NULL,&node1};
	
	listNode *L=&headNode;
	disp(L);
	listNode *newL=reList(L);
	disp(L);
	disp(newL);
}

运行结果：
在这里插入图片描述

第十一题

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

listNode* reList(listNode* &head){
	listNode *newHeadB=new listNode;
	newHeadB->next=NULL;
	listNode *Bhead=newHeadB;
	listNode *p=head->next;
	listNode *ra=head;
	listNode *temp;
	while(p!=NULL){
		ra->next=p;
		ra=p;
		p=p->next;
		if(p!=NULL){
			temp=p->next;
			p->next=Bhead->next;
			Bhead->next=p;
			p=temp;
		}
	}
	ra->next=NULL;
	return Bhead;
}

void disp(listNode *head){
	listNode *s=head->next;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={5,nullptr};
	listNode node4={4,&node5};
	listNode node3={3,&node4};
	listNode node2={2,&node3};
	listNode node1={1,&node2};
	listNode headNode={NULL,&node1};
	
	listNode *L=&headNode;
	disp(L);
	listNode *newL=reList(L);
	disp(L);
	disp(newL);
}

在这里插入图片描述

第十二题

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

void solution(listNode *&head){
	listNode *p=head->next; 
	listNode *after;

	while(p->next!=NULL){
		after=p->next;
		if(p->val==after->val){
			p->next=after->next;
			free(after);
		}else{
			p=p->next;
		}
	}
}

void disp(listNode *head){
	listNode *s=head->next;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node5={30,nullptr};
	listNode node4={21,&node5};
	listNode node3={10,&node4};
	listNode node2={10,&node3};
	listNode node1={7,&node2};
	listNode headNode={NULL,&node1};
	
	listNode *L=&headNode;
	disp(L);
	solution(L); 
	disp(L);
}

在这里插入图片描述

第十三题

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

listNode* solution(listNode *&la,listNode* &lb){
	listNode *pa=la->next;
	listNode *pb=lb->next;
	listNode *r;
	la->next=NULL;//la作为结果链表的头指针，先将结果链表初始化为空 
	while(pa&&pb){
		if(pa->val<=pb->val){
			r=pa->next;
			pa->next=la->next;
			la->next=pa;
			pa=r;
		}
		else{
			r=pb->next;
			pb->next=la->next;
			la->next=pb;
			pb=r; 
		}
	}
	if(pa)//如果是A剩余pb指向他，将剩余的链表指针统一用pb表示，减少重复代码量 
		pb=pa;
	while(pb){//采用头插法，将剩余链表插入，来保持递减次序 
		r=pb->next;
		pb->next=la->next;
		la->next=pb;
		pb=r;
		}
	free(lb); 
	return la;
 
}

void disp(listNode *head){
	listNode *s=head->next;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node6={9,nullptr};
	listNode node5={8,&node6};
	listNode node4={7,&node5};
	listNode node3={5,&node4};
	listNode node2={4,&node3};
	listNode node1={3,&node2};
	listNode node0={1,&node1};
	listNode headNode={NULL,&node0};
	
	
	listNode nodeB4={7,nullptr};
	listNode nodeB3={5,&nodeB4};
	listNode nodeB2={2,&nodeB3};
	listNode nodeB1={1,&nodeB2};
	listNode headNodeB={NULL,&nodeB1};
	
	listNode *LA=&headNode;
	listNode *LB=&headNodeB; 
	
	disp(LA);
	disp(LB);
	
	listNode *c;
	c=solution(LA,LB); 
	disp(c);
}

在这里插入图片描述

第十四题

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

listNode* solution(listNode *&la,listNode* &lb){
	listNode *pa=la->next;
	listNode *pb=lb->next;
	listNode *lc=new listNode;
	lc->next=NULL;
	lc->val=0;
	listNode *pc=lc;
	while(pa!=NULL&&pb!=NULL){
		if(pa->val==pb->val){
			pc->next=pa;
			pc=pa;
			pa=pa->next;
			pb=pb->next;
		}
		else if(pa->val<pb->val){
			pa=pa->next;
		}else if(pb->val<pa->val){
			pb=pb->next;
		}
	}
	pc->next=NULL;//置结果链表尾指针为NULL 
	return lc;	 
}

void disp(listNode *head){
	listNode *s=head->next;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node6={9,nullptr};
	listNode node5={8,&node6};
	listNode node4={7,&node5};
	listNode node3={5,&node4};
	listNode node2={4,&node3};
	listNode node1={3,&node2};
	listNode node0={1,&node1};
	listNode headNode={NULL,&node0};
	
	
	listNode nodeB4={7,nullptr};
	listNode nodeB3={5,&nodeB4};
	listNode nodeB2={2,&nodeB3};
	listNode nodeB1={1,&nodeB2};
	listNode headNodeB={NULL,&nodeB1};
	
	listNode *LA=&headNode;
	listNode *LB=&headNodeB; 
	
	disp(LA);
	disp(LB);
	
	listNode *c;
	c=solution(LA,LB); 
	disp(c);
}

在这里插入图片描述

第十五题

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

listNode* solution(listNode *&la,listNode* &lb){
	listNode *pa=la->next;
	listNode *pb=lb->next;
	listNode *pc=la;
	listNode *u;
	while(pa!=NULL&&pb!=NULL){
		if(pa->val==pb->val){
			pc->next=pa;
			pc=pa;
			pa=pa->next;
			u=pb;
			pb=pb->next;
			free(u);
		}
		else if(pa->val<pb->val){
			u=pa;
			pa=pa->next;
			free(u);
		}else if(pb->val<pa->val){
			u=pb;
			pb=pb->next;
			free(u);
		}
	}
	while(pa!=NULL){
		u=pa;
		pa=pa->next;
		free(u);
	}
	while(pb!=NULL){
		u=pb;
		pb=pb->next;
		free(u);//释放A中剩余的结点 
	}
	pc->next=NULL;//置结果链表尾指针为NULL 
	free(lb);
	return la;	 
}

void disp(listNode *head){
	listNode *s=head->next;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node6={9,nullptr};
	listNode node5={8,&node6};
	listNode node4={7,&node5};
	listNode node3={5,&node4};
	listNode node2={4,&node3};
	listNode node1={3,&node2};
	listNode node0={1,&node1};
	listNode headNode={NULL,&node0};
	
	
	listNode nodeB4={7,nullptr};
	listNode nodeB3={5,&nodeB4};
	listNode nodeB2={2,&nodeB3};
	listNode nodeB1={1,&nodeB2};
	listNode headNodeB={NULL,&nodeB1};
	
	listNode *LA=&headNode;
	listNode *LB=&headNodeB; 
	
	disp(LA);
	disp(LB);
	
	listNode *c;
	c=solution(LA,LB); 
	disp(c);
}

在这里插入图片描述

第十六题：

在这里插入图片描述

#include<iostream>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

bool solution(listNode *&la,listNode* &lb){
	listNode *pa=la;
	listNode *pb=lb;
	listNode *pre=pa;
	
	while(pa!=NULL&&pb!=NULL){
		if(pb->val==pa->val){
			pa=pa->next;
			pb=pb->next;
		}
		else{
			pa=pa->next;
			pb=lb;//判断B是否是A的连续子序列，所以需要pb需要返回到B链表的第一个结点 
		}
	}
	if(pb==NULL){
		return true;
	}
	return false;
	
}

void disp(listNode *head){
	listNode *s=head;
	while(s!=NULL){
		cout<<s->val<<"->";
		s=s->next;
	}
	cout<<"NULL"<<endl;
}
int main(){
	listNode node6={9,nullptr};
	listNode node5={8,&node6};
	listNode node4={7,&node5};
	listNode node3={5,&node4};
	listNode node2={4,&node3};
	listNode node1={3,&node2};
	listNode node0={1,&node1};
	
	
	listNode nodeB4={7,nullptr};
	listNode nodeB3={5,&nodeB4};
	listNode nodeB2={4,&nodeB3};
	listNode nodeB1={3,&nodeB2};
	
	listNode *LA=&node0;
	listNode *LB=&nodeB1; 
	
	disp(LA);
	disp(LB);
	bool c;
	c=solution(LA,LB); 
	if(c){
		cout<<"true";
	}else{
		cout<<"false";
	}
}

在这里插入图片描述

第二十一题

在这里插入图片描述
方法一：哈希表判断有无环

#include<iostream>
#include<unordered_set>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

bool reList(listNode* &head){
	listNode *p=head;
	unordered_set<listNode*> hashtable;
	while(p!=NULL){
		if(hashtable.count(p)){//插入之前先查哈希表看该节点之前是否出现过。 
			return true;
		}
		hashtable.insert(p);//如果表中未查到，则说明之前没有出现过，则插入哈希表中。	
		p=p->next;	
	}
	return false;
}

int main(){
	listNode node5={6,nullptr};
	listNode node4={4,&node5};
	listNode node3={2,&node4};
	listNode node2={3,&node3};
	listNode node1={1,&node2};
	node5={6,&node3};
	
	listNode *L=&node1;
	bool flag=reList(L);
	if(flag){
		cout<<"true";
	}
	else{
		cout<<"false"; 
	}
}

在这里插入图片描述
方法二：快慢指针判断有无环

#include<iostream>
#include<unordered_set>
using namespace std;
struct listNode{
	int val;
	struct listNode*next;
};

listNode* reList(listNode* &head){
	listNode *fast=head,*slow=head;
	while(fast!=NULL&&fast->next!=NULL){
		fast=fast->next->next;
		slow=slow->next;
		if(fast==slow){
			break;
		}
	}
	if(slow==NULL||fast->next==NULL){
		return NULL;//没有环，返回NULL 
	}
	listNode *p1=head, *p2=slow;
	while(p1!=p2){
		p1=p1->next;
		p2=p2->next;
	}
	return p1;//返回入口点 
}

int main(){
	listNode node5={6,nullptr};
	listNode node4={4,&node5};
	listNode node3={2,&node4};
	listNode node2={3,&node3};
	listNode node1={1,&node2};
	node5={6,&node3};
	
	listNode *L=&node1;
	listNode *point=reList(L);
	cout<<point->val; 
}

在这里插入图片描述

执剑人LG
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 1853
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
(王道408考研数据结构)第二章线性表-第三节3：循环单链表和循环双链表
快乐江湖的博客
11-10 1261
文章目录一：循环链表定义二：循环单链表三：循环双链表 一：循环链表定义 循环链表：规定好头尾结点的指向形成环状 循环单链表：其尾节点的next指针由原本的空改为指向头结点 循环双链表：其尾节点的next指针由原本的空改为指向头结点，同时头结点的prior指针指向尾节点 二：循环单链表 原来的单链表如果p是尾节点，一定有p->next=NULL; 循环单链表如果p是尾节点，一定有p->next=Head; 注意循环单链表的初始化 bool InitList(LNode*& He
王道数据结构-线性表2.2.4课后习题
m0_65036580的博客
09-02 566
王道数据结构2.2.4课后习题
考研数据结构：第二章 线性表
m0_57180439的博客
03-29 724
我们在学习数据结构时，需要关注数据结构的三个方面：逻辑结构、物理结构和数据的运算。该小节中，我们首先要介绍线性表的定义和基本操作，其实就是要探讨这种数据结构它的逻辑结构是怎样的，我们要对这种数据结构实现哪些基本运算，也就是所谓的基本操作。在之后的小节中，我们还会探讨如何使用不同的存储结构来实现线性表。ps:当采用不同的存储结构时，对于数据的运算的具体实现也会不同，这点我们后面会用具体的代码帮助大家进行理解。什么是线性表？
《数据结构》-第二章 线性表（习题）
大家一起进步叭
06-30 9653
写在前面的话： 适应范围：《数据结构》复习总结系列适用于考研、期末考试、考前复习，小白新手 本系列参考书目： 《数据结构：c语言版》（严蔚敏） 关于写这个系列的原因：本人今年考研上岸，加上在校期间学习《数据结构》这门课时候，对数据结构有了好感，对这门课考试的考点把握还不错，所以不想荒废自己的知识，就计划用这种方式总结起来。如果有理解不到位的地方，欢迎在评论指出。我会尽量把知识点讲清楚后，按照考点进行总结。这个系列计划按照知识点总结后+考点总结，同时配有少部分习题（之...
考研数据结构——链表相关大题（含解析和代码超详细）
给你糖ya的博客
04-01 903
1.链表题常用方法有：头插法、尾插法、逆置法、归并法、双指针法等。2.对于顺序表，因为可以直接存取，所以经常结合排序和查找的几种算法设计思路进行设计，如归并排序、二分查找等。3.对于算法设计题，若能写出数据结构类型的定义、正确的算法思想，则至少给一半的分数；若能用伪代码写出自然更好；比较复杂的地方可以直接用文字表达。4.本章节（包括顺序表的内容，即下面这个链接）的所有习题要二刷三刷，一定要掌握！！！考研数据结构——线性表相关大题（含解析和代码）_数据结构考研真题线性表-CSDN博客。
王道408数据结构——第二章 线性表
weixin_45668903的博客
09-25 1455
文章目录一、线性表的定义和基本操作线性表顺序表1.插入操作2.删除操作3.按值查找（顺序查找）二、单链表1. 头插法2. 尾插法3. 按序号查找4. 按值查找5. 插入结点6. 删除结点7. 求表长三、 双链表1. 插入2. 删除四、循环链表五、静态链表六、顺序表和链表的比较 一、线性表的定义和基本操作 线性表 线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，n=0是为一个空表。除第一个元素外，每一个元素有且仅有一个直接前驱，除最后一个元素外，每一个元素有且仅有一个直接后驱。 顺序表 线性表
王道数据结构课代表 - 考研数据结构 第二章 线性表 究极精华总结笔记（C版本）
clzZ2的博客
01-21 6081
数据结构与算法 笔记导航🚥🚥🚥 🥬 第一章 绪论 🥕 第二章 线性表 🥪 第三章 栈和队列 🍊 第四章 串-KMP(看毛片算法) 🍒 第五章 树和二叉树 🍀 第六章 图 🍚 第七章 查找(B树、散列表) 🧄 第八章 排序 (内部排序：八大排序动图演示与实现 + 外部排序) 🍔 数据结构与算法 复试精简笔记 🎨 408 全套初复试笔记汇总 传送门 🏃‍🏃‍🏃‍ 如果本篇文章对大家起到帮助的话，跪求各位帅哥美女们，求赞👍 、求收藏、求关注！
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
《数据结构》第二章算法设计题--线性表 定义线性表节点的结构.pdf
04-18
数据结构算法设计题--线性表节点结构设计 本文主要讲解了数据结构中线性表的节点结构设计，涉及到链表的合并、插入、删除等操作。下面是对该知识点的详细讲解： 1. 链表的节点结构设计 链表是一种常见的数据结构...
《数据结构》第二章线性表习题.doc
12-01
本资源摘要信息对应的知识点主要涉及到数据结构的第二章线性表习题，包括线性表的定义、链式存储、顺序存储、单链表、双向循环链表、栈和队列等概念。 一、线性表的定义 线性表是指一个有限序列，可以为空。它的每...
数据结构-第二章 线性表.ppt
07-04
"数据结构-第二章 线性表" 数据结构是相互之间存在一种或多种特定关系的数据元素的集合。数据结构包括数据元素、数据项、数据对象、逻辑结构和存储结构（物理结构）。算法的五个重要特性是：算法效率的度量、事前...
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
从键盘输入数据，建立两个有序线性表(每个线性表的输入数据按由小到大次序输入来建立线性表，不必考虑排序算法)；输出建好的这两个有序线性表；将这两个有序线性表归并为一个有序线性表；输出归并后的有序线性表。 ...
王道考研数据结构第二讲-线性表
07-21
和我的王道考研数据结构专题中的代码对应，可以参看https://blog.csdn.net/zhangbaodan1/article/details/81142428
数据结构（初阶3.单链表）
2401_83968713的博客
07-14 658
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 431
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构第35节 性能优化 算法的选择
最新发布
hummhumm的专栏
07-18 388
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1851
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 211
1%29%5D。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值