王道数据结构链表

已于 2023-11-21 21:31:05 修改
阅读量58 收藏
点赞数
分类专栏： 王道数据结构代码题 文章标签： 链表 数据结构
于 2022-11-26 21:01:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heart912921/article/details/128056791
版权

删除带头结点的单链表中所有值为x的结点

//删除带头结点的单链表中所有值为x的结点,
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{//定义结构体 
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[6]={1,2,3,4,5,6};
int n=6;
void buildlist(linklist &L){//尾插法建立链表 
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;
} 
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
//删除函数
void deletex(linklist &L,int x){
	lnode *p=L->next,*q,*r=L;
	while(p){
		if(p->data==x){
			q=p;
			p=p->next;
			free(q);
		}else{
			r->next=p;
			r=p;
			p=p->next;
		}
	}
} 
int main(){
	linklist L;
	buildlist(L);
	disp(L);
	deletex(L,3);
	disp(L);
	return 0;
}

带头结点的链表中删除最小值x

//带头结点的链表中删除最小值x
#include<bits/stdc++.h>
using namespace std;
//定义结构体 
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[4]={2,3,1,4};
int n=4;
//尾插法建立链表
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));//创建头结点
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	} 
	r->next=NULL;
	
}
//输出函数 
void disp(linklist L){
	lnode *s = L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
//开始删除最小值
void deletemin(linklist &L){
	lnode *pre=L,*p=pre->next;
	lnode *minpre=pre,*minp=p;
	while(p){
		if(p->data<minp->data){
			minp=p;
			minpre=pre;
		}else{
			pre=p;
			p=p->next;
		}
	}
	minpre->next=minp->next;
	free(minp);
} 
int main(){
	linklist L;
	buildlist(L);
	disp(L);
	deletemin(L);
	disp(L);
	return 0;
}

依次删除最小值并输出

//依次删除最小值并输出 删一个释放一个空间 不使用数组作为辅助空间
#include<bits/stdc++.h>
using namespace std;
//定义结构体
typedef struct lnode {
	int data;
	struct lnode *next;
} lnode,*linklist;
int a[4]= {2,3,1,4};
int n=4;
//尾插法建立链表
void buildlist(linklist &L) {
	L=(linklist)malloc(sizeof(lnode));//创建头结点
	lnode *s,*r=L;
	for(int i=0; i<n; i++) {
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;

}
//输出函数
void disp(linklist L) {
	lnode *s = L->next;
	while(s) {
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
//开始删除最小值
void deletemin(linklist &L) {

	while(L) {
		lnode *pre=L,*p=pre->next;
		lnode *minpre=pre,*minp=p;
		while(p) {
			if(p->data<minp->data) {
				minp=p;
				minpre=pre;
			} else {
				pre=p;
				p=p->next;
			}

		}
		cout<<minp->data<<" ";
		minpre->next=minp->next;
		free(minp);
	}
	free(L);

}
int main() {
	linklist L;
	buildlist(L);
	disp(L);
	deletemin(L);
	return 0;
}

有序链表中删重复元素

#include<bits/stdc++.h>
using namespace std;
//定义结构体
typedef struct lnode {
	int data;
	struct lnode *next;
} lnode,*linklist;
int a[10]= {1,2,2,3,3,4,5,6,6,7};
int n=10;
//尾插法建立链表
void buildlist(linklist &L) {
	L=(linklist)malloc(sizeof(lnode));//创建头结点
	lnode *s,*r=L;
	for(int i=0; i<n; i++) {
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;

}
//输出函数
void disp(linklist L) {
	lnode *s = L->next;
	while(s) {
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
void deletelist(linklist &L){

	lnode *p=L->next,*q;
	while(p->next){
		q=p->next;
		if(p->data==q->data){
			p->next=q->next;
			free(q);
		}else{
			p=p->next;
		}
		
	}
}
int main() {
     linklist L;
     buildlist(L);
     disp(L);
     deletelist(L);
     disp(L);
	return 0;
}

删绝对值

//删绝对值相同的结点 已知|data|<=n,保留第一个出现的值 
//要求算法高效 遍历一遍
//那么就得用空间换时间了 使用辅助整数数组q
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[5]={21,-15,-15,7,15};
int m=5;
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<m;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
void deletesame(linklist &L,int n){
	lnode *p=L,*f;
	int *q;
	q=(int *)malloc(sizeof(int)*(n+1));
	for(int i=0;i<n+1;i++) *(q+i)=0;
	int s=0;
	while(p->next!=NULL){
		s=abs(p->next->data);
		if(*(q+s)==0){
			*(q+s)=1;
			p=p->next;
		}else{
			f=p->next;
			p->next=f->next;
			free(f);
			
		}
	}
	free(q);
}
int main(){
	linklist L;
	buildlist(L);
	disp(L);
	deletesame(L,21);
	disp(L);
	return 0;
}

删一段

//带头结点的单链表中删除给定值s-t之间的值
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[5]={2,3,5,1,6};
int n=5;
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	}
	r->next =NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
void deletelist(linklist &L,int s,int t){
	lnode *pre=L,*p=pre->next;
	while(p){
		if(p->data>=s&&p->data<=t){
			pre->next=p->next;
			free(p);
			p=pre->next;
		}else{
			pre=p;
			p=p->next;
		}
	}
}
int main(){
	linklist L;
	buildlist(L);
	disp(L);
	deletelist(L,1,3);
	disp(L);
	return 0;
}

逆置

//逆序输出
//用的头插法
#include <bits/stdc++.h>
using namespace std;
int a[5]={2,3,5,4,3};
int n=5;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
void reverse(linklist &L){
	lnode *p=L->next,*r;//r指向p的后继防止断链
		L->next=NULL;
	while(p){
		r=p->next;
		p->next=L->next;
		L->next=p;
		p=r;		
	} 
}
int main(){
    linklist L;
	buildlist(L);
	disp(L);
	reverse(L);
	disp(L);	
	return 0;
}

排序（直接插入排序）

//排序 直接插入排序
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[5]={2,1,3,5,4};
int n=5;
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next ;
	}
	r->next=NULL;
} 
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
//排序函数
void sortlist(linklist &L){
	lnode *p=L->next,*r=p->next,*f;
	p->next=NULL;
	p=r;
	while(p){
		r=p->next;
		f=L;
		while(f->next!=NULL&&f->next->data<p->data) f=f->next;
		p->next=f->next;
		f->next=p;
		p=r;  		
	}
} 
int main(){
    linklist L;
	buildlist(L);
	disp(L);
	sortlist(L);
	disp(L);	
	return 0;
}

找倒数第k个位置结点

//找倒数第K个位置的结点
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[5]={1,2,3,4,5};
int n=5;
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
		
	}
	cout<<endl;
}
int findk(linklist L,int k){
	lnode *p=L->next,*q=L->next;//p工作指针
	int count= 0; 
	while(p){
		if(count<k) count++;
		else q=q->next;
		p=p->next;
	}
	if(count<k) return 0;
	else {
		cout<<"倒数第"<<k<<"个位置元素是"<<q->data<<" ";
		return 1;
	}
}
int main(){
	linklist L;
	buildlist(L);
	disp(L);
	findk(L,4);
	return 0;
}

找公共结点的起始位置

//找公共结点的起始位置//也就是找公共结点 
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	char data;
	struct lnode *next;
}lnode,*linklist;
char a[7]={'l','o','a','d','i','n','g'};
char b[5]={'b','e','i','n','g'};
int n1=7;
int n2=5;
void buildlist(linklist &L,char aa[],int n){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=aa[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
int length(linklist L){
	int k=0;
	lnode *s=L->next;
	while(s){
		k++;
		s=s->next;
	}
	return k;
}
linklist findfirst(linklist L1,linklist L2){
	lnode *p1=L1->next,*p2=L2->next;
	int len1=length(L1),len2=length(L2);
	int dist=abs(len1-len2);
	//先把多余的结点遍历完
	if(len1>len2){
		while(dist--){
			p1=p1->next;
		}
	} else if(len2>len1){
		while(dist--){
			p2=p2->next;
		}
	}
	//开始寻找 
    while(p1){
    	if(p1->data!=p2->data){
    		p1=p1->next;
    		p2=p2->next;
		}else return p1;
	}
	return p1;
}
int main(){
	linklist L1,L2;
	buildlist(L1,a,7);
	buildlist(L2,b,5);
	disp(L1);
	disp(L2);
	linklist ans=findfirst(L1,L2);
	cout<<ans->data<<endl;
	return 0;
}

在这里插入图片描述

找公共元素–存入原来的L1中

//找公共元素存于A中
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[5]={1,2,4,8,10};
int b[6]={2,3,4,6,10,11};
int n1=5;
int n2=6;
void buildlist(linklist &L,int aa[],int n){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=aa[i];
	    r->next=s;
	    r=r->next;
	}
	r->next=NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
void findlist(linklist &L1,linklist &L2){
	lnode *p1=L1->next ,*p2=L2->next,*r,*f;
	L1->next=NULL;
	f=L1;
	while(p1&&p2){
		if(p1->data<p2->data) p1=p1->next;
		else if(p2->data<p1->data) p2=p2->next;
		else{
			r=p1->next;//防止断链
			p1->next =f->next;
			f->next=p1;
			f=p1;
			p1=r; 
		    	
		}
		f->next=NULL;
	}
}
int main(){
	linklist L1,L2;
	buildlist(L1,a,5);
	buildlist(L2,b,6);
	disp(L1);
	disp(L2);
	findlist(L1,L2);
	disp(L1);
	return 0;
}

在这里插入图片描述

找公共元素–存入新链表L3中

//找公共元素建立新链表
#include<bits/stdc++.h> 
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[4]={1,2,3,4};
int b[5]={2,3,5,6,7};
int n1=4;
int n2=5;
void buildlist(linklist &L,int aa[],int n){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=aa[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;
}
void disp(linklist L){
	lnode *s = L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next; 
	}
	cout<<endl;
}
linklist L3;
void buildnewlist(linklist L1,linklist L2){
	L3=(linklist)malloc(sizeof(lnode));
	lnode *p1=L1->next,*p2=L2->next,*r;
	r=L3;
	while(p1&&p2){
		if(p1->data<p2->data) p1=p1->next;
		else if(p1->data>p2->data) p2=p2->next;
		else{
			r->next=p1;
			r=p1;
			p1=p1->next;
			p2=p2->next;
		}
		
	}
	r->next=NULL;
}
int main(){
	linklist L1,L2;
	buildlist(L1,a,4);
	buildlist(L2,b,5);
	disp(L1);
	disp(L2);
	buildnewlist(L1,L2);
	disp(L3);
	return 0;
}

在这里插入图片描述

-----------------------------------

判断B是否是A的子序列

//判断B是否是A的子序列
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[11]={1,2,3,4,5,6,7,3,4,5,7};
int b[4]={3,4,5,7};
int n1=11,n2=4;
void buildlist(linklist &L,int aa[],int n){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=aa[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
bool isok(linklist L1,linklist L2){
	lnode *p1=L1->next ,*p2=L2->next,*r=L1->next;
	while(p1&&p2){
		if(p1->data!=p2->data){
			r=r->next;
			p1=r;
			p2=L2->next;//P2从头开始 
		}else{//相等的话就一一比较了 
			p1=p1->next;
			p2=p2->next;
		}
	} 
	if(p2!=NULL) return false;
	else return true; 
}
int main(){
	linklist L1,L2;
	buildlist(L1,a,11);
	buildlist(L2,b,4);
	disp(L1);
	disp(L2);
	if(isok(L1,L2)==true){
		cout<<"B是A的子序列"<<endl; 
	}else cout<<"匹配失败"<<endl; 
	return 0;
}

合并链表递减

//合并链表递减，要求合并后的表再放在原来的表中
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[4]={1,3,4,6};
int b[2]={2,5};
int n1=4;
int n2=2;
void buildlist(linklist &L,int aa[],int n){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=aa[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
//开始合并 ，用的头插法 
void mergelist(linklist L1,linklist L2){
	lnode *p1=L1->next,*p2=L2->next,*r;
	L1->next =NULL;
	while(p1&&p2){
		if(p1->data<p2->data){
			r=p1->next;//防止断链
			p1->next=L1->next;
			L1->next=p1;
			p1=r; 
		}else{
			r=p2->next;
			p2->next=L1->next;
			L1->next=p2;
			p2=r;
		}
	}
	if(p1) p2=p1;//如果有链表非空 弄到p2上去 再把p2中的结点依次插入到新结点 
	while(p2){//因为最终的表在L1上 
		r=p2->next;
		p2->next=L1->next ;
		L1->next =p2;
		p2=r; 
	}
	free(L2);
} 
int main(){
	linklist L1,L2;
	buildlist(L1,a,4);
	buildlist(L2,b,2);
	disp(L1);
	disp(L2);
	mergelist(L1,L2);
	disp(L1); 
	return 0;
}

链表重组

//链表重组{1,2,3,4,5,6,7,8}-->{1,8,2,7,3,6,4,5}
//{1,2,3,4,5,6,7,8}-->{1,2,3,4,8,7,6,5}-->{1,8,2,7,3,6,4,5}
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[8]={1,2,3,4,5,6,7,8};
int n=8;
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
void newlist(linklist &L){
	lnode *p=L,*q=L,*r,*l; //p q 指向L 所以下面 
	while(p->next&&q->next){//p走1步，q走2步
	    p=p->next;
		q=q->next->next; 
	}
	q=p->next;
	p->next=NULL;
	//开始原地逆置后半段 用头插法
	while(q){
		r=q->next;
		q->next=p->next;
		p->next=q;
		q=r;
	} 
	//重组 
	l=L->next;
	q=p->next;
	p->next=NULL;
	while(q){
		r=q->next;
		q->next=l->next;
		l->next=q;
		l=q->next;
		q=r;
		
	} 
}
int main(){
	linklist L;
	buildlist(L);
	disp(L);
	newlist(L);
	disp(L);
	return 0;
}

切割

//分割链表
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[6]={1,2,3,4,5,6};
int n=6;
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	}
	r->next=NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	} 
	cout<<endl;
}
linklist L2;//全局变量 
void cutlist(linklist &L1){
	L2=(linklist)malloc(sizeof(lnode));
	L2->next=NULL;
	lnode *r1=L1,*r2=L2,*p=L1->next;
	L1->next=NULL;
	int i=0;
	while(p){
		i++;
		if(i%2==0){
			r2->next=p;r2=p;
		} 
		else{
			r1->next=p;r1=p;
		} 
		p=p->next;
	}
	r1->next=NULL;
	r2->next=NULL;
}
int main(){
	linklist L1;
	buildlist(L1);
	disp(L1);
	cutlist(L1);
	disp(L1);
	disp(L2);
	
	return 0;
}

连接两个循环单链表

//连接两个循环单链表
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[3]={1,2,3};
int b[3]={4,5,6};
int n1=3,n2=3;
void buildlist(linklist &L,int aa[],int n){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=aa[i];
		r->next=s;
		r=r->next;
	}
	r->next=L;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s!=L){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
//算法思想：找到两个尾指针 将第一个链表的尾指针与第二个链表的头指针连接
//将第二个链表的尾指针与第一个链表的头指针连接 保持循环形式
void newlist(linklist &L1,linklist &L2){
	lnode *p1=L1->next,*p2=L2->next;
	while(p1->next!=L1){
		p1=p1->next;
	}
	while(p2->next!=L2){
		p2=p2->next;
	}
	p1->next=L2->next;
	p2->next=L1;
}
int main(){
	linklist L1,L2;
	buildlist(L1,a,3);
	buildlist(L2,b,3);
	disp(L1);
	disp(L2);
	newlist(L1,L2);
	disp(L1);
	return 0;
}

循环单链表中 依次删除最小值并输出

//循环单链表中 依次删除最小值并输出 
#include <bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next;
}lnode,*linklist;
int a[6]={5,4,6,8,1,3};
int n=6;
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		r->next=s;
		r=r->next;
	}
	r->next=L;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s!=L){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}

//算法思想：每循环一次 找到最小的结点 删除并输出
//直到链表为空 最后释放头结点
void deleteminlist(linklist &L){
	lnode *p=L->next,*pre=L,*minp=p,*minpre=pre;
	while(L->next!=L)//否则L空 
	{
       	p=L->next,pre=L,minp=p,minpre=pre;
		while(p!=L){
			if(p->data<minp->data){
				minp=p;
				minpre=pre;
			}else{
				pre=p;
				p=p->next;
			}
		} 
		//找到了后
		cout<<minp->data<<" ";
		minpre->next=minp->next;
		free(minp); 
	} 
	free(L);
} 
int main(){
	linklist L;
	buildlist(L);
	disp(L);
	deleteminlist(L);
	return 0;
}

判断循环双链表是否对称

//判断循环双链表是否对称 
//算法思想：p指针从左向右遍历，q指针从右向左遍历
//当p q 指针指向相同结点或者相邻时结束
//若他们所指向的结点相同就继续比较 否则返回false
//如果比较全部相等 返回true
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data;
	struct lnode *next,*prior;
}lnode,*linklist;
int a[5]={1,2,3,2,1};
int n=5;
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	L->next =L;
	L->prior=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		s->next=r->next;
		r->next->prior=s;
		s->prior=r;
		r->next=s;
		r=s;
		L->prior=s; 
		
	}
}
void disp(linklist L){
	lnode *s=L->next;
	while(s!=L){
		cout<<s->data<<" ";
		s=s->next;
		
	}
	cout<<endl;
}
//判断是否对称
bool isok(linklist L){
	lnode *p=L->next,*q=L->prior;
	while(p!=q&&q->next !=p){
		if(p->data==q->data){
			p=p->next;
			q=q->prior;
		}else return false;
	}
	return true;
} 
int main(){
	linklist L;
	buildlist(L);
	disp(L);
	if(isok(L)==true) cout<<"对称"<<endl;
	else cout<<"不对称"<<endl; 
	return 0;
}

非循环双链表 频率

//非循环双链表查找元素再排序，返回找到结点的地址
#include<bits/stdc++.h>
using namespace std;
typedef struct lnode{
	int data,f;
	struct lnode *next,*prior;
}lnode,*linklist;
int a[4]={1,2,3,4};
int n=4;
void buildlist(linklist &L){
	L=(linklist)malloc(sizeof(lnode));
	lnode *s,*r=L;
	L->prior=NULL;
	L->next=L;
	for(int i=0;i<n;i++){
		s=(lnode *)malloc(sizeof(lnode));
		s->data=a[i];
		s->f=0;
		s->next=r->next;
		r->next->prior=s;
		s->prior=r;
		r->next=s;
		r=s;
		
	}
	r->next =NULL;
}
void disp(linklist L){
	lnode *s=L->next;
	while(s){
		cout<<s->data<<" ";
		s=s->next;
	}
	cout<<endl;
}
//算法思想：此题主要考察双链表的查找、删除、插入
//先查找x，找到后频率设为1，再将x从原链表中断裂，通过比较频率将其插入合适的位置
linklist locate(linklist &L,int x){
	lnode *p=L->next,*q;
	while(p!=NULL&&p->data!=x) p=p->next;
	if(!p) cout<<"没有这个结点"<<endl;
	else {//找到了这个结点 
		p->f++;
	}
	//开始断链
	if(p->next!=NULL){
		p->next->prior=p->prior;
		p->prior->next=p->next;
	} 
	q=p->prior;
	while(q!=L&&q->f<p->f){
		q=q->prior;
		
	}
	p->next=q->next;
	q->next->prior=p;
	p->prior=q;
	q->next=p;
	
	return p;
}
int main(){
	linklist L;
	buildlist(L);
	disp(L);
	linklist ans=locate(L,3);
	cout<<ans->data<<endl;
	return 0;
}

在这里插入图片描述

欣欣向亮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
王道考研数据结构单链表代码（带头节点）
05-28
自己写的王道考研数据结构单链表（带头结点）例题和习题代码，所有函数运行都没问题。
最值得收藏的 数据结构 全部知识点思维导图整理(王道考研), 附带经典题型整理.emmx
03-27
用mindmaster打开文件, 本文的思维导图根据王道的数据结构书本整理而来并标记出重点内容，包括了知识点和部分课后习题
王道计算机考研数据结构线性表代码
10-03
王道计算机考研数据结构线性表代码 顺序表 单链表 双链表 循环链表 静态链表 带头节点和不带头节点链表的初始化 链表的节点增加、删除节点、销毁链表、双链表正向打印逆向打印！ 静态链表的初始化以及插入操作
数据结构折半插入排序源码，c++
07-06
需要使用2013版本以上的Visual Studio才能正常打开 采用C++面向对象 详细的注释说明，简洁易懂 有点儿bug
数据结构c语言代码（devc++版）
07-27
里面包含了数据结构c语言示例代码，且用了c++引用，与王道书基本一致，仅供参考。 包括 顺序表 链表 栈 队列 树 查找 排序 串
【C语言视角】数据结构之~二叉树
循环渐进学习编程，成长
05-01 1186
设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。第一层是根结点，只有一个，所以2(1-1）=20=1。终端结点数其实就是叶子结点数，而一棵二叉树，除了叶子结点外，剩下的就是度为1或2的结点数了，我们设n1为度是1的结点数。终端结点数其实就是叶子结点数，而一棵二叉树，除了叶子结点外，剩下的就是度为1或2的结点数了，我们设n1为度是1的结点数。
redis核心数据结构——跳表项目设计与实现（跳表结构插入数据、删除数据、展示数据）
qq_63149342的博客
05-01 519
另外就是每次创建新节点时需要随机分配层数，加上一开始用两个变量分别记录最大层数和当前层数，分配后该层数不能超过最大层数，且如果大于当前层数，需要将当前层数进行更新。向跳表中插入一对数据，如果跳表中已存在该键值对，则不做任何操作，返回 1，如果不存在该键值对，则将该键值对插入到跳表中，返回 0。此成员函数需要从跳表中删除键为 key 的节点。在跳表中查询键值为 key 的键值对，如果跳表中已存在该键值对，则返回 true，否则返回 false。参数说明： K key：要删除的元素的键，其中 K 是键的类型。
【数据结构】链表专题2
m0_74091744的博客
05-01 1300
前言本篇博客继续探讨有关链表的专题，这片博客的题，提前打个预防针，有点意思哦，哈哈哈，话不多说，进入正文若有问题 评论区见📝。
[数据结构]————排序总结——插入排序（直接排序和希尔排序）—选择排序（选择排序和堆排序）-交换排序（冒泡排序和快速排序）—归并排序（归并排序）
小李很执着的博客
05-04 955
直接插入排序是一种简单观的排序算法，它基本思想是将待排序的元逐个插入到已经排好序的序列中，直到所有元素都插入完成为止下面是对直接插入排序的析总结：最好情况下待排序序列已经是有序的此时只需要比较n-1次，时间复杂度为O（n）。最坏情况下，待排序序列是逆序的，此时需要比较和移动元素的次数最多，时间复杂度为O(n^2)。平均情况下，假设待排序序列中的每个元素都等概率地出现在任何位置，那么平时间复杂度为O(n^2)。
数据结构-线性表-应用题-2.2-5
muse3159546973的博客
05-07 96
从顺序表中删除其值在给定值s与t之间（包括s和t，且s
数据结构中的算法
zy1215058242的博客
05-01 1022
什么是算法呢？算法是描述解决问题的方法。算法(Algorithm)这个单词最早出现在波斯数学家阿勒·花刺子密在公园825年(相当于我们中国的唐朝时期)所写的《印度数字算数》中。如今普遍认可的对算法的定义是：算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。现实世界中的问题千奇百怪，算法当然也就千变万化，没有通用的算法可以解决所有问题。甚至解决一个小问题，很优秀的算法却不一定适合它。指令能被人或机器等计算装置执行。
数据结构-线性表-应用题-2.2-4
muse3159546973的博客
05-07 293
这个区间的起始位置是 i，这是因为 i 是在 [s, t] 范围内找到的第一个元素的位置，即从这里开始的元素需要被删除或覆盖。通过设置新的顺序表长度为 i 的值（即移动完成后的最后一个元素的索引加一），我们有效地切除了数组尾部的多余部分，这部分现在包含了重复的、不再需要的数据。从有序顺序表中删除其值在给定值s与t之间（要求s
acwing算法提高之数据结构--平衡树Treap
YMWM_的博客
05-01 365
acwing算法提高之数据结构--平衡树Treap
【数据结构和算法】--RangeSet时间范围管理示例
寻梦友的博客
05-05 324
ImmutableRangeSet是一个不可修改的RangeSet，而TreeRangeSet则是利用树的形式来实现，提供了高效的查询和插入操作。这种自动合并的特性使得RangeSet能够保持范围的不重叠性，从而简化了范围集合的管理。当向RangeSet中添加一个新的范围时，它会遍历范围树，找到与新范围相交或相邻的现有范围，并进行合并。例如，当查询一个元素是否包含在RangeSet中时，可以从树的根节点开始，沿着适当的分支向下遍历，直到找到一个包含该元素的范围或确定该元素不在RangeSet中。
数据结构-线性表-应用题-2.2-12
muse3159546973的博客
05-07 172
1）算法的基本设计思想：依次扫描数组的每一个元素，将第一个遇到的整数num保存到c中，count记为1，若遇到的下一个整数还是等于num,count++,否则count--,当计数减到0时，将遇到的下一个整数保存到c中，计数重新记为1，反复该过程，直到扫描全部数组元素为止。获得最终的候选主元素，但此时还没完成，出现次数还要过半才行，判断c中元素是否是真正的主元素，再次扫描该数组统计c中元素出现的次数，再进一步进行判断。3）时间复杂度O(n),空间复杂度O（1）
【数据结构（十）】Map和Set
weixin_69049913的博客
05-02 1394
本篇文章将讲解数据结构的最后一个集合类：Map和Set。希望同学们能掌握 Map/Set 实际实现类HashMap/TreeMap/HashSet/TreeSet 的使用以及背后的数据结构哈希表的原理和简单实现。
数据结构可视化（适合考研党）
qq_51281451的博客
04-30 658
还在疑惑平衡二叉树、红黑树、B树、B+树怎么插入构建的吗，不要慌张，这个网站会一步一步来演示.
数据结构-线性表-应用题-2.2-14
最新发布
muse3159546973的博客
05-07 129
n=(|S1|+|S2|+|S3|),时间复杂度为O(n),空间复杂度为O(1)。3）时间复杂度和三元组的元素个数有关，因为要依次遍历里面的元素。
数据结构——排序算法分析与总结
island1314的博客
05-02 1472
排序算法
王道数据结构视频pdf
07-17
王道数据结构视频PDF是一套以视频和PDF文档形式提供的学习资料，主要涵盖数据结构的相关知识和算法。这套资料包含了丰富的内容和案例，通过视频和PDF的结合使用，可以帮助学生更好地理解和掌握数据结构的基本概念和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值