day5数据结构

最新推荐文章于 2024-06-17 19:15:39 发布

欸嘿HYL

最新推荐文章于 2024-06-17 19:15:39 发布

阅读量15

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/HYL1234511/article/details/132157362

版权

头文件

#ifndef _LINKLIST_H
#define _LINKLIST_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef char datatype;//重名命名
//定义节点类型
typedef struct Node
{
	union
	{
		datatype data;//节点数据域
		int len;//头结点数据域
	};
	struct Node *next;//指针域

}Node,*LinkListPtr;
//创建链表
LinkListPtr list_create();
//判断空
int list_empty(LinkListPtr L);
//申请节点分装数据函数
LinkListPtr node_buy(datatype e);
//头插
int list_inser_head(LinkListPtr L,datatype e);
//遍历
void list_show(LinkListPtr L);
//尾插
int list_inser_tail(LinkListPtr L,datatype e);
//任意插
int list_insert_post(LinkListPtr L,int pos,datatype e);

//头删
int list_delete_head(LinkListPtr L);


//尾删
int list_delete_tail(LinkListPtr L);

//任意删
int list_delete_post(LinkListPtr L,int pos);
//递归反转
void list_reverse_dg(LinkListPtr L);

//按位置查找返回节点
int list_search_value(LinkListPtr L, datatype e);

//按值查找返回节点位置
LinkListPtr list_search_pos(LinkListPtr L,int pos);
//按位置进行修改
int list_mod(LinkListPtr L,int pos,datatype e);
//按值进行修改
int list_mod_varle(LinkListPtr L,datatype e,datatype m);

//链表的排序
int list_sore(LinkListPtr L,int flag);

//链表的反转*
void list_reverse(LinkListPtr L);
//返回链表长度
int list_length(LinkListPtr L);

//链表的销毁
void list_free(LinkListPtr L);
#endif

源文件

#include"linklist.h"
//创建链表
LinkListPtr list_create()
{
	//在堆区申请一个头节点
	LinkListPtr L =(LinkListPtr)malloc(sizeof(Node));
	if(NULL==L)
	{
		printf("创建失败\n");
		return NULL;

	}	
	//创建成功初始化节
	L->len=0;
	L->next=NULL;
	printf("创建链表成功\n");
	return L;
}


//判断空
int list_empty(LinkListPtr L)
{
		if(NULL==L)
	{
		printf("所给链表不合法\n");
		return -1;

	}	
		//判断指针域的内容
		return L->next==NULL &&L->len==0;
	
}
//申请节点分装函数
LinkListPtr node_buy(datatype e)
{
	LinkListPtr P=(LinkListPtr)malloc(sizeof(Node));
	if(NULL==P)
	{
		printf("节点申请失败\n");
		return NULL;
	}
	//节点申请成功将数据分装进去
	P->data=e;
	P->next=NULL;
	return P;
}

//头插
int list_inser_head(LinkListPtr L,datatype e)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("所给链表不合法\n");
		return 0;
	}
	//调用函数申请节点分装数据
	LinkListPtr P=node_buy(e);
	if(NULL==P)
	{
		return 0;
	}
	//结点已经准备好,准备头插逻辑
	P->next=L->next;
	L->next=P;
	//表的变化
	L->len++;
	printf("插入成功\n");
	return 1;
}

//遍历
void list_show(LinkListPtr L)
{
	if(NULL==L||list_empty(L))
	{
		printf("遍历失败\n");
		return;
	}
	//遍历逻辑
	//定义一个遍历指针从第一个节点开始
	LinkListPtr q=L->next;
	while(q!=NULL)
	{
		//输出数据域
		printf("%c\t",q->data);
		q=q->next;//指正后移
	}
	printf("\n");
}


//尾插
int list_inser_tail(LinkListPtr L,datatype e)
{	//判断逻辑
	if(NULL==L)
	{
		printf("所给链表不合法\n");
		return 0;
	}
	//找到最后一个结点
	//	LinkListPtr q=list_search_pos(L,L->len);
	//遍历指针从头节点出发
	LinkListPtr q=L;
	//遍历找到最后一个节点
	while(q->next!=NULL)
	{
		q=q->next;
	}
	//调用函数申请节点分装数据
	LinkListPtr P=node_buy(e);
	if(NULL==P)
	{
		return 0;
	}
	//结点已经准备好,准备头插逻辑
	q->next=P;
	
	//表的变化
	L->len++;
	printf("插入成功\n");
	return 1; 

	
}


//任意插
int list_insert_post(LinkListPtr L,int pos,datatype e)
{
	if(NULL==L||pos<1||pos>L->len+1)
	{
		printf("插入失败\n");
		return 0;
	}
	//申请结点分装数据
	LinkListPtr p=node_buy(e);
	if(NULL==p)
	{
		return 0;
	}
	//找到要插入位置的前一个节点
	LinkListPtr q=list_search_pos(L,pos-1);
	//执行插入逻辑
	p->next=q->next;
	q->next=p;
	//表长变化
	L->len++;
	printf("插入成功\n");
	return 1;
}

//头删
int list_delete_head(LinkListPtr L)
{
	//判断
	if(NULL==L||list_empty(L))
	{
		printf("所给链表不合法\n");
		return 0;
	}

	//删除逻辑
	LinkListPtr q=L->next;
	L->next=q->next;
	//释放要删除的结点
	free(q);
	q=NULL;
	printf("删除成功\n");
	//表长变化
	L->len--;
	return 1;
}
//尾删
int list_delete_tail(LinkListPtr L)
{
		//判断逻辑
		if(NULL==L||list_empty(L))
	{
		printf("所给链表不合法\n");
		return 0;
	}
		//找到倒数第二个结点
		LinkListPtr q=L;
		while(q->next->next!=NULL)
		{
			q=q->next;

		}
		//删除逻辑
		free(q->next);
		q->next=NULL;
		/*LinkListPtr p=q->next;
		q->next=NULL;
		free(p);
		p=NULL;*/
		//表长变化
		L->len--;
		printf("删除成功\n");
		return 1;


}
//任意删
int list_delete_post(LinkListPtr L,int pos)
{
	//判断逻辑
		if(NULL==L||list_empty(L)||pos<1||pos>L->len)
	{
		printf("所给链表不合法\n");
		return 0;
	}

	//找到删除节点
	LinkListPtr q=list_search_pos(L,pos-1);
	LinkListPtr p=q->next;
	//孤立
	q->next=p->next;
	//释放要删除的节点
	free(p);
	p=NULL;
	//表长编号
	L->len--;
	printf("删除成功\n");
	return 1;
}
//按值查找返回节点
int list_search_value(LinkListPtr L, datatype e)
{
	if(NULL==L||list_empty(L))
	{
			printf("查找失败\n");
			return 0;
	}
/*	for(int i=1;i<L->len;i++)
	{
		//判断第i个节点跟要查找的值是否相等
			if(list_search_pos(L,i)->data==e)
		{
			return i;
		}
	}*/
	//定义遍历指针
	LinkListPtr q=L->next;
	int index=0;
	while((q=q->next)!=NULL)
	{ 	
		index++;
		if(q->data==e)
		{
			return index;
		}
	}
	
	return 0;
}
//按位置查找返回结点地址
LinkListPtr list_search_pos(LinkListPtr L,int pos)
{
	if(NULL==L||list_empty(L)||pos<0||pos>L->len)
	{
		printf("查找失败");
		return NULL;
	}
	//说明可以进行查找
	//定义遍历指针从头结点开始
	LinkListPtr q=L;
	for(int i=0;i<pos;i++,q=q->next);
	//将找到的结点返回
	return q;



}

//按位置进行修改
int list_mod(LinkListPtr L,int pos,datatype e)
{ 
	//判断逻辑
	if(NULL==L||list_empty(L))
	{
		printf("修改失败\n");
		return 0;
		
	}
	//找到要修改位置的节点
	LinkListPtr q=list_search_pos(L,pos);
	q->data=e;//修改值
	printf("修改成功！\n");
	return 1;

}
//按值进行修改
int list_mod_varle(LinkListPtr L,datatype e,datatype m)
{
	//判断逻辑
	if(NULL==L||list_empty(L))
	{
		printf("修改失败\n");
		return 0;
		
	}
	//找值
	LinkListPtr q=L->next;
	while(q->next!=NULL)
	{ 	
		q=q->next;
		if(q->data==e)
		{
			q->data=m;
		}
	}
		printf("修改完成！\n");
			return 1;

}
//链表的排序
int list_sore(LinkListPtr L,int flag)
{
	//判断逻辑
	if(NULL==L||list_empty(L))
	{
		printf("排序失败\n");
		return 0;
		
	}
	else
	{
		for(int i=1;i<L->len;i++)
		{
			for(int j=1;j<L->len;j++)
			{
				if(list_search_pos(L,j)->data>list_search_pos(L,j+1)->data)
				{
						datatype m=list_search_pos(L,j)->data;
						list_search_pos(L,j)->data=list_search_pos(L,j+1)->data;
						list_search_pos(L,j+1)->data=m;
				}
			}
		}
	}
	printf("排序完成！\n");
	return 1;
}
//递归反转
void list_reverse_dg(LinkListPtr L)
{ 	
	LinkListPtr H=L->next;
	L->next=NULL;

	if(H==NULL)
	{
		printf("反转完成\n");
		return L;
		
	}else
	{
		LinkListPtr q=H;
		H=H->next;
		d->next=NULL;
		L->next=list_reverse_dg(H);

	}
	
}

//链表的反转*
void list_reverse(LinkListPtr L)
{
	if(NULL==L||L->len<=1)
	{
		printf("查找失败\n");
		
	}
	//开始反转
	LinkListPtr H=L->next;//将链表托管
	L->next=NULL;//头结点指针域置空
	LinkListPtr p;
	while(H!=NULL)
	{
		//标记要搬运的节点
		p=H;
		H=H->next;//指向下一个节点
		//以头插的形式放入到L链表上
		p->next=L->next;
		L->next=p;

	}
	printf("反转成功\n");
	
}
//返回链表长度
int list_length(LinkListPtr L)
{
	if(NULL==L)
	{
		printf("返回失败\n");
		return -1;
	}
	//返回长度
	return L->len;

}
//链表的销毁
void list_free(LinkListPtr L)
{
	if(NULL==L)
	{
		printf("释放失败\n");
		return;
	}
	//将所有节点全部释放
	while(!list_empty(L))
	{
		list_delete_head(L);
	}
	//将头节点释放
	free(L);
	L=NULL;
	printf("释放成功\n");
}

测试文件

#include"linklist.h"

int main(int argc, const char *argv[])
{		
	//调用函数创建一个链表
	LinkListPtr L=list_create();
		if(NULL==L)
	{
		printf("创建成功\n");
		return -1;

	}
		//调用头插函数
		list_inser_head(L,'A');
		list_inser_head(L,'W');
		list_inser_head(L,'S');

		list_inser_head(L,'D');
		//尾插函数
		list_inser_tail(L,'I');
		list_inser_tail(L,'F');
		//调用任意位置插入
		list_insert_post(L,3,'G');
		//调用遍历函数
		list_show(L);
		//任意删
		list_delete_post(L,3);
		//调用遍历函数
		list_show(L);
		//头删
		list_delete_head(L);
		//调用遍历函数
		list_show(L);
		//尾删
		list_delete_tail(L);
		//调用遍历函数
		list_show(L);
		//按值查找返回位置
		printf("W的位置：%d\n",list_search_value(L,'W')+1);
		//按位置进行修改
		list_mod(L,2,'C');
		//调用函数 
		list_show(L);
		//反转
		list_reverse(L);
		list_show(L);
		//按值修改
		list_mod_varle(L,'S','M');
		list_show(L);
		//排序
		list_sore(L,1);
		list_show(L);
		printf("************************\n");
		//递归反转
		list_reverse_dg(L);
		list_show(L);

		//求长度
		printf("链表长度：%d\n",list_length(L));
		list_free(L);
			return 0;
}

思维导图