数据结构链表

最新推荐文章于 2025-05-02 19:27:56 发布

Venusler

最新推荐文章于 2025-05-02 19:27:56 发布

阅读量28

点赞数

文章标签：数据结构链表 windows

本文链接：https://blog.youkuaiyun.com/Venusler/article/details/132156791

版权

头文件

#ifndef __LINKLIST_H__
#define __LINKLIST_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);

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

//尾删
int list_delete_tail(LinkListPtr L);

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

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

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

//链表排序
void list_paixu(LinkListPtr L);

//链表的反转
void list_reverse(LinkListPtr L);

//返回链表的长度
int list_lenght(LinkListPtr L);

//链表的销毁
int list_free(LinkListPtr L);

#endif

源文件

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#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&&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;  //指针域为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 ;
	}

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

		q=q->next;  //4、指针后移
	}
}

//按位置查找返回节点
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||list_empty(L))
	{
		printf("尾插失败\n");
		return 0;
	}
	
	//调用任意位置插入函数
	list_insert_post(L,L->len,e);
	//LinkListPtr p=node_buy(e);
	//if(NULL=p)
	//{
	//return 0;	
	//}
	//LinkListPtr q=list_search_pos(L,L->len);
	//q->next=p;
	
	//表长变化

	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
	p=NULL;

	//表长变化
	L->len--;

	printf("头删成功\n");
	return 1;
}

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

	//删除逻辑
	//1、标记要删除的节点
	LinkListPtr p=q->next;
	//2、孤立要删除的节点
	q->next=p->next;
	//3、释放要删除的节点
	free(p);
	p=NULL;
	
	//表长变化
	L->len--;
	
	printf("删除成功\n");

	return q;
}

//尾删
int list_delete_tail(LinkListPtr L)
{	
	//判断逻辑
	if(NULL==L||list_empty(L))
	{
		printf("尾删失败\n");
		return 0;
	}

	//调用任意位置删除函数
	LinkListPtr p=list_search_pos(L,L->len-1);
	free(p->next);
	p->next=NULL;

	//正常逻辑
	/*LinkListPtr p=L;
	while(p->next->next!=NULL)
	{
		p=p->next;
	}
	free(p->next);
	p->next=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;
	}

	//定义一个指针从第一个节点开始
	LinkListPtr p=L->next;
	
	//按值查找
	int k=1;
	while(p!=NULL)
	{
		if(p->data==e)
		{
			printf("查找成功\n");
			printf("对应的位置为第%d个节点\n",k);
			//return k;
		}
		p=p->next;
		k++;
	}

	/*for(int i=1;i<=L->len;i++)
	 * {
	 * 		if(list_search_pos(L,i)->data==e)
	 * 		{
	 *  		return i;
	 * 		}
	 * }*/
	return 1;
}

//按位置进行修改
int list_update_pos(LinkListPtr L,int pos,datatype e)
{
	//判断逻辑
	if(NULL==L||list_empty(L)||pos<1||pos>L->len)
	{
		printf("查找失败\n");
		return 0;
	}
	
	//修改逻辑
	LinkListPtr q=list_search_pos(L,pos);
	
	//替换节点中的值
	q->data=e;

	printf("修改成功\n");
	
	return 0;
}

//按值进行修改
int list_update_value(LinkListPtr L,datatype e,datatype f)
{
	//判断逻辑
	if(NULL==L||list_empty(L))
	{
		printf("查找失败\n");
		return 0;
	}

	//修改逻辑
	LinkListPtr q=L->next;
	for(int i=1;i<=L->len;i++)
	{
		if(e==q->data)
		{
			q->data=f;
		}
		q=q->next;
	}

	printf("修改成功\n");

	return 0;
}

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

	//排序逻辑
	LinkListPtr q=L->next;
	char temp;
	for(int i=1;i<L->len;i++)
	{
		q=L->next;  //每次进循环都是q为第一个节点
		for(int j=1;j<L->len;j++)
		{
			if(q->data-'A' > q->next->data-'A')
			{
				temp=q->data;
				q->data=q->next->data;
				q->next->data=temp;
			}
			q=q->next;
		}
	}

	printf("排序完成\n");

}
//链表的反转
void list_reverse(LinkListPtr L)
{
	//判断逻辑
	if(NULL==L||L->len<=1)
	{
		printf("反转失败\n");
		return ;
	}

	//开始反转
	LinkListPtr H=L->next;  //将链表托管
	L->next=NULL;  //头节点指针域置空

	LinkListPtr p;  //节点的搬运工
	while(H!=NULL)
	{
		//标记要搬运的节点
		p=H;
		H=H->next;   //H指向下一个节点

		//以头插的形式放到L链表上
		p->next=L->next;
		L->next=p;
	}

	printf("反转成功\n");
}

//返回链表长度
int list_lenght(LinkListPtr L)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("所给链表不合法\n");
		return -1;
	}

	//返回链表的长度
	return L->len;
}

//链表的销毁
int list_free(LinkListPtr L)
{	
	//判断逻辑
	if(NULL==L||list_empty(L))
	{
		printf("销毁失败\n");
		return 0;
	}

	//销毁过程,将全部节点释放
	while(!list_empty(L))  //L->next!=NULL
	{
		list_delete_head(L);
	}

	//释放头节点
	free(L);
	L=NULL;

	printf("释放成功\n");
}

主函数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linklist.h"
int main(int argc, const char *argv[])
{
	//调用创建函数创建一个链表
	LinkListPtr L=list_create();
	if(NULL==L)
	{
		return -1;
	}
	
	//调用头插函数
	list_insert_head(L,'O');
	list_insert_head(L,'L');
	list_insert_head(L,'L');
	list_insert_head(L,'E');
	list_insert_head(L,'H');
	putchar(10);

	//调用遍历函数
	list_show(L);
	putchar(10);
	printf("%d\n",L->len);

	//调用任意位置插入
	list_insert_post(L,2,'W');
	list_show(L);
	putchar(10);
	printf("%d\n",L->len);
	
	//调用尾插函数
	list_insert_tail(L,'A');
	list_show(L);
	putchar(10);
	printf("%d\n",L->len);

	//调用头删函数
	list_delete_head(L);
	list_show(L);
	putchar(10);
	printf("%d\n",L->len);

	//调用任意位置删除
	list_delete_post(L,5);
	list_show(L);
	putchar(10);
	printf("%d\n",L->len);

	//尾删
	list_delete_tail(L);
	list_show(L);
	putchar(10);
	printf("%d\n",L->len);
	
	//按值查找返回节点位置
	list_search_value(L,'E');
	putchar(10);

	//按位置进行修改
	list_update_pos(L,2,'B');
	list_show(L);
	putchar(10);
	printf("%d\n",L->len);		
	
	//按值进行修改
	list_update_value(L,'B','Z');
	list_show(L);
	putchar(10);
	printf("%d\n",L->len);

	//链表排序
	list_paixu(L);
	list_show(L);
	putchar(10);

	//链表的反转
	list_reverse(L);
	list_show(L);
	putchar(10);

	//返回链表的长度
	int c=list_lenght(L);
	printf("链表的长度为：%d",c);
	putchar(10);

	//链表的销毁
	list_free(L);

	return 0;
}

思维导图