数据结构基础代码

本文章为博主考研为巩固知识所写，有不足帮忙指出！！！加油！必上岸！！！

顺序表

#include
#include
#define MaxSize 100
#define test printf("测试\n");
//定义顺序表结构 
typedef struct node{
	int data[MaxSize];
	int length;
}SqList;
//初始化顺序表
SqList InitList(SqList L){
	for(int i=0;i<100;i++){
		L.data[i]=0;
	}
	L.length=0;
} 
//建立顺序表
SqList BuildList(SqList L){
	int x,i=1;
	scanf("%d",&x);
	while(x!=0){
		L.data[i++]=x;
		L.length++;
		scanf("%d",&x);
	}
	return L;
} 
//打印顺序表
void PrintList(SqList L){
	for(int i=1;i<=L.length;i++){
		printf("%d ",L.data[i]);
	}
} 
//插入操作
SqList InsertList(SqList L,int i,int e){
	if(i<1||i>L.length){
		printf("插入失败");
		exit(1);
	}
	//i以及后面的元素后移 
	for(int j=L.length;j>=i;j--){
		L.data[j+1]=L.data[j];
	}
	L.data[i]=e;
	L.length++;
	return L;
} 
//删除操作
SqList DeleteList(SqList L,int i){
	if(i<1||i>L.length){
		printf("删除失败");
		exit(1);
	}
	//删除
	for(int j=i+1;j<=L.length;j++){
		L.data[j-1]=L.data[j];
	} 
	L.length--;
	return L;
} 
//按值查找
int SelectList(SqList L,int e){
	for(int i=0;i<L.length;i++){
		if(L.data[i]==e){
			printf("%d的值在%d位/n",e,i);
			return 0;
		}
	}
} 
int main(){
	SqList L;
	//初始化 
	InitList(L);
	//建立顺序表 
	L = BuildList(L);
	//插入 
	L=InsertList(L,3,10);
	//删除 
	L=DeleteList(L,3);
	//查找
	SelectList(L,3); 
	//打印 
	PrintList(L);
	return 0;
}

单链表

#include
#include
#define test_NULL if(L->next==NULL){printf("链表为空");exit(1);}
//定义结构 
typedef struct node{
	int data;
	struct node *next;
}LNode,*SqList;
//初始化带头节点链表 
SqList InitList(){
	SqList L = (SqList)malloc(sizeof(LNode));//生成一个节点变量 
	if(L==NULL){
		printf("分配空间失败");
		exit(1);
	} 
	L->next=NULL;
	return L;
}  
//头插法建立单链表(打印出来为逆序) 
SqList SequenceCreatList(SqList L){
	int x;
	scanf("%d",&x);//第一个点
	while(x!=0){//输入9999结束
		LNode *NewNode = (LNode*)malloc(sizeof(LNode));//生成一个新节点变量
		if(NewNode==NULL){
			printf("分配空间失败");
			exit(1); 
		} 
		NewNode->data=x;
		NewNode->next=L->next;//将头结点的下一个节点改成新节点的下一个节点 
		L->next=NewNode;//新节点作为头结点的下一个节点 
		scanf("%d",&x); 
	}	
	return L;
} 
//尾插法建立单链表（打印出来为顺序）
SqList inSequenceCreatList(SqList L){
	int x;
	LNode* p=L;//指针指向L的头结点 
	scanf("%d",&x);
	while(x!=0){
		LNode* NewNode = (LNode*)malloc(sizeof(LNode));
		if(NewNode==NULL){
			printf("分配空间失败");
			exit(1);
		}
		NewNode->data=x;
		p->next=NewNode;
		p=NewNode;
		scanf("%d",&x);
	}
	p->next=NULL;
	return L;
}
//打印链表  
void PrintList(SqList L){
	test_NULL;//判空 
	printf("\n链表为："); 
	LNode* p;//指向当前节点指针
	p=L->next;//指针初始指向第一个节点（头结点的下一个节点） 
	while(p!=NULL){//指针非空继续遍历
		printf("%d ",*p);
		p=p->next; 
	}
	printf("\n\n");
}
//求表长操作
int GetLength(SqList L){
	test_NULL;//判空 
	int length=0;
	LNode* p=L->next;
	while(p){
		length++;
		p=p->next;
	}
	return length;
} 
//按序号查找节点值
LNode* GetElem(SqList L,int x){
	test_NULL;//判空 
	int i=0;
	LNode* p = L;
	if(x<1||x>GetLength(L)){
		printf("输入异常");
		return;
	}
	while(i<x){
		p=p->next;
		i++;
	}
	return p;
	
	
} 
//按值查找节点索引
int GetIndex(SqList L,int x){
	test_NULL;//判空 
	int i=0; 
	LNode * p = L->next;
	while(x!=p->data&&p){
		i++;
		p=p->next;	
	}
	return i+1; 
}
//后插法插入节点 
void InsertElem(SqList L,int x,int num){//在第x个位置插入num; 
	LNode* newNode = (LNode*)malloc(sizeof(LNode));
	LNode* p=GetElem(L,x-1);//找到插入节点的前驱节点 
	newNode->data=num;
	//往后插 
	newNode->next=p->next;
	p->next=newNode; 
} 
//删除节点
void DeleteElem(SqList L,int x){//删除第i个节点 
	test_NULL;//判空 
	LNode* newNode = (LNode*)malloc(sizeof(LNode));
	LNode* p=GetElem(L,x-1);//找到插入节点的前驱节点 
	LNode* q=p->next;//q指向被删除节点
	p->next=q->next; 
} 
int main(){
	//定义结构 
	SqList L;
	L = InitList(L);
	//初始化
	//L = inSequenceCreatList(L);
	 //打印链表 
	PrintList(L);
	//计算表长
	printf("表长为:%d\n\n",GetLength(L)); 
	//查询索引值 
	printf("请输入查询带查询值的索引:");
	int x1;
	scanf("%d",&x1);
	printf("第%d个节点值为：%d\n\n",x1,GetElem(L,x1)->data);
	//按值查找索引
	printf("请输入待查询索引的值:");
	int x2;
	scanf("%d",&x2);
	printf("值为%d的索引为：%d\n\n",x2,GetIndex(L,x2)); 
	//插入节点
	printf("输入插入位置，插入值:");
	int t,x3;
	scanf("%d %d",&t,&x3);
	InsertElem(L,t,x3);
	printf("插入之后链表:");
	PrintList(L);
	//删除节点
	printf("请输入删除位置:");
	int x4;
	scanf("%d",&x4);
	DeleteElem(L,x4); 
	printf("删除之后的链表:");
	PrintList(L);  
	return 0;
}

无头节点单链表

#include
#include
#define test_NULL if(L==NULL){printf("链表为空");exit(1);}
//定义结构
typedef struct node{
	int data;
	struct node *next;
}LNode,*SqList; 
//初始化链表
SqList InitSqList(SqList L){
	L=NULL;//防止脏数据
	return L; 
} 
//头插法建立单链表
SqList headBuildList(SqList L){
	int x;
	scanf("%d",&x);
	while(x!=0){
		LNode* newNode = (LNode*)malloc(sizeof(LNode));//生成一个节点变量
		if(newNode==NULL){
			printf("分配空间失败");
			exit(1); 
		} 
		newNode->data=x;
		newNode->next=L;
		L=newNode;
		scanf("%d",&x);
	}
	return L;
} 
//尾插法建立单链表
SqList behindBuildList(SqList L){
	int x;
	LNode* p=L; 
	scanf("%d",&x);
	while(x!=0){
		LNode* newNode =(LNode*)malloc(sizeof(LNode));//声明一个节点变量
		if(newNode==NULL){
			printf("分配空间失败");
			exit(1); 
		}
		newNode->data=x;
		if(p){//判断插入的是否为第一个点 
			p->next=newNode;//表尾指针指向最后一个点 
		}else{
			L=newNode;//头指针指向第一个节点 
		} 
		p=newNode;
		scanf("%d",&x);
	}
	p->next=NULL;//必须设置尾节点 
	return L;
} 
//打印链表
void PrintList(SqList L){
	test_NULL;
	LNode *q = L;
	while(q){
		printf("%d ",q->data);
		q=q->next;
	}
} 
//求表长
int lengthList(SqList L){
	test_NULL;
	int length=0;
	LNode* p = L;
	while(p){
		p=p->next;
		length++;
	}
	return length;
} 
//查询第i个点
LNode* FindLocate(SqList L,int i){
	test_NULL;
	LNode *p = L;
	int j=1;
	while(j!=i){
		p=p->next;
		j++; 
	}
	return p;//找到查询点节点的地址 
} 
//插入操作
SqList InsertList(SqList L,int i,int e){ 
	test_NULL;
	if(i<1||i>lengthList(L)) {
		printf("输入不合法\n");
		exit(1); 
	}
	LNode* newNode = (LNode*)malloc(sizeof(LNode));//分配一个节点变量 
	if(newNode==NULL){
			printf("分配空间失败");
			exit(1); 
	}
	newNode->data=e;
	if(i==1){//如果在插入到第一个节点，由于没有头节点，所以要处理 
		newNode->next=L;
		L=newNode;
		return L;
	} 
	//插入其他正常位置 
	LNode* frontNode = FindLocate(L,i-1);
	newNode->next=frontNode->next;
	frontNode->next=newNode;
	return L;
} 
//删除节点 
SqList DeleteNode(SqList L,int i){
	test_NULL;
	//由于是无头链表删除第一个点要特殊处理 
	if(i==1){
		LNode* q = L;//q指向第一个节点 
		L = q->next;
		free(q);//释放空间 
		return L;
	}
	//其他位置正常处理 
	LNode* frontNode = FindLocate(L,i-1);//查找删除节点前一个节点地址 
	LNode* q = frontNode->next;
	frontNode->next = frontNode->next->next;
	free(q);//释放内存空间 
	return L;
}
//修改节点值
SqList UpdateNode(SqList L,int i,int x){
	test_NULL;
	LNode* Node = FindLocate(L,i);
	Node->data = x;
	return L;
	
} 
int main(){
	//声明链表 
	SqList L;
	//初始化链表 
	L = InitSqList(L);
	//建立链表 
	L = behindBuildList(L);
	//打印链表 
	//求表长
	printf("表长为：%d\n",lengthList(L)); 
	//插入操作
	//L=InsertList(L,1,100);
	//删除节点 
	//L=DeleteNode(L,3);
	//修改节点值
	UpdateNode(L,1,100); 
	//打印链表 
	PrintList(L);
	return 0;
}

双链表

#include
#include
#define test_NULL if(L->next==NULL){printf("链表为空");exit(1);}
//定义结构
typedef struct Node{
	int data;
	struct Node *prior,*next;
}LNode,*SqList; 
//双链表初始化(带头结点)
SqList InitList(){ 
	LNode* L = (LNode*)malloc(sizeof(LNode));//分配头结点变量 
	if(L==NULL){
		printf("分配空间失败");
		exit(1);
	}
	//头结点两个指针设为空 
	L->next=NULL;
	L->prior=NULL; 
} 
//建立链表 
SqList BuildList(SqList L){
	int x;
	scanf("%d",&x);
	LNode* p = L;//浮动指针 
	while(x!=0){
		LNode* newNode = (LNode*)malloc(sizeof(LNode));//分配新节点变量
		newNode->data = x;//存入值
		//newNode->prior=newNode->next=NULL;
		//后插法插入链表 
		p->next=newNode;
		newNode->prior=p;
		p=newNode; 
		scanf("%d",&x);
	}
	p->next=NULL;
	return L;
}
//打印链表
void PrintfList(SqList L){
	test_NULL;
	LNode* p = L->next;
	while(p){
		printf("%d ",p->data);
		p = p->next;
	}
	 
} 
//求表长
int LengthList(SqList L){
	test_NULL;
	int length = 0;
	LNode* p = L->next;
	while(p){
		length++;
		p = p->next;
	}
	return length;
} 
//返回节点地址
LNode* FindLocate(SqList L,int i){
	test_NULL;
	int j=1;
	LNode* p = L->next;
	while(i!=j){
		p = p->next;
		j++;
	}
	return p;
} 
//插入操作
SqList InsertList(SqList L,int i,int e){
	test_NULL;
	LNode* newNode = (LNode*)malloc(sizeof(LNode));
	if(newNode==NULL){
		printf("空间分配失败");
		exit(1);
	} 
	newNode->data=e;
	//修改指针 
	LNode* p = FindLocate(L,i);//找到插入点地址
	newNode->next = p;
	p->prior->next=newNode;
	newNode->prior = p->prior;
	p->prior = newNode;
	return L;
	 
} 
//删除操作
SqList DeleteList(SqList L,int i){
	test_NULL;
	LNode* p = FindLocate(L,i);//找到插入点地址
	//修改指针 
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	return L;
} 
int main(){
	//初始化双链表 
	SqList L = InitList();
	//建立双链表
	L = BuildList(L);
	//求表长
	printf("表长为%d\n",LengthList(L));
	//插入节点
	L =  InsertList(L,2,100);
	//删除节点
	L = DeleteList(L,2); 
	//打印链表
	PrintfList(L); 
	return 0;
}

循环双链表

#include
#include
#define test_NULL if(L->next==NULL){printf("链表为空");exit(1);}
//定义结构
typedef struct Node{
	int data;
	struct Node *prior,*next;
}LNode,*SqList; 
//双链表初始化(带头结点)
SqList InitList(){ 
	LNode* L = (LNode*)malloc(sizeof(LNode));//分配头结点变量 
	if(L==NULL){
		printf("分配空间失败");
		exit(1);
	}
	//头结点两个指针指向本身 
	L->next=L;
	L->prior=L; 
} 
//建立链表 
SqList BuildList(SqList L){
	int x;
	scanf("%d",&x);
	LNode* p = L;//浮动指针 
	while(x!=0){
		LNode* newNode = (LNode*)malloc(sizeof(LNode));//分配新节点变量
		newNode->data = x;//存入值
		//newNode->prior=newNode->next=NULL;
		//后插法插入链表 
		p->next=newNode;
		newNode->prior=p;
		p=newNode; 
		scanf("%d",&x);
	}
	//首尾相连 
	p->next=L;
	L->prior=p; 
	return L;
}
//打印链表
void PrintfList(SqList L){
	test_NULL;
	LNode* p = L->next;
	while(p!=L){//不等于头指针为终止条件 
		printf("%d ",p->data);
		p = p->next;
	}
	 
} 
//求表长
int LengthList(SqList L){
	test_NULL;
	int length = 0;
	LNode* p = L->next;
	while(p!=L){//不等于头指针为终止条件 
		length++;
		p = p->next;
	}
	return length;
} 
//返回节点地址
LNode* FindLocate(SqList L,int i){
	test_NULL;
	int j=1;
	LNode* p = L->next;
	while(i!=j){
		p = p->next;
		j++;
	}
	return p;
} 
//插入操作
SqList InsertList(SqList L,int i,int e){
	test_NULL;
	LNode* newNode = (LNode*)malloc(sizeof(LNode));
	if(newNode==NULL){
		printf("空间分配失败");
		exit(1);
	} 
	newNode->data=e;
	//修改指针 
	LNode* p = FindLocate(L,i);//找到插入点地址
	newNode->next = p;
	p->prior->next=newNode;
	newNode->prior = p->prior;
	p->prior = newNode;
	return L;
	 
} 
//删除操作
SqList DeleteList(SqList L,int i){
	test_NULL;
	LNode* p = FindLocate(L,i);//找到插入点地址
	//修改指针 
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	return L;
} 
int main(){
	//初始化双链表 
	SqList L = InitList();
	//建立双链表
	L = BuildList(L);
	//求表长
	printf("表长为%d\n",LengthList(L));
	//插入节点
	L =  InsertList(L,2,100);
	//删除节点
	L = DeleteList(L,2); 
	//打印链表
	PrintfList(L); 
	return 0;
}

顺序栈

#include
#include
#define MaxSize 100
#define test_NULL if(S.top==-1){printf("栈空");exit(1);} 
typedef struct{
	int data[MaxSize];
	int top;
}SqStack;
//初始化栈 
SqStack InitStack(SqStack S){
	S.top = -1;//初始化栈顶指针 
}
//判断栈空 
int StackEmpty(SqStack S){
	return S.top=-1?1:0; 
} 
//进栈
SqStack PushStack(SqStack S,int x){
	if(S.top==MaxSize-1){//判断栈满 
		printf("栈满\n");
		exit(1);
	}
	S.data[++S.top]=x;
	return S;
} 
//出栈
SqStack popStack(SqStack S){
	test_NULL;
	 S.top--;
	 return S;
} 
//读取栈顶元素
int GetTop(SqStack S){	
	test_NULL;
	return S.data[S.top];
} 
int main(){
	//定义一个栈
	SqStack S;
	//初始栈 
	S = InitStack(S); 
	//进栈
	int x; 
	scanf("%d",&x);
	while(x!=0){
		S=PushStack(S,x); 
		scanf("%d",&x);
	}
	//读取栈顶元素 

	printf("栈顶元素为:%d\n",GetTop(S));
	//出栈
	S=popStack(S);
	//读取栈顶元素 
	printf("栈顶元素为:%d\n",GetTop(S));
	return 0;
}

链栈

#include
#include
typedef struct LinkNode{
	int data;
	struct LinkNode *next;
}LNode,*LiStack;
///初始化链栈 
LiStack InitTsack(){
	LiStack S = (LiStack)malloc(sizeof(LNode));//初始化一个带头结点的链栈
	 if(S==NULL){
	 	printf("内存分配失败\n");
	 	exit(1);
	 }
	 S->next = NULL;
}
//判断栈空
int EmptyStack(LiStack S){
	return S->next==NULL?1:0;
} 
//进栈
LiStack PushStack(LiStack S,int x){
	LNode* newNode = (LNode*)malloc(sizeof(LNode)); 
	if(S==NULL){
	 	printf("内存分配失败\n");
	 	exit(1);
	 }
	 newNode->data = x;
	 newNode->next=S->next; 
	 S->next=newNode;
	 return S;
} 
//出栈
LiStack PopStack(LiStack S){
	if(EmptyStack(S)){
		printf("栈空\n");
		exit(1);
	}
	LNode* p = S->next;
	S->next=S->next->next;
	free(p);
	return S; 
} 
//获取栈顶元素 
int GetTop(LiStack S){
	if(EmptyStack(S)){
		printf("栈空\n");
		exit(1);
	}
	return S->next->data;
}
//链栈大小
int LengthSTack(LiStack S){
	LNode* p = S->next;
	int length = 0;
	while(p){
		length++;
		p = p->next;
	}
	return length;
} 
int main(){
	LiStack S;
	//初始化栈 
	S = InitTsack();
	//进栈
	int x; 
	scanf("%d",&x);
	while(x!=0){
		S=PushStack(S,x); 
		scanf("%d",&x);
	}
	
	printf("栈的大小:%d\n",LengthSTack(S));
	//出栈
	PopStack(S); 
	//获取栈顶元素
	printf("栈顶元素为:%d\n",GetTop(S)); 
	return 0;
}

循环队列

#include
#include
#define MaxSize 100
//定义结构
typedef struct{
	int data[MaxSize];
	int front,rear;
}SqQueue;
//初始化队列
SqQueue InitQueue(SqQueue Q){
	Q.front=Q.rear=0;
} 
//入队
SqQueue EnQueue(SqQueue Q,int x){
		if((Q.rear+1)%MaxSize==Q.front){
			printf("队满");
			exit(1);
		}
		Q.data[Q.rear]=x;
		Q.rear = (Q.rear+1)%MaxSize;
		return Q;
} 
//判空 
int IsEmpty(SqQueue Q){
	return Q.front==Q.rear?1:0;
} 
//出队
SqQueue Dequeue(SqQueue Q){
	if(IsEmpty(Q)){
		printf("队空\n");
		exit(1); 
	}
	Q.front=(Q.front+1)%MaxSize;
	return Q;
} 
//获取队首元素
int GetFront(SqQueue Q){
	if(IsEmpty(Q)){
		printf("队空\n");
		exit(1); 
	}
	return Q.data[Q.front];
} 
//获取队长
int LengthQueue(SqQueue Q){
	if(IsEmpty(Q)){
		printf("队空\n");
		exit(1); 
	}
	return (Q.rear-Q.front+MaxSize)%MaxSize;
} 
int main(){
	SqQueue Q;
	//初始化队列 
	Q = InitQueue(Q);
	//入队
	int x; 
	scanf("%d",&x);
	while(x!=0){
		Q=EnQueue(Q,x); 
		scanf("%d",&x);
	}
	printf("队首元素为:%d  队列长度为%d\n\n",GetFront(Q),LengthQueue(Q));
	Q = Dequeue(Q);
	printf("队首元素为:%d  队列长度为%d\n\n",GetFront(Q),LengthQueue(Q));
	
	
	return 0;
}

链式队列

#include
#include
//链式队列节点 
typedef struct LinkNode{
	int data;
	struct LinkNode *next;
}LinkNode;
//队列头指针和尾部指针
typedef struct{
	LinkNode *front,*rear;
}LinkQueue;
//初始化
LinkQueue InitQueue(LinkQueue Q){
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));//建立头结点
	Q.front->next=NULL; 
	return Q;
} 
//判空
int IsEmpty(LinkQueue Q){
	return Q.front == Q.rear?1:0;
} 
//入队
LinkQueue EnQueue(LinkQueue Q,int x){
	LinkNode*s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data=x;s->next=NULL;
	Q.rear->next=s;
	Q.rear=s;
	return Q;
} 
//出队
LinkQueue DeQueue(LinkQueue Q){
	if(IsEmpty(Q)){
		printf("队空");
		exit(1);
	}
	LinkNode* p = Q.front->next;
	Q.front->next=p->next;
	free(p);
	return Q;
} 
//获取队列长度
int LengthQueue(LinkQueue Q){
	if(IsEmpty(Q)){
		printf("队空");
		exit(1);
	}
	int length = 0;
	LinkNode* p=Q.front->next;
	while(p){
		length++;
		p=p->next;
	}
	return length;
}
//获取队列首元素
int  GetFront(LinkQueue Q){
	if(IsEmpty(Q)){
		printf("队空");
		exit(1);
	}
	return Q.front->next->data;
}

 
int main(){
	LinkQueue Q;
	//初始化 
	Q = InitQueue(Q);
	//入队
	int x; 
	scanf("%d",&x);
	while(x!=0){
		Q=EnQueue(Q,x); 
		scanf("%d",&x);
	}
	printf("队首元素为:%d  队列长度为%d\n\n",GetFront(Q),LengthQueue(Q)); 
	Q = DeQueue(Q);
	printf("队首元素为:%d  队列长度为%d\n\n",GetFront(Q),LengthQueue(Q));
	return 0;
}