八月七日作业

最新推荐文章于 2024-10-07 19:56:58 发布

【浮生闲】

最新推荐文章于 2024-10-07 19:56:58 发布

阅读量374

点赞数

文章标签： windows

本文链接：https://blog.csdn.net/2301_77616453/article/details/132154659

版权

头文件

#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_insert_head(LinkListPtr L,datatype e);

//遍历
void list_show(LinkListPtr L);

//按位置查找返回节点
LinkListPtr list_search_pos(LinkListPtr L,int pos);

//任意位置插入
int list_insert_post(LinkListPtr L,int pos,datatype e);

//尾插
int list_insert_tail(LinkListPtr L,datatype e);

//头删
int list_delete_head(LinkListPtr L);

//尾删
int list_delete_tail(LinkListPtr L);

//任意位置删除
int list_delete_pos(LinkListPtr L,int pos);

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

//按位置进行修改
int list_updata_pos(LinkListPtr L,int pos,datatype e);

//按值进行修改
int list_updata_value(LinkListPtr L,datatype e,datatype a);

//链表的排序
void list_sort(LinkListPtr L);

//链表的反转
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;    //初始链表长度为0
	L->next=NULL; //链表上没有任何结点

	printf("创建成功\n");
	return L;
}




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

	//判断指针域的内容
	return L->next==NULL;
}




//申请结点封装数据函数
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_insert_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 ;
	}

	//遍历逻辑
	//1、定义遍历指针从第一个结点开始
	LinkListPtr q=L->next;
	while(q!=NULL)   //2、只要当前结点存在
	{
		//3、输出数据域
		printf("%c\t",q->data);

		q=q->next;    //4、指针后移
	}
	printf("\n");
}



//按位置查找返回节点
LinkListPtr list_search_pos(LinkListPtr L,int pos)
{
	//判断逻辑
	if(NULL==L||list_empty(L)||pos<0||pos>L->len)
	{
		printf("查找失败\n");
		return NULL;
	}

	//说明可以进行查找
	//定义遍历指针从头结点开始
	LinkListPtr q=L;
	for(int i=0;i<pos;i++)
	{
		q=q->next;
	}

	//将找到的结点返回
	return q;
}



//任意位置插入
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_insert_tail(LinkListPtr L,datatype e)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("插入失败\n");
		return 0;
	}

	//找到最后一个结点
	//LinkListPtr q=list_search_pos(L,L->len);　或
	
	//1、定义遍历指针从头结点出发
	LinkListPtr q=L;
	
	//2、遍历找到最后一个结点
	while(q->next!=NULL)
	{
		q=q->next;
	}

	//申请结点封装数据函数
	LinkListPtr P=node_buy(e);
	if(NULL==P)
	{
		return 0;
	}

	//尾插
	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 P=L->next;
	L->next=P->next;
	free(P);
	P==NULL;

	//表长变化
	L->len--;
	printf("头删成功\n");
	return 1;
}



//尾删
int list_delete_tail(LinkListPtr L)
{
	//判断逻辑
	if(NULL==L||list_empty(L))
	{
		printf("尾删失败\n");
		return 0;
	}
	
	//删除逻辑
	LinkListPtr q=list_search_pos(L,L->len-1);
	LinkListPtr P=q->next;
	q->next=NULL;
	free(P);
	P=NULL;

	//表长变化
	L->len--;
	printf("尾删成功\n");
	return 1;
}



//任意位置删除
int list_delete_pos(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);

	//删除逻辑
	//1、标记要删除的结点
	LinkListPtr P=q->next;
	
	//2、孤立要删除的结点
	q->next=P->next;

	//3、释放要删除的结点
	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;
		}
	}
}



//按位置进行修改
int list_updata_pos(LinkListPtr L,int pos,datatype e)
{
	//判断逻辑
	if(NULL==L||list_empty(L)||pos<1||pos>L->len)
	{
		printf("修改失败\n");
		return 0;
	}
	
	//找到需要修改结点
	LinkListPtr P=list_search_pos(L,pos);

	//开始修改
	P->data=e;
	printf("修改成功\n");
	return 1;
}



//按值进行修改
int list_updata_value(LinkListPtr L,datatype e,datatype a)
{
	if(NULL==L||list_empty(L))
	{
		printf("修改失败\n");
		return 0;
	}
	
	//找到要修改结点的位置
	int pos=list_search_value(L,e);

	//找到需要修改的结点
	LinkListPtr P=list_search_pos(L,pos);

	//开始修改
	P->data=a;
	printf("修改成功\n");
	return 1;
}



//链表的排序
void list_sort(LinkListPtr L)
{
	//判断逻辑
	if(NULL==L||list_empty(L))
	{
		printf("排序失败\n");
	}

	//开始排序
	for(int i=1;i<L->len;i++)
	{
		for(int j=1;j<=L->len-i;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");
}



//链表的反转
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;      //指向下一个结点

		//以头插的形式放入Ｌ链表上
		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");
	}

	//将所有结点全部释放
	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)
	{
		return -1;
	}
	


	//调用头插函数
	list_insert_head(L,'Q');
	list_insert_head(L,'W');
	list_insert_head(L,'E');
	list_insert_head(L,'R');



	//调用遍历函数
	list_show(L);



	//调用任意位置插入函数
	list_insert_post(L,3,'D');
	list_show(L);



	//调用尾插函数
	list_insert_tail(L,'F');
	list_insert_tail(L,'G');
	list_show(L);



	//调用头删函数
	list_delete_head(L);
	list_show(L);



	//调用尾删函数
	list_delete_tail(L);
	list_show(L);



	//调用任意位置删除函数
	list_delete_pos(L,2);
	list_show(L);



	//调用按位置进行修改函数
	list_updata_pos(L,2,'M');
	list_show(L);



	//调用按值进行修改函数
	list_updata_value(L,'M','W');
	list_show(L);



	//调用链表的排序函数
	list_sort(L);
	list_show(L);



	//调用链表的反转函数
	list_reverse(L);
	list_show(L);



	//调用返回链表的长度函数
	int n=list_length(L);
	printf("%d\n",n);



	//调用链表销毁函数
	list_free(L);
	L=NULL;



	return 0;
}

思维导图