常用数据结构操作合集

数据结构常用代码操作合集实验；包括单链表、栈、队列、普通二叉树、平衡二叉树、无向图等的操作合集，代码注释比较少

实验代码：

#include<stdio.h>
#include<malloc.h>
#include<time.h>
#define inf 999
typedef struct node1{       //链表节点结构 
	int data1;
	struct node1* next;
}node1;
typedef struct node2{       //二叉树结点结构 
	int b;
	struct node2* left;
	struct node2* right;
}node2;
typedef struct grap{                 //图 结构体 
	int s;            //点数
	int s1;            //边数 
	int v[21];        //点  
	int e[21][21];    //边 
}grap;
node1* Crea1(){                    //创建单链表
	int c;
	node1* L=(node1*)malloc(sizeof(node1)),*p=L;
	L->next=NULL;
	scanf("%d",&c);
	while(c){
		node1* C=(node1*)malloc(sizeof(node1));
		C->next=NULL; C->data1=c;
		p->next=C; p=C;
		scanf("%d",&c);
	}
	return L->next;
}
void f(node1* list){      //输出链表
	int p=0;
	while(list){
		if(!p) printf("链表数据：");
		printf("%d  ",list->data1);p++;
		list=list->next;
	}
	if(!p) printf("链表为空\n");
	else printf("\n");
	printf("-----------------------------------------------------\n");
}
node1* f_earse(node1* list){           //删除 
	int f;
	printf("请输入要删除的数据：");
	scanf("%d",&f);
	if(!list) {
		printf("无数据可删！\n");
		return NULL;
	}
	while(list&&list->data1==f)  list=list->next;
	if(!list) return NULL;
	node1* p=list,*q=p->next;
	while(q){
		if(q->data1==f) {
			p->next=q->next;
			free(q);
			q=p->next;
		}
		else {
			p=q;q=p->next;
		}
	}
	return list;
}
node1* f_add(node1* list){        //增添 
	int f;
	printf("请输入要增添的数据：");
	scanf("%d",&f);
	node1* p=(node1*)malloc(sizeof(node1));
	p->data1=f;
	p->next=list;
	return p;
}
node1* f_rev(node1* list){      //反转 
	node1* head=(node1*)malloc(sizeof(node1)); head->next=NULL;
	while(list){
		node1* p=list;
		list=list->next;
		p->next=head->next;
		head->next=p;
	}
	return head->next;
}
void f_distory(node1* node){
	if(node){
		f_distory(node->next);
		free(node);
		node=NULL;
	}
}
void f_print1(node1* list){       //链表操作
	printf("-----------------------链表--------------------------\n");
	printf("--------------------1:删除数据-----------------------\n");
	printf("--------------------2:增添数据-----------------------\n");
	printf("--------------------3:逆转链表-----------------------\n");
	printf("------------------0:退出链表操作---------------------\n");
	f(list);
	printf("\n-----------------------------------------------------\n");
	while(1){
		int t;
		scanf("%d",&t);
		if(!t) {
			printf("已退出单链表实验！！！\n"); 
			f_distory(list); return ;
		}
		else if(t==1) list=f_earse(list);
		else if(t==2) list=f_add(list);
		else if(t==3) list=f_rev(list);
		f(list);
	}
}

node2* Crea2(){                   //创建二叉树
	node2 *p;
	int c;
	scanf("%d",&c);
	if(c==-1) return NULL;
	else {
		p=(node2*)malloc(sizeof(node2));
		p->b=c;
		p->left=Crea2();
		p->right=Crea2();
		return p;
	}
}
void f_xx(node2* tree){       //先序
	if(tree){
		printf("%d ",tree->b);
		f_xx(tree->left);
		f_xx(tree->right);
	}
}
void f_zx(node2* tree){     //中序
	if(tree){
		f_zx(tree->left);
		printf("%d ",tree->b);
		f_zx(tree->right);
	}
}
void f_hx(node2* tree){      //后序
	if(tree){
		f_hx(tree->left);
		f_hx(tree->right);
		printf("%d ",tree->b);
	}
}
void f_cx(node2* tree){      //层序
	node2* a[100];
	int i=0,j=0;
	if(tree) a[j++]=tree;
	while(i<j){
		node2* p=a[i++];
		printf("%d ",p->b);
		if(p->left) a[j++]=p->left;
		if(p->right) a[j++]=p->right;
	}
}
void f_leaf(node2* tree){      //叶子结点
	if(tree){
		if(tree->left==NULL&&tree->right==NULL)
			printf("%d ",tree->b);
		f_leaf(tree->left);
		f_leaf(tree->right);
	}
}
int f_high(node2* tree){      //树高
	if(!tree) return 0;
	else {
		int i=f_high(tree->left);
		int j=f_high(tree->right);
		return (i>j?i:j)+1;
	}
}
void distory_tree(node2* tree){		
	if(tree != NULL)	{		
		distory_tree(tree->left);        
		distory_tree(tree->right);        
		free(tree);		
		tree = NULL;	
	}
}
void f_print2(node2* tree){              //二叉树操作
	printf("-----------------------二叉树--------------------------\n");
	printf("---------------------1:先序遍历------------------------\n");
	printf("---------------------2:中序遍历------------------------\n");
	printf("---------------------3:后序遍历------------------------\n");
	printf("---------------------4:层序遍历------------------------\n");
	printf("-------------------5:输出叶子结点----------------------\n");
	printf("---------------------6:输出树高------------------------\n");
	printf("------------------0:退出二叉树操作---------------------\n");
	printf("-------------------------------------------------------\n");
	while(1){
		int t;
		scanf("%d",&t);
		if(!t) {
			printf("已退出二叉树实验！！！\n");
			distory_tree(tree); return ;
		} 
		else if(t==1) {
			printf("先序序列：");
			f_xx(tree);
			printf("\n");
		}
		else if(t==2){
			printf("中序序列：");
			f_zx(tree);
			printf("\n");
		}
		else if(t==3){
			printf("后序序列：");
			f_hx(tree);
			printf("\n");
		}
		else if(t==4){
			printf("层序序列：");
			f_cx(tree);
			printf("\n");
		}
		else if(t==5){
			printf("叶子结点为：");
			f_leaf(tree);
			printf("\n");
		}
		else if(t==6){
			printf("树高为：%d",f_high(tree));
			printf("\n");
		}
	}
	
}
node1* Crea3(){                         //创建栈 
	node1* stack=(node1*)malloc(sizeof(node1)),*q;
	stack->next=NULL;
	int t;
	scanf("%d",&t);
	while(t){
		node1* p=(node1*)malloc(sizeof(node1));
		p->data1=t;p->next=NULL;
		q=stack;
		while(q->next) q=q->next;
		q->next=p;
		scanf("%d",&t);
	}
	return stack->next;
} 
node1* f_push(node1* stack){        //入栈 or 入队 
	printf("请输入进栈元素：");
	int c;
	scanf("%d",&c);
	node1* p=(node1*)malloc(sizeof(node1)),*q=stack;
	p->data1=c;p->next=NULL;
	if(!q) return p;
	while(q->next){
		q=q->next;
	}
	q->next=p;
	return stack;
}
void ff1(node1* stack,int P){      //输出栈
	if(P!=-1) {
		printf("栈内有 %d 个元素\n",P);
		printf("---------------------------------------------------------\n");
		return ;
	} 
	int p=0;
	while(stack){
		if(!p) printf("栈内数据：");
		printf("%d  ",stack->data1);p++;
		stack=stack->next;
	}
	if(!p) printf("栈为空\n");
	else printf("\n");
	printf("---------------------------------------------------------\n");
}
node1* f_pop1(node1* stack){      //出栈 
	node1* p=stack;
	if(!p) return NULL;
	if(!p->next) {
		printf("出栈元素：%d\n",p->data1);
		return NULL;
	}
	node1* q=p->next;
	while(q->next) {
		p=q;q=p->next;
	}
	printf("出栈元素：%d\n",q->data1);
	p->next=NULL; free(q);
	return stack;
}
int f_num(node1* stack){              //栈 or 队列 元素个数 
	if(!stack) return 0;
	return f_num(stack->next)+1;
}
void f_print3(node1* stack){                          //栈操作 
	printf("--------------------------栈-----------------------------\n");
	printf("------------------------1：进栈--------------------------\n");
	printf("------------------------2：出栈--------------------------\n");
	printf("------------------3：查看栈内元素个数--------------------\n");
	printf("---------------------0：退出栈实验-----------------------\n");
	ff1(stack,-1);
	printf("---------------------------------------------------------\n");
	while(1){
		int t,p=-1;
		scanf("%d",&t);
		if(!t){
			printf("已退出栈实验！！！\n");
			f_distory(stack); return ;
		}
		else if(t==1) stack=f_push(stack);
		else if(t==2) stack=f_pop1(stack);
		else if(t==3) p=f_num(stack);
		ff1(stack,p);
	} 
} 
node1* Crea4(){                                    //创建队列 
	node1* queue=(node1*)malloc(sizeof(node1)),*q;
	queue->next=NULL;
	int t;
	scanf("%d",&t);
	while(t){
		node1* p=(node1*)malloc(sizeof(node1));
		p->data1=t;p->next=NULL;
		q=queue;
		while(q->next) q=q->next;
		q->next=p;
		scanf("%d",&t);
	}
	return queue->next;
} 
node1* f_pop2(node1* queue){
	if(!queue) return NULL;
	printf("出队元素为：%d\n",queue->data1);
	return queue->next;
} 
void ff2(node1* queue,int P){      //输出栈
	if(P!=-1) {
		printf("队列内有 %d 个元素\n",P);
		printf("---------------------------------------------------------\n");
		return ;
	} 
	int p=0;
	while(queue){
		if(!p) printf("队列内数据：");
		printf("%d  ",queue->data1);p++;
		queue=queue->next;
	}
	if(!p) printf("队列为空！！！\n");
	else printf("\n");
	printf("---------------------------------------------------------\n");
}
void f_print4(node1* queue){                          //栈操作 
	printf("--------------------------队列-----------------------------\n");
	printf("-------------------------1：进队---------------------------\n");
	printf("-------------------------2：出队---------------------------\n");
	printf("------------------3：查看队列内元素个数--------------------\n");
	printf("---------------------0：退出队列实验-----------------------\n");
	ff2(queue,-1);
	printf("---------------------------------------------------------\n");
	while(1){
		int t,p=-1;
		scanf("%d",&t);
		if(!t){
			printf("已退出队列实验！！！\n");
			f_distory(queue); return ;
		}
		else if(t==1) queue=f_push(queue);
		else if(t==2) queue=f_pop2(queue);
		else if(t==3) p=f_num(queue);
		ff2(queue,p);
	} 
}
void f_addTree(node2** s_tree,int t){   //平衡树添加元素 
	node2* p=(node2*)malloc(sizeof(node2));
	p->b=t; p->left=NULL; p->right=NULL;
	if(!*s_tree) *s_tree=p;
	else {
		node2* k=*s_tree;
		while(k){
			if(k->b > t){
				if(k->left==NULL) {
					k->left=p;
					return ;
				}
				else k=k->left;
			}
			else {
				if(k->right==NULL){
					k->right=p;
					return ;
				}
				else k=k->right;
			}
		}
	}
}
void Crea5(node2** s_tree){      //创建初始平衡树 
	int n,t;
	scanf("%d",&n);
	printf("请输入排序树的%d个初始数据：\n",n);
	for(int i=0;i<n;i++){
		scanf("%d",&t);
		f_addTree(s_tree,t);
	}
}
void fd(node2** s_tree){                //增添 
	printf("请输入要增添的数据："); 
	int k;
	scanf("%d",&k);
	f_addTree(s_tree,k);
	printf("增添成功！\n");
}
void f_print5(node2* s_tree){
	printf("---------------------排序二叉树------------------------\n");
	printf("---------------------1:先序遍历------------------------\n");
	printf("---------------------2:中序遍历------------------------\n");
	printf("---------------------3:后序遍历------------------------\n");
	printf("---------------------4:层序遍历------------------------\n");
	printf("-------------------5:输出叶子结点----------------------\n");
	printf("---------------------6:输出树高------------------------\n");
	printf("---------------------7:增添数据------------------------\n");
	printf("------------------0:退出二叉树操作---------------------\n");
	printf("-------------------------------------------------------\n");
	while(1){
		int t;
		scanf("%d",&t);
		if(!t) {
			printf("已退出排序二叉树实验\n");
			distory_tree(s_tree); return ;
		}
		else if(t==1) {
			printf("先序序列：");
			f_xx(s_tree);
			printf("\n");
		}
		else if(t==2){
			printf("中序序列：");
			f_zx(s_tree);
			printf("\n");
		}
		else if(t==3){
			printf("后序序列：");
			f_hx(s_tree);
			printf("\n");
		}
		else if(t==4){
			printf("层序序列：");
			f_cx(s_tree);
			printf("\n");
		}
		else if(t==5){
			printf("叶子结点为：");
			f_leaf(s_tree);
			printf("\n");
		}
		else if(t==6){
			printf("树高为：%d",f_high(s_tree));
			printf("\n");
		}
		else if(t==7) fd(&s_tree);
	}
}
void Crea6(grap* G1){
	for(int i=0;i<21;++i){
		G1->v[i]=0;
		for(int j=0;j<21;++j) G1->e[i][j]=inf;
	}
	int n,m;
	scanf("%d",&n);
	while(n>20) {
		printf("顶点数超出范围！！！\n请输入顶点数：");
		scanf("%d",&n);
	}
	G1->s=n;
	printf("请输入边数：");
	scanf("%d",&m);
	while(m>n*(n-1)/2) {
		printf("边数超出范围！！！\n请输入边数：");
		scanf("%d",&m);
	}
	G1->s1=m;
	int i,j;
	for(int k=0;k<m;++k){
		scanf("%d %d",&i,&j);
		if(i>n||j>n||i==j) {
			printf("输入边不合法！！！\n");--k;
		}
		else {
			G1->e[i][j]=1;
			G1->e[j][i]=1;
		}
	}
}
void f_ad1(grap* G1){         //无向图增加边       
	printf("请输入要增添的边：");
	int i,j;
	scanf("%d %d",&i,&j);
	while(i==j||i>G1->s||j>G1->s){
		printf("输入边不合法！请重新输入：");
		scanf("%d %d",&i,&j); 
	}
	if(G1->e[i][j]<inf) printf("这条边已存在！\n");
	else {
		G1->e[i][j]=1;
		G1->e[j][i]=1;
		++G1->s1;
		printf("增添边成功！\n");
	} 
}
void f_ears1(grap* G1){     //无向图删除边 
	if(G1->s1<1) {
		printf("无边可删！ 删边失败！\n");
		return ;
	}
	else {
		int i,j;
		printf("请输入要删除的边：");
		scanf("%d %d",&i,&j);
		while(i==j||i>G1->s||j>G1->s){
			printf("输入边不合法！请重新输入：");
			scanf("%d %d",&i,&j); 
		}
		if(!G1->e[i][j]) printf("这条边不存在！\n");
		else {
			G1->e[i][j]=inf;
			G1->e[j][i]=inf;
			-- G1->s1;
			printf("删除边成功！\n");
		}
	}
}
void f_JuZ(grap* G1){        //输出无向图的领接矩阵 
	printf("该无向无权图的领接矩阵为：\n");
	for(int i=1;i<=G1->s;++i){
		for(int j=1;j<=G1->s;++j)
			printf("%3d  ",G1->e[i][j]);
		printf("\n\n");
	}
}
void dfs(grap* G1,int a[],int p ){
	a[p]=1;
	for(int i=1;i<=G1->s;++i){
		if(G1->e[p][i]<inf&&!a[i]){
			a[i]=1;
			dfs(G1,a,i);
		}
	}
}
void f_dfs(grap* G1){
	printf("请输入要查询的俩点：");
	int p,q,n=G1->s;
	scanf("%d %d",&p,&q);
	while(p>n||q>n||p<1||q<1){
		printf("查询点不合法！ 请重新输入：");
		scanf("%d %d",&p,&q); 
	}
	int a[21];
	for(int i=0;i<=n;++i) a[i]=0;
	a[p]=1;
	dfs(G1,a,p);
	if(a[q]) printf("%d和%d之间有通路(^_^)!\n",p,q);
	else printf("%d和%d之间无通路(T_T)!\n",p,q);
}
int f_min(int* a,int* v,int n){
	int m=inf,p=0;
	for(int i=1;i<=n;++i){
		if(a[i]<m&&!v[i]){
			m=a[i]; p=i;
		}
	}
	return p;
}
void f_dijk(grap* G1){
	int p,q,n=G1->s;
	int a[21],v[21];
	printf("请输入要查询距离的两点：");
	scanf("%d %d",&p,&q);
	for(int i=1;i<=n;++i) {
		a[i]=G1->e[p][i]; v[i]=0;
	}
	v[p]=1;
	for(int i=1;i<=n;++i){
		int k=f_min(a,v,n);
		v[k]=1;
		for(int j=1;j<=n;++j){
			if(G1->e[k][j]+a[k]<a[j]){
				a[j]=G1->e[k][j]+a[k];
			}
		}
	}
	printf(" %d 到 %d 的最短路为 %d \n",p,q,a[q]);
} 
void Dfs(grap* G,int a[],int b[],int x,int p,int q,int S){
	
	b[p]=1;a[x]=p;
	
	if(p==q){
		for(int i=0;i<=x;i++){
			printf(" %d",a[i]);
			if(i<x) printf(" ->");
		}
		printf("     ( 路径长度： %d )\n",S);
		return ;
	}
	
	for(int i=1;i<=G->s;++i){
		if(G->e[p][i]<inf&&!b[i]){
			Dfs(G,a,b,x+1,i,q,S+G->e[p][i]);
			b[i]=0;
		}
	}
}
void f_way(grap* G){
	int i,j;
	int a[21]={0},b[21]={0},n=G->s;
	printf("请输入要查询路径的两点：");
	scanf("%d %d",&i,&j);
	while(i==j||i>n||j>n){
		printf("输入点不合法！ 请重新输入：");
		scanf("%d %d",&i,&j); 
	}
	printf(" %d -> %d 路径：\n",i,j);
	Dfs(G,a,b,0,i,j,0);
}
void f_print6(grap* G1){
	printf("--------------------------无向无权图----------------------------\n");
	printf("---------------------------1：增添边----------------------------\n");
	printf("---------------------------2：删减边----------------------------\n");
	printf("--------------------------3：领接矩阵---------------------------\n");
	printf("--------------------4：求两点是否存在通路-----------------------\n");
	printf("----------------------5：求两点最短路径-------------------------\n");
	printf("----------------------6：求两点所有路径-------------------------\n");
	printf("---------------------0:退出无向无权图操作-----------------------\n");
	printf("----------------------------------------------------------------\n");
	while(1){
		int t;
		scanf("%d",&t);
		if(!t) {
			printf("已退出无向无权图实验！\n");
			return ;
		}
		else if(t==1) f_ad1(G1);
		else if(t==2) f_ears1(G1);
		else if(t==3) f_JuZ(G1);
		else if(t==4) f_dfs(G1);
		else if(t==5) f_dijk(G1);
		else if(t==6) f_way(G1); 
		printf("----------------------------------------------------------------\n");
	}
}
void Crea7(grap* G2){
	for(int i=0;i<21;++i){
		G2->v[i]=0;
		for(int j=0;j<21;++j) G2->e[i][j]=inf;
	}
	int n,m;
	scanf("%d",&n);
	while(n>20) {
		printf("顶点数超出范围！！！\n请输入顶点数：");
		scanf("%d",&n);
	}
	G2->s=n;
	printf("请输入边数：");
	scanf("%d",&m);
	while(m>n*(n-1)/2) {
		printf("边数超出范围！！！\n请输入边数：");
		scanf("%d",&m);
	}
	G2->s1=m;
	int i,j,g;
	printf("请输入%d条带权边(起点 终点 权值)：\n",m);
	for(int k=0;k<m;++k){
		scanf("%d %d %d",&i,&j,&g);
		if(i>n||j>n||i==j) {
			printf("输入边不合法！！！\n");--k;
		}
		else {
			G2->e[i][j]=g;
			G2->e[j][i]=g;
		}
	}
} 
void f_ad2(grap* G2){
	printf("请输入要增添的边及权值：");
	int i,j,g;
	scanf("%d %d %d",&i,&j,&g);
	while(i==j||i>G2->s||j>G2->s){
		printf("输入边不合法！请重新输入：");
		scanf("%d %d %d",&i,&j,&g); 
	}
	if(G2->e[i][j]<inf) printf("这条边已存在！\n");
	else {
		G2->e[i][j]=g;
		G2->e[j][i]=g;
		++G2->s1;
		printf("增添边成功！\n");
	} 
}
void f_ears2(grap* G2){
	if(G2->s1<1) {
		printf("无边可删！ 删边失败！\n");
		return ;
	}
	else {
		int i,j;
		printf("请输入要删除的边：");
		scanf("%d %d",&i,&j);
		while(i==j||i>G2->s||j>G2->s){
			printf("输入边不合法！请重新输入：");
			scanf("%d %d",&i,&j); 
		}
		if(!G2->e[i][j]) printf("这条边不存在！\n");
		else {
			G2->e[i][j]=inf;
			G2->e[j][i]=inf;
			-- G2->s1;
			printf("删除边成功！\n");
		}
	}
}
void f_print7(grap* G2){
	printf("--------------------------无向带权图----------------------------\n");
	printf("---------------------------1：增添边----------------------------\n");
	printf("---------------------------2：删减边----------------------------\n");
	printf("--------------------------3：领接矩阵---------------------------\n");
	printf("--------------------4：求两点是否存在通路-----------------------\n");
	printf("----------------------5：求两点最短路径-------------------------\n");
	printf("----------------------6：求两点所有路径-------------------------\n");
	printf("---------------------0:退出无向带权图操作-----------------------\n");
	printf("----------------------------------------------------------------\n");
	while(1){
		int t;
		scanf("%d",&t);
		if(!t) {
			printf("已退出无向带权图实验！\n");
			return ;
		}
		else if(t==1) f_ad2(G2);
		else if(t==2) f_ears2(G2);
		else if(t==3) f_JuZ(G2);
		else if(t==4) f_dfs(G2);
		else if(t==5) f_dijk(G2);
		else if(t==6) f_way(G2);
		printf("----------------------------------------------------------------\n");
	}
}
void f1(){
	printf("请输入链表数据(以0结束)：\n");
	node1* list=Crea1();  //创建链表
	
	f_print1(list);    //操作链表
}
void f2(){
	printf("请输入二叉树的扩展先序序列：\n");
	node2* tree=Crea2();   //创建二叉树
	
	f_print2(tree);      //操作二叉树
}
void f3(){
	printf("请输入初始栈内元素(以0结束)：\n");
	node1* stack=Crea3();  //创建栈 
	
	f_print3(stack);     //操作栈 
} 
void f4(){
	printf("请输入初始队列内元素(以0结束)：\n");
	node1* queue=Crea4();  //创建队列 
	
	f_print4(queue);     //操作队列 
}
void f5(){
	printf("请输入排序二叉树初始元素个数：");
	node2* s_tree=NULL;
	Crea5(&s_tree);               //创建排序树
	
	f_print5(s_tree);      //操作排序树 
} 
void f6(){
	printf("请输入 无向无权图 的顶点数(顶点数不大于20)：");
	grap G1;
	Crea6(&G1);
	
	f_print6(&G1);
} 
void f7(){
	printf("请输入 无向带权图 的顶点数(顶点数不大于20)：");
	grap G2;
	Crea7(&G2);
	
	f_print7(&G2);
} 
void fff(){
	printf("--------------------------------------------------------------\n"); 
	printf("------------------数--据--结--构--实--验----------------------\n");
	printf("------------------------1：链表-------------------------------\n");
	printf("-----------------------2：二叉树------------------------------\n");
	printf("-------------------------3：栈--------------------------------\n");
	printf("------------------------4：队列-------------------------------\n");
	printf("---------------------5：排序二叉树----------------------------\n");
	printf("---------------------6：无向无权图----------------------------\n");
	printf("---------------------7：无向有权图----------------------------\n");
	printf("--------------------0：结束本次实验---------------------------\n");
	printf("--------------------------------------------------------------\n"); 
	
	while(1){
		int t;
		printf("请输入操作代码：");
		scanf("%d",&t);
		if(!t) {
			printf("本次实验已结束！！！感谢使用！！！\n");
			break; 
		}
		else if(t==1) f1();         //单链表
		else if(t==2) f2();    //二叉树
		else if(t==3) f3();    //栈 
		else if(t==4) f4();    //队列 
		else if(t==5) f5();    //排序二叉树 
		else if(t==6) f6();    //无向无权图 
		else if(t==7) f7();    //无向有权图 
	}
}
int main(){
	
	fff();
	
	return 0;
}