链表

最新推荐文章于 2024-09-10 21:54:53 发布
最新推荐文章于 2024-09-10 21:54:53 发布
阅读量233 收藏
点赞数 2
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63641691/article/details/141904465
版权

单向链表

#ifndef _LINK_H_
#define _LINK_H_


typedef int Datatype;

#include<head.h>
typedef struct node
{
	Datatype data;
	struct node *pnext;
}Link_Node_t;


typedef struct link
{
	Link_Node_t *phead;
	int clen;
}Link_t;

extern Link_t *create_link();
extern int push_link_head(Link_t *plink,Datatype data);
extern int print_list(Link_t *plink);
extern int push_tail(Link_t *plink,Datatype data);
extern int pop_link_head(Link_t *plink) ;
extern int is_empty_list(Link_t *plink);
extern int pop_link_tail(Link_t *plink);
extern Link_Node_t * find_list_element(Link_t *plink,Datatype date);
extern void updata_list_element(Link_t *plink,Link_Node_t *q,Datatype date);
extern void delete_list(Link_t *plink);
extern Link_Node_t * find_midlist(Link_t *plink);
extern Link_Node_t * find_last_num(Link_t *plink,int num);
extern void delete_list_element(Link_t *plink,int date);
extern Link_Node_t * find_last_num_fa(Link_t *plink,int num);
extern void invert_list_element(Link_t *plink);
extern void insert_list_element(Link_t *plink);

#endif
#include"link.h"




Link_t *create_link()
{
	Link_t *plink = malloc(sizeof(Link_t));
	if(NULL == plink)
	{
		perror("fail to malloc\n");
		return NULL ;
	}

	plink->phead = NULL;
	plink->clen = 0;


	return plink;
}

//头插
int push_link_head(Link_t *plink,Datatype data)
{
	Link_Node_t *pnode = malloc(sizeof(Link_Node_t));
	if(NULL == pnode)
	{
		perror("fail malloc");
		return -1;
	}

	pnode->data = data;
	pnode->pnext =	NULL;

	pnode->pnext = plink->phead;
	plink->phead = pnode;

	plink->clen++;

	return 0;
}


//遍历
int print_list(Link_t *plink)
{
	Link_Node_t *p;
	p = plink->phead;

	while(p != NULL)
	{
		printf("data = %d\n",p->data);
		p = p->pnext;
	}

	return 0;
}

//尾插
int push_tail(Link_t *plink,Datatype data)
{

	Link_Node_t *pnode = malloc(sizeof(Link_Node_t));
	if(NULL == pnode)
	{
		perror("fail malloc");
		return -1;
	}

	pnode->data = data;
	pnode->pnext =	NULL;

	if(plink->phead == NULL)
	{
		push_link_head(plink,1);		
	}

	Link_Node_t *p;
	p = plink->phead;

	while(p->pnext != NULL)
	{
		p = p->pnext;
	}
	p->pnext = pnode;
	plink->clen++;

	return 0;
}


//头删

int pop_link_head(Link_t *plink) 
{
	if(is_empty_list(plink))
	{
		return 0;
	}
	Link_Node_t *p = plink->phead;

	plink->phead = p->pnext;
	free(p);
	plink->clen--;
	return 0;
}



//判空
int is_empty_list(Link_t *plink)
{
	if(plink->phead == NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

//尾删
int pop_link_tail(Link_t *plink)
{
	
	if(is_empty_list(plink))
	{
		return -1;

	}
	else if(plink->clen == 1)
	{
		pop_link_head(plink);
	}
	else
	{
		Link_Node_t *p = plink->phead;
		while(p->pnext->pnext != NULL)
		{
			p = p->pnext;
		}
			free(p->pnext);
			p->pnext = NULL;
			plink->clen--;

	}
	return 0;

}

//找指定节点
Link_Node_t * find_list_element(Link_t *plink,Datatype date)
{
	Link_Node_t *p = plink->phead;
	while(p->data != date)
	{
		p = p->pnext;
	}

	return p;
}


//改指定节点
void updata_list_element(Link_t *plink,Link_Node_t *q,Datatype date)
{
	Link_Node_t *p = plink->phead;

	p = q;
	p->data = date;
	
}

//删除链表
void delete_list(Link_t *plink)
{
	
	int ret = 0;
	while(pop_link_tail(plink) == 0)
	{
		
	}
	/*
	while(plink->phead != NULL)
	{
		pop_link_tail(plink);
	}*/
	free(plink);

}

//找中间节点
Link_Node_t * find_midlist(Link_t *plink)
{
	Link_Node_t *p = plink->phead;
	
	int i = plink->clen / 2;
	while(i)
	{
		p = p->pnext;
		--i;
	}
	return p;
}


//快慢指针法－－找中间节点
//Link_Node_t * find_midlist_fs(Link_t *plink)
//{

//}


//找指定倒数第几节点
Link_Node_t * find_last_num(Link_t *plink,int num)
{
	Link_Node_t *p = plink->phead;
	
	int i = plink->clen;
	i = i + 1 - num;
	if(i <= 0)
	{
		printf("链表只有%d个节点\n",plink->clen);
		return NULL;
	}
	else
	{
		while(i - 1)
		{
			p = p->pnext;
			--i;
		}
		return p;
	}

}
//快慢指针法－－找倒数节点
Link_Node_t * find_last_num_fa(Link_t *plink,int num)
{
	Link_Node_t *pfast = plink->phead;
	Link_Node_t *pslow = plink->phead;

	while(pfast->pnext != NULL)
	{
		if(num - 1 <= 0)
		{
			break;
		}
		num--;
		pfast = pfast->pnext;
	}

	while(pfast->pnext != NULL)
	{
		pfast = pfast->pnext;
		pslow = pslow->pnext;
	}
	return pslow;
}

//删除指定节点
void delete_list_element(Link_t *plink,int date)
{
	Link_Node_t *p = plink->phead;
	if(date == 8)
	{
		pop_link_head(plink);
	}
	else
	{
		while(p->pnext->data != date)
		{
			p = p->pnext;
		}
		Link_Node_t *q = plink->phead;
		q = p->pnext->pnext;
		free(p->pnext);
		p->pnext = q;
		plink->clen--;
	}
}

//链表倒置
void invert_list_element(Link_t *plink)
{
	Link_Node_t * ptemp = plink->phead;
	Link_Node_t * pinsert = plink->phead;

	plink->phead = NULL;

	while(ptemp != NULL)
	{

		ptemp = ptemp->pnext;

		pinsert->pnext = plink->phead;
		plink->phead = pinsert;

		pinsert = ptemp;
	}

}


//链表排序
void insert_list_element(Link_t *plink)
{
	Link_Node_t * ptemp = plink->phead->pnext;
	Link_Node_t *pinsert = NULL;
	Link_Node_t *p = NULL;
	
	plink->phead->pnext = NULL;
	while(ptemp != NULL)
	{
		pinsert = ptemp;
		ptemp = ptemp->pnext;

		if(pinsert->data < plink->phead->data)
		{
			pinsert->pnext = plink->phead;
			plink->phead = pinsert;
		}
		else
		{
			p = plink->phead;
			while(p->pnext != NULL && p->pnext->data < pinsert->data)
			{
				p = p->pnext;
			}
			pinsert->pnext = p->pnext;
			p->pnext = pinsert;
		}
	}

}
#include"link.h"

int main(int argc, const char *argv[])
{
	Link_t *plink = create_link();
	if (NULL == plink)
	{
		return -1;
	}
	
	push_link_head(plink, 1);
	push_link_head(plink, 9);
	push_link_head(plink, 3);
	push_link_head(plink, 11);
	push_link_head(plink, 56);
	push_link_head(plink, -1);
	push_link_head(plink, 7);
	push_link_head(plink, 77);

//	print_list(plink);

	push_tail(plink,0);	
//	print_list(plink);

//	pop_link_head(plink);

//	pop_link_tail(plink);
//
	Link_Node_t *p ;
//	p = find_list_element(plink,2);
//	updata_list_element(plink,p,10);
//	print_list(plink);
//	delete_list(plink);
	

//	p = find_midlist(plink);

//	p = find_last_num(plink,4);
//	updata_list_element(plink,p,10);
	

//	delete_list_element(plink,8);

 
//	p = find_last_num_fa(plink,9);
//	updata_list_element(plink,p,10);
//	invert_list_element(plink);
	
	insert_list_element(plink);
	print_list(plink);
	return 0;
}

双向链表

#ifndef _BOTHWAY_H_
#define _BOTHWAY_H_


#include<head.h>


typedef struct stu
{
	int id;
	char name[20];
	double score;
}DataType;

typedef struct dnode
{
	DataType data;
	struct dnode *ppre;
	struct dnode *pnext;
}DLink_Node_t;

typedef struct dlink
{
	DLink_Node_t *phead;
	int clen;
	pthread_mutex_t mutex;
}DLink_t;


extern DLink_t * create_doulink(void);
extern int is_empty_bothway(DLink_t *pdoulink);
extern int  push_doulink_head(DLink_t *pdoulink,DataType data);
extern void print_bothway_list(DLink_t *pdoulink,int dir);
extern int push_doulink_tail(DLink_t *pdoulink,DataType data);
extern void delete_doulink_head(DLink_t *pdoulink);
extern void delete_doulink_tail(DLink_t *pdoulink);
extern DLink_Node_t *find_doulink_element(DLink_t *pdoulink,char *name);
extern void updata_doulink_element(DLink_t *pdoulink,char *name,double score);
extern void destory_doulist(DLink_t *pdoulink);




#endif
#include"bothway.h"


//创建头

DLink_t * create_doulink(void)
{
	DLink_t *pdoulink = malloc(sizeof(DLink_t));
	if(pdoulink == NULL)
	{
		perror("fail to malloc\n");
		return NULL;
	}

	pdoulink->phead = NULL;
	pdoulink->clen = 0;
	pthread_mutex_init(&(pdoulink->mutex),NULL);

	return pdoulink;
}


//判空列表
int is_empty_bothway(DLink_t *pdoulink)
{
	return NULL == pdoulink->phead;
}


//头插

int  push_doulink_head(DLink_t *pdoulink,DataType data)
{
	DLink_Node_t *pnode = malloc(sizeof(DLink_Node_t));
	if(pnode == NULL)
	{
		perror("fail to malloc_node");
		return -1;
	}
	pnode->data = data;
	pnode->ppre = NULL;
	pnode->pnext = NULL;

	if(is_empty_bothway(pdoulink))
	{
		pdoulink->phead = pnode;
	}
	else
	{
		pnode->pnext = pdoulink->phead;
		pdoulink->phead->ppre = pnode;
		pdoulink->phead = pnode;
	}
	pdoulink->clen++;

	return 0;
}


//遍历
void print_bothway_list(DLink_t *pdoulink,int dir)
{
	if(is_empty_bothway(pdoulink))
	{
		return ;
	}
	

	DLink_Node_t *p = pdoulink->phead;

	if(pdoulink->clen == 1)
	{
		printf("%2d  %s  %f\n",p->data.id,p->data.name,p->data.score);

	}
	else if(dir)
	{
		while(p != NULL)
		{
			printf("%2d  %s  %f\n",p->data.id,p->data.name,p->data.score);
			p = p->pnext;
		}
	}
		else
		{
			while(p->pnext != NULL)
			{
				p = p->pnext;
			}
			while(p != NULL)
			{
				printf("%2d  %s  %f\n",p->data.id,p->data.name,p->data.score);
				p = p->ppre;

			}
	}

}




//尾增
int push_doulink_tail(DLink_t *pdoulink,DataType data)
{
	DLink_Node_t *pnode = malloc(sizeof(DLink_Node_t));
	if(pnode == NULL)
	{
		perror("fail to malloc_node");
		return -1;
	}
	pnode->data = data;
	pnode->ppre = NULL;
	pnode->pnext = NULL;

	DLink_Node_t *p = pdoulink->phead;
	while(p->pnext != NULL)
	{
		p = p->pnext;
	}
	p->pnext = pnode;
	pnode->ppre = p;
	pdoulink->clen++;
	return 0;
}

//头删
void delete_doulink_head(DLink_t *pdoulink)
{
	DLink_Node_t *p = pdoulink->phead;
	
	if(is_empty_bothway(pdoulink))
	{
		return ;
	}
	if(pdoulink->clen == 1)
	{
		pdoulink->phead = p->pnext;
		free(p);
		pdoulink->clen--;
	}
	else
	{
		pdoulink->phead = p->pnext;
		p->pnext->ppre = NULL;
		pdoulink->clen--;
		free(p);
	}
}

//尾删
void delete_doulink_tail(DLink_t *pdoulink)
{
	if(is_empty_bothway(pdoulink))
	{
		return ;
	}
	else if(pdoulink->clen == 1)
	{
		delete_doulink_head(pdoulink);
		return ;
	}
	else
	{
		DLink_Node_t *p = pdoulink->phead;

		while(p->pnext->pnext != NULL)
		{
			p = p->pnext;
		}
		p->pnext = NULL;
		pdoulink->clen--;
		free(p->pnext);
	}

}



//查找
DLink_Node_t *find_doulink_element(DLink_t *pdoulink,char *name)
{
	DLink_Node_t *p = pdoulink->phead;

	while(p != NULL)
	{
		if(strcmp(p->data.name,name) == 0)
		{
			return p;
		}
			p = p->pnext;
	}
	return NULL;
}


//更新分数
void updata_doulink_element(DLink_t *pdoulink,char *name,double score)
{
	DLink_Node_t *p = pdoulink->phead;

	while(p != NULL)
	{
		if(strcmp(p->data.name,name) == 0)
		{
			p->data.score = score;
		}
			p = p->pnext;
	}

}


//销毁
void destory_doulist(DLink_t *pdoulink)
{
	if(is_empty_bothway(pdoulink))
	{
		return ;
	}
	while(pdoulink->clen > 0)
	{
		delete_doulink_head(pdoulink);
	}
	free(pdoulink);
}

总结：

        找节点时有两种情况

        while（p != NULL） 或    while( p -> pnext != NULL)

        {                                        {

                p = p->pnext;                 p = p->pnext;

        }                                          }

情况1时出循环就不能操作了,出循环p就指向空了，循环内可以找到最后一个节点

情况2时出循环才能指向最后一个节点，再进行操作

陈愿fs
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
关于链表，看这一篇就够了！（新手入门）
m0_52532896的博客
04-20 7万+
将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过来说，指针中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。
07丨链表（下）：如何轻松写出正确的链表代码？1
08-03
【链表】是一种重要的数据结构，它不像数组那样在内存中连续存储，而是通过节点间的指针连接起来。链表的每个节点包含数据和指向下一个节点的指针，这种结构使得链表在插入和删除操作上相比数组更具优势，但同时也...
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 17万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
C++ 链表
m0_62175410的博客
07-26 3万+
C++链表笔记
C语言—链表
weixin_73588765的博客
01-01 1万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
C语言——链表
m0_62386635的博客
11-20 2万+
C语言——链表 链表是一种基础的数据结构类型，一种能够动态维护数据的线性数据表。链表的数据以结点形式存储信息，并通过结点之间的指针实现结点之间的衔接。 为什么要用链表？ 链表和数组类似，但是功能比数组强大得多，数组的空间是固定的，在定义数组的时候，数组的大小已经被固定，在使用时有可能会造成空间的浪费或者面临空间不够的风险，而链表的空间是动态的，则避免了这一问题。 我们来看最基础的单向链表： 1.首先要定义结构体作为链表的结点： typedef struct node { int data; struct
C语言链表详解附实例
xiaoxiaodawei的博客
03-11 2万+
链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。链表和数组比较，不用事先确定存储空间，而是根据需要开辟内存单元。本文章实现了用C语言编写学生管理系统，可以实现添加、删除、增加..,等功能
javascript链表
weixin_46224014的博客
11-06 8678
1.什么是链表？ 链表是多个元素组成的列表 元素存储不连续，用next指针连接到一起 JS中没有链表，但是可以用Object模拟链表 2.常用操作 新增节点 append 删除节点 remove 插入节点 insert 输出节点 索引 indexOf ...
链表的基本操作
weixin_61702071的博客
04-30 3562
链表 单链表 一、单链表的定义 链表是一种常见的采用动态存储分配方式的数据结构，它是一种物理存储单元上非连续，非顺序的存储结构。n个结点连成一个链表，即为链表的链式存储结构，如果在链表中，每个结点都只有一个指针，所有的结点都是单线联系，除了末尾结点指针为空外，每个结点的指针都指向下一个结点，一环扣一环形成一条线性链，称此链表为单向线性链表或简称单链表。 二、单链表的基本操作 1.单链表的创建 单链表的建立就是在程序的运行过程中，从无到有的建立一个链表，即一个一个分配结点的内存空间，然后输入结点中的数据，并建
尾插法建立链表详解
qq_40741513的博客
07-10 4万+
尾插法，顾名思义，就是把新加入的节点插入到上一个节点的尾部（头插法是把新加入的节点插入到上一个节点的头部），next存储下一个节点位置的地址，开始时，初始化定义头节点 head -> next = NULL; 表示头节点的下一个节点为空，就是该链表只有一个头节点，图形化表示为 由于头插法要把每一个新加入的节点插入到上一个节点的尾部，所以需要定义一个指针，记录每次插入变换后的最后一个节点的指针域信息 r = head; 将头节点赋值给r,r记录每次插入变换后尾部的信息 申请一个节点
链表填空题（打印）1
08-08
【链表基础知识】 链表是一种线性数据结构，与数组不同，它不连续存储数据，而是通过节点间的指针连接。每个节点包含数据部分和一个指向下一个节点的指针。链表分为单向链表、双向链表和循环链表等类型。 1. **...
Python单向链表和双向链表原理与用法实例详解
09-20
链表是一种重要的数据结构，它不同于数组，不连续存储元素，而是通过节点之间的引用关系连接。在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只...
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
【数据结构】——1.1树
qq_43507078的博客
09-07 971
树，二叉树
数据结构10
最新发布
m0_52024881的博客
09-10 301
假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点(k为正整数)。若查找成功，算法输出该结点的data域的值，并返回1;（3）根据设计思想和实现步骤，采用程序设计语言描述算法(使用C、C++或Java语言实现)，关键之处请给出简要注释。这里需要注意一下递归出现的位置。（1）描述算法的基本设计思想。（2）描述算法的详细实现步骤。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 642
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
栈—数据结构
weixin_63722559的博客
09-06 1033
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
Java-数据结构-栈和队列-Stack和Queue (oﾟ▽ﾟ)o
2303_80388948的博客
09-07 842
栈：是一种特殊的线性表，其 只允需在固定的一端进行插入和删除操作。 进行插入和删除的一端叫做栈顶，另一端叫做栈底。并且要遵循 先进后出 的规则。 队列：是一种只允许一端进行插入元素，在另一端进行删除元素的特殊的线性表。 队列具有 先进先出 的性质：进行插入的一端叫做队尾，进行删除的一端叫做队头。也就是队尾进，队头出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值