数据结构 C语言实现各种操作

w645551

于 2024-04-18 22:39:29 发布

阅读量183

点赞数 3

文章标签：数据结构 c语言 windows

本文链接：https://blog.csdn.net/w645551/article/details/137932505

版权

1顺序表

#include "seq_list.h"
//创建顺序表(从堆区申请空间)
seq_p create_seq()
{
	//从堆区申请一个顺序表的空间
	seq_p S = (seq_p)malloc(sizeof(seq_list));
	if(S==NULL)
	{
		printf("空间申请失败\n");
		return NULL;
	}
	S->len = 0;
	bzero(S->data,sizeof(S->data)); //给数组清0
	return S;   //返回堆区申请的首地址
}
//判空
int empty_seq(seq_p S)
{
	//入参合理性检查
	if(S==NULL)
	{
		printf("入参为空\n");
		return -1;
	}
	return S->len==0?1:0;
}
//判满
int full_seq(seq_p S)
{
	//入参合理性检查
	if(S==NULL)
	{
		printf("入参为空\n");
		return -1;
	}
	return S->len==MAX?1:0;
}
//头插
void insert_head(seq_p S,datatype data)
{
	//入参合理性检查
	if(S==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//判满
	if(full_seq(S))
	{
		printf("表已满，不能插入\n");
		return;
	}
	//需要把元素循环后移
	for(int i=S->len-1;i>=0;i--)
	{
		//元素后移
		S->data[i+1] = S->data[i];
	}
	//第一个位置可以被覆盖
	S->data[0]=data;
	//顺序表的长度自增
	S->len++;
}
//输出顺序表
void show(seq_p S)
{
	//入参合理性检查
	if(S==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//判空
	if(empty_seq(S))
	{
		printf("表为空，无需输出\n");
		return;
	}
	for(int i=0;i<S->len;i++)
	{
		printf("%d\n",S->data[i]);
	}
}
//尾插
void insert_tail(seq_p S,datatype data)
{
	//入参合理性检查
	if(S==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//判满
	if(full_seq(S))
	{
		printf("表已满，不能插入\n");
		return;
	}
	S->data[S->len]=data;  //尾插
	S->len++;
}
void delete_head(seq_p S)
{
	if(S==NULL)
	{
		printf("入参为空\n");
		return;
	}
	if(empty_seq(S))
	{
		printf("表为空，无法删除\n");
		return;
	}
	for(int i=0;i<S->len-1;i++)
	{
		S->data[i]=S->data[i+1];
	}
	S->len--;
}
void clear_seq(seq_p S)
{
	if(S==NULL)
	{
		printf("入参为空\n");
		return;
	}
	S->len=0;

}
int Insert_seq(seq_p S,int index,datatype data)
{	
    if (S == NULL || index < 0 || index > S->len+1 || S->len == MAX) {  
        // 顺序表为空、索引无效、或已满，无法插入  
		printf("位置不合理\n");
        return -1;
    }  
	for(int i=S->len;i>index;i--)
	{
		S->data[i]=S->data[i-1]; //元素后移
	}
	S->data[index-1]=data; //在指定位置插入
	S->len++;
	return 0;

}
// 一级指针，只能释放空间，不能给主函数中的S置空
// 二级指针，能给主函数中的S置空
void Free_seq(seq_p *S) {
    if (S = NULL || *S = NULL) 
	S==NULL和*S==NULL不能交换位置，因为S是一个二级指针，
	//要先判断二级指针不为空，再判断二级指针指向的内容不为空
	{
        free(*S);  // 释放数组
       *S = NULL; 
    }
}
void Delete_seq(seq_p S,int index)
{
	if(S==NULL)
	{
		printf("入参为空\n");
		return;
	}
	if(empty_seq(S))
	{
		printf("表为空，无法删除\n");
		return;
	}
	if(index<0 || index>S->len)
	{
		printf("位置不合理\n");
		return;
	}
	for(int i=index; i<=S->len-1; i++)
	{
		S->data[i-1]=S->data[i];  //元素前移
	}
	S->len--;
}
void RemoveDup(seq_p S)
{
	if(S==NULL)
	{
		printf("入参为空\n");
		return;
	}	
	if(empty_seq(S))
	{
		printf("表为空，无法去重\n");
		return;
	}
	if(S->len == 1)
	{
		printf("表中只有一个元素。无法去重\n");
		return;
	}
    //先循环遍历顺序表表中的每一个元素
	for (int i=0; i<S->len; i++)
	{
		for(int j=i+1; j<S->len; j++)
		{
			if (S->data[i]==S->data[j])
			{
				Delete_seq(S,j+1);
				j--; 
				//按位置删除后，原来已经判断过的位置，被新的元素覆盖了需要重新判断
			}
			
		}
	}

}

2 单链表

#include "link.list.h"
//创建头结点
node_p create_link_list()
{
	node_p H=(node_p)malloc(sizeof(node));
	if(H==NULL)
	{
		printf("申请失败\n");
		return NULL;
	}
	return H;	
}
//创建数据节点
node_p create_node(int data)
{
	node_p new = (node_p)malloc(sizeof(node));
	if(new==NULL)
	{
		printf("申请失败\n");
		return NULL;
	}
	new->data=data;
	return new;
}
//头插
void insert_head(node_p H,int data)
{
	//入参合理性检查
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//给数据申请节点
	node_p new=create_node(data);//返回堆区申请的空间的首地址
	new->next=H->next;
	H->next=new;
	H->data++;
}
//单链表的判空
int empty_link(node_p H)
{
	//入参合理性检查
	if(H==NULL)
	{
		printf("入参为空\n");
		return -1;
	}
	return H->next==NULL?1:0;
}
//单链表的输出
void show_link(node_p H)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	if(empty_link(H))
	{
		printf("表为空\n");
		return;
	}
	node_p p=H->next;//从第一个节点开始输出
	                 //p是node_p类型
	while(p!=NULL) 	//最后一个结点需要进入输出
	{	
		printf("%d->",p->data);
		p = p->next;
	}
	printf("NULL\n");	
}
//头删
void del_head(node_p H)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	if(empty_link(H))
	{
		printf("表为空\n");
		return;
	}
	node_p del=H->next; //保存要删除的结点
	H->next=H->next->next;
	free(del);
	H->data--;
}
//尾插
void insert_tail(node_p H,int data)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	node_p p = H;
	while(p->next!=NULL)
	{	
		p = p->next;
	}
	//申请新结点
	node_p new = create_node(data);
	//让新结点的指针域，保留原来尾结点的指针域
	new->next = p->next;
	//原来的尾结点指向新结点
	p->next = new;
	H->data++;
}
//尾删
void dele_tail(node_p H)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	if(empty_link(H))
	{
		printf("表为空\n");
		return;
	}
	node_p p = H;
	while(p->next->next!=NULL)//找到倒数第二个结点
	{	
		p = p->next;
	}
	node_p del = p->next;  //保存要删除的尾结点
	p->next = p->next->next; 
	free(del);
	H->data--;
}
// 按位置插入
void insert_pos(node_p H,int data,int pos)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//判断位置不合理的情况
	//如果有5个元素，往第6个位置插入相当于尾插
	if(pos <= 0 || pos > H->data+1)
	{
		printf("位置不合理\n");
		return;
	}
    //找到pos-1位置的结点
	int i = 0;  //i用来记录位置
	node_p p = H; //让指针从头结点出发
	while(i!=pos-1)//找到pos-1位置的结点
	{
		p = p->next;
		i++;
	}
	node_p new = create_node(data);
	new->next=p->next;//让新结点的指针指向原来的pos位置的结点
	p->next=new;//让pos-1位置的结点指向新结点
	H->data++;
}
//按位置删除
void delete_pos(node_p H,int pos)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//判断位置不合理的情况
	if(pos <= 0 || pos > H->data)
	{
		printf("位置不合理\n");
		return;
	}
    //找到pos-1位置的结点
	int i = 0;  //i用来记录位置
	node_p p = H; //让指针从头结点出发
	for(i=0;i<pos-1;i++)
	{
		p=p->next;
	}
	node_p del = p->next; //保存要删除的结点
	p->next=p->next->next;
	free(del);
	H->data--;
}
//按位置查找，返回值
int search_pos(node_p H,int pos)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return -1;
	}
	//判断位置不合理的情况
	if(pos <= 0 || pos > H->data)
	{
		printf("位置不合理\n");
		return -2;
	}
	node_p p=H->next;
	int i = 1;
	while(i<pos)
	{
		p=p->next;
		i++;
	}
	return p->data;


}
//按值修改元素,不考虑重复元素
void updata_value(node_p H,int key,int new_data)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	if(empty_link(H))
	{
		printf("链表为空\n");
		return;
	}
	node_p p=H->next;//从第一个数据节点开始查找
	while(p!=NULL)
	{
		if(p->data==key)
		{
			p->data=new_data;
			return;
		}
		p=p->next;

	}

}
//单向链表的逆置
void overturn_link(node_p H)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	if(empty_link(H))
	{
		printf("链表为空,无需逆置\n");
		return;
	}
	if(H->next->next==NULL)
	{
		printf("只有一个元素，无需逆置\n");
		return;
	}
	//先保留第二个结点的地址
	node_p p = H->next->next;
	H->next->next = NULL;  //给第一个结点的指针域赋值为NULL，变成最后一个结点
	node_p q;     //暂时是一个野指针
	while(p!=NULL)
	{
		q = p->next;   //在头插之前保留下一个要头插结点的首地址
		p->next = H->next; //头插
		H->next = p;
		p = q;  //让p指向下一个要头插的结点
	}
}

3 单向循环链表

#include "loop_list.h"
//创建单循环链表
node_p create_loop()
{
	node_p H = (node_p)malloc(sizeof(node));
	if(H==NULL)
	{
		printf("空间申请失败\n");
		return NULL;
	}
	H->data = 0;
	H->next = H;
	return H;
}
//创建新节点
node_p create_node(int data)
{
	node_p new = (node_p)malloc(sizeof(node));
	if(new==NULL)
	{
		printf("空间申请失败\n");
		return NULL;
	}
	new->data = data;
	return new;
}
//判空
int empty_loop(node_p H)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return -1;
	}
	return H->next==H?1:0;
}
//头插
void insert_head(node_p H,int data)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	node_p new = create_node(data);
	new->next = H->next;
	H->next = new;
	H->data++;
}
//输出
void show(node_p H)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	node_p p = H->next;
	while(p!=H)  //H==NULL时，while循环不执行
	{
		printf("%d->",p->data);
		p=p->next;
	}
	printf("H\n");
}
//尾插
void insert_tail(node_p H,int data)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	node_p new = create_node(data);
	node_p p = H;
	while(p->next!=H)
	{
		p=p->next;
	}
	new->next = p->next;
	p->next = new;
	H->data++;
}
//头删
void dele_head(node_p H)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	if(empty_loop(H))
	{
		printf("链表为空\n");
		return;
	}
	node_p del = H->next;
	H->next = H->next->next;
	free(del);
	H->data--;
}
//按位置插入
void insert_pos(node_p H,int data,int pos)
{
	//入参合理性检查
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//pos合理性检查
	if(pos < 0 || pos > H->data+1)
	{
		printf("pos值不合理\n");
		return;
	}
	node_p p = H;
	int i = 0;
	for(i=0;i<pos-1;i++)
	{
		p=p->next;
	}
	node_p new = create_node(data);
	new->next = p->next;
	p->next = new;
	H->data++;
}
//删除单循环链表的头结点
node_p dele(node_p H)
{
	//入参合理性检查
	if(H==NULL)
	{
		printf("入参为空\n");
		return NULL;
	}
	node_p p = H->next;
	//把尾结点的指针域指向第一个结点
	while(p->next!=H)  //找到尾结点
	{
		p=p->next;
	}
	node_p temp = H->next;
	p->next = H->next;
	free(H);
	return temp;  //返回可以操作链表的第一个结点
}
//输出删除头结点后的单循环链表
void show_no_head(node_p T)
{
	if(T==NULL)
	{
		printf("入参为空\n");
		return;
	}
	node_p p = T;//从第一个结点开始遍历链表
/*	while(p->next!=T) 
	{
		printf("%d->",p->data);
		p=p->next;
	}
	printf("%d->T\n",p->data);*/
	do
	{
		printf("%d->",p->data);
		p = p->next;
	}while(p!=T);  //使用do···while循环为了让第一个结点进入循环
	printf("T\n");

}

4 双向链表

#include "double_loop.h"

//创建双向循环链表
node_p create_dbloop()
{
	node_p H = (node_p)malloc(sizeof(node));
	if(H==NULL)
	{
		printf("申请失败\n");
		return NULL;
	}
	return H;
	H->next = H;
	H->prev = H;
	H->data = 0;
}
//创建结点
node_p create_node(int data)
{
	node_p new = (node_p)malloc(sizeof(node));
	if(new==NULL)
	{
		printf("申请失败\n");
		return NULL;
	}
	new->data = data;
	return new;
}
//头插
void insert_head(node_p H,int data)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	node_p new = create_node(data);
	new->next = H->next;
	new->prev = H;
	H->next->prev = new;//链表只有头结点时，H->next==H
	H->next = new;
	H->data++;
}
//尾插
void insert_tail(node_p H,int data)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	node_p p = H;
	while(p->next!=H) //找到最后一个结点，只有头结点，H->next=H时，不执行
	{
		p=p->next;
	}
	node_p new = create_node(data);
	new->next = p->next; //p->next == H
	new->prev = p;
	p->next->prev = new; //H->prev = new; p->next->prev==H
	p->next = new;
	H->data++;
}
//按位置插入
void insert_pos(node_p H,int data,int pos)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//pos的合理性检查
	if(pos<=0 || pos>H->data+1)
	{
		printf("pos值不合理\n");
		return;
	}
	node_p p = H;
	for(int i=0;i<pos-1;i++) //找到pos-1的位置
	{
		p=p->next;
	}
	node_p new = create_node(data);
	new->next = p->next;
	new->prev = p;
	p->next->prev = new; //不涉及段错误，双向循环链表，一个环
	p->next = new;
	H->data++;
}
//按位置删除
void del_pos(node_p H,int pos)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//pos的合理性检查
	if(pos<=0 || pos>H->data)
	{
		printf("pos值不合理\n");
		return;
	}
	node_p p = H;
	for(int i=0;i<pos-1;i++) //找到pos-1位置的结点
	{
		p=p->next;
	}
	node_p del = p->next;
	p->next = p->next->next;
	p->next->next->prev = p;
	free(del);
	H->data--;
}
//输出
void show(node_p H)
{
	node_p p = H;
	while(p->next!=H)
	{
		printf("%d->",p->data);
		p=p->next;
	}
	printf("NULL");
}

5 双向循环链表

#include "double_loop.h"

//创建双向循环链表
node_p create_dbloop()
{
	node_p H = (node_p)malloc(sizeof(node));
	if(H==NULL)
	{
		printf("申请失败\n");
		return NULL;
	}
	H->next = H;
	H->prev = H;
	H->data = 0;
	return H;
}
//创建结点
node_p create_node(int data)
{
	node_p new = (node_p)malloc(sizeof(node));
	if(new==NULL)
	{
		printf("申请失败\n");
		return NULL;
	}
	new->data = data;
	return new;
}
//头插
void insert_head(node_p H,int data)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	node_p new = create_node(data);
	new->next = H->next;
	new->prev = H;
	H->next->prev = new;//链表只有头结点时，H->next==H
	H->next = new;
	H->data++;
}
//尾插
void insert_tail(node_p H,int data)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	node_p p = H;
	while(p->next!=H) //找到最后一个结点，只有头结点，H->next=H时，不执行
	{
		p=p->next;
	}
	node_p new = create_node(data);
	new->next = p->next; //p->next == H
	new->prev = p;
	p->next->prev = new; //H->prev = new; p->next==H
	p->next = new;
	H->data++;
}
//按位置插入
void insert_pos(node_p H,int data,int pos)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//pos的合理性检查
	if(pos<=0 || pos>H->data+1)
	{
		printf("pos值不合理\n");
		return;
	}
	node_p p = H;
	for(int i=0;i<pos-1;i++) //找到pos-1的位置
	{
		p=p->next;
	}
	node_p new = create_node(data);
	new->next = p->next;
	new->prev = p;
	p->next->prev = new; //不涉及段错误，双向循环链表，一个环
	p->next = new;
	H->data++;
}
//按位置删除
void del_pos(node_p H,int pos)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	//pos的合理性检查
	if(pos<=0 || pos>H->data)
	{
		printf("pos值不合理\n");
		return;
	}
	node_p p = H;
	for(int i=0;i<pos-1;i++) //找到pos-1位置的结点
	{
		p=p->next;
	}
	node_p del = p->next;
	p->next = p->next->next;
	p->next->next->prev = p;
	free(del);
	H->data--;
}
//输出
void show(node_p H)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return;
	}
	if(empty_dbloop(H))
	{
		printf("链表为空\n");
		return;
	}
	node_p p = H->next;
	while(p!=H)
	{
		printf("%d->",p->data);
		p=p->next;
	}
	printf("H\n");
}
//判空
int empty_dbloop(node_p H)
{
	if(H==NULL)
	{
		printf("入参为空\n");
		return -1;
	}
	return H->next==H?1:0;
}

6 栈

6.1顺序栈

#include "seq_stack.h"
//从堆区申请顺序栈的空间
seq_p create_stack()
{
	seq_p S = (seq_p)malloc(sizeof(seq_stack));
	if(S==NULL)
	{
		printf("申请空间失败\n");
		return NULL;
	}
	S->top = -1;
	return S;
}
//入栈/压栈
void push_stack(seq_p S,datatype data)
{
	if(S==NULL)
	{
		printf("申请空间失败\n");
		return;
	}
	if(full_stack(S))
	{
		printf("栈满\n");
		return;
	}
	S->top++;
	S->data[S->top]=data;
}

//判空
int empty_stack(seq_p S)
{
	if(S==NULL)
	{
		printf("申请空间失败\n");
		return -1;
	}
	return S->top==-1?1:0;
}
//判满
int full_stack(seq_p S)
{
	if(S==NULL)
	{
		printf("申请空间失败\n");
		return -1;
	}
	return S->top==MAX-1?1:0;
}
//输出
void show(seq_p S)
{
	if(S==NULL)
	{
		printf("申请空间失败\n");
		return;
	}
	if(empty_stack(S))
	{
		printf("栈空\n");
		return;
	}
	for(int i=S->top;i>=0;i--)
	{
		printf("%-4d",S->data[i]);		
	}
	putchar(10);
}
//出栈
void pop_stack(seq_p S)
{
	if(S==NULL)
	{
		printf("申请空间失败\n");
		return;
	}
	if(empty_stack(S))
	{
		printf("栈空\n");
		return;
	}
	printf("出栈元素为%d\n",S->data[S->top--]);
}
//释放顺序栈
void free_stack(seq_p *S)
{
	if(S==NULL || *S==NULL)
	{
		printf("入参为空\n");
		return;
	}
	free(S);
}

6.2 链栈

#include "link_stack.h"
//申请节点
node_p create_node(int data)
{
	node_p new = (node_p)malloc(sizeof(node));
	if(new==NULL)
	{
		printf("申请空间失败\n");
		return NULL;
	}
	new->data = data;
	return new;
}

//入栈
//T的指针是在堆区，出入栈需要修改T的指向，要传入*T，修改实参
//否则修改的只是形参
void push_stack(node_p *T,int data)
{
	node_p new = create_node(data);
	new->next = *T;
	*T = new;
}

//判空
int empty_stack(node_p T)
{
	return T==NULL?1:0;
}
//出栈
void pop_stack(node_p *T)
{
	node_p del = *T;
	*T=(*T)->next;
	printf("要出栈的元素为%d\n",del->data);
	free(del);
}
//输出栈
void show(node_p T)
{
	if(empty_stack(T))
	{
		printf("栈为空\n");
		return;
	}
	node_p p = T;
	while(p!=NULL)
	{
		printf("%d->",p->data);
		p=p->next;
	}
}