C语言双链表

已于 2023-06-25 16:58:21 修改
阅读量205 收藏 1
点赞数 3
文章标签： c语言 c++ 算法
于 2022-11-03 21:52:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63048425/article/details/125171296
版权

学完双链表后写的，欢迎各位读者纠错。

双链表的定义

typedef struct Lnode
{
	int data;
	struct Lnode* next;
	struct Lnode* pre;
}Lnode, * pLnode;
typedef struct Linklist
{
	int len;
	pLnode head;
}Linklist, * pLinklist;

我把申请空间写成了一个函数以后再用的时候就不用再写这句话了，直接调用这个函数就行了。

pLnode makenode()
{
	pLnode s = (pLnode)malloc(sizeof(Lnode));
	if (!s)exit(-1);
	return s;
}

然后初始化链表

void Initlist(pLinklist L)
{
	pLnode p = makenode();
	p->next = NULL;
	p->pre = NULL;
	L->head = p;
	L->len = 0;
}

头插法

void pushhead(pLinklist L, int e)
{
	assert(L != NULL);
	pLnode p = makenode();
	if (L->len == 0)
	{
		p->data = e;
		p->next = L->head->next;
		p->pre = L->head;
		L->head->next = p;
		L->len++;
	}
	else
	{
		p->data = e;
		p->pre = L->head;
		p->next = L->head->next;
		L->head->next->pre = p;
		L->head->next = p;
		L->len++;
	}
}

尾插法

void pushback(pLinklist L, int e)
{
	assert(L != NULL);
	pLnode p = makenode();
	pLnode s = makenode();
	s = L->head;
	while (s->next != NULL)
	{
		s = s->next;
	}
	p->data = e;
	p->next = NULL;
	p->pre = s;
	s->next = p;
	L->len++;
}

头删法

void delhead(pLinklist L)
{
	assert(L != NULL);
	if (L->head->next->next == NULL)
	{
		free(L->head->next);
		L->head->next = NULL;
		L->len--;
	}
	else
	{
		L->head->next = L->head->next->next;
		L->head->next->pre = L->head;
		L->len--;
	}
}

尾删法

void delback(pLinklist L)
{
	assert(L != NULL);
	pLnode p ;
	p = L->head;
	while (p->next != NULL)
	{
		p = p->next;
	}
	p->pre->next = NULL;
	L->len--;
	free(p);
	p = NULL;
}

交换两个数据的值

void exchange(pLinklist L, int s1,int s2)
{
	assert(L != NULL);
	pLnode p ;
	pLnode s ;
	p = L->head->next;
	s = L->head->next;
	for (int i = 0; i < s1-1; i++)
	{
		p = p->next;
	}
	for (int i = 0; i < s2-1; i++)
	{
		s = s->next;
	}
	int e;
	e = p->data;
	p->data = s->data;
	s->data = e;
}

排序

pLinklist sort(pLinklist L)
{
	assert(L != NULL);
	pLnode p ;
	int s=0;
	for (int i = 0; i < (L->len) - 1; i++)
	{
		p = L->head->next;
		for (int j = 0; j < (L->len) - 1; j++)
		{
			if (p->data > p->next->data)
			{
				s = p->data;
				p->data = p->next->data;
				p->next->data = s;
			}
			p = p->next;
		}
	}
	return L;
}

打印到屏幕上

void show(pLinklist L)
{
	assert(L != NULL);
	pLnode p ;
	p = L->head->next;
	while (p)
	{
		if (p->next == NULL)
		{
			printf("%d\n", p->data);
		}
		else {
			printf("%d->", p->data);
		}
		p = p->next;
	}
}

输入

void input(pLinklist L)
{
	assert(L != NULL);
	int s, e;
	scanf("%d", &s);
	for (int i = 0; i < s; i++)
	{
		scanf("%d", &e);
		pushback(L, e);
	}
}

清空链表

void clearlist(pLinklist L)
{
	assert(L != NULL);
	pLnode p;
	p = L->head->next;
	while (p->next != NULL)
	{
		p = p->next;
	}
	while (p != L->head)
	{
		p = p->pre;
		free(p->next);
		p->next = NULL;
		L->len--;
	}
}

销毁链表

void Destorylist(pLinklist L)
{
	assert(L != NULL);
	clearlist(L);
	free(L->head);
	L->head = NULL;
}

主函数

int main()
{
	Linklist L;
	Initlist(&L);
	input(&L);
	show(&L);
	delback(&L);
	sort(&L);
	show(&L);
	exchange(&L, 1, 4);
	show(&L);
	clearlist(&L);
	Destorylist(&L);
	return 0;
}

整体代码

#include<assert.h>
#include<stdio.h>
#include<stdlib.h>
typedef struct Lnode
{
	int data;
	struct Lnode* next;
	struct Lnode* pre;
}Lnode, * pLnode;
typedef struct Linklist
{
	int len;
	pLnode head;
}Linklist, * pLinklist;
pLnode makenode()
{
	pLnode s = (pLnode)malloc(sizeof(Lnode));
	if (!s)exit(-1);
	return s;
}
void Initlist(pLinklist L)
{
	pLnode p = makenode();
	p->next = NULL;
	p->pre = NULL;
	L->head = p;
	L->len = 0;
}
void pushhead(pLinklist L, int e)
{
	assert(L != NULL);
	pLnode p = makenode();
	if (L->len == 0)
	{
		p->data = e;
		p->next = L->head->next;
		p->pre = L->head;
		L->head->next = p;
		L->len++;
	}
	else
	{
		p->data = e;
		p->pre = L->head;
		p->next = L->head->next;
		L->head->next->pre = p;
		L->head->next = p;
		L->len++;
	}
}
void pushback(pLinklist L, int e)
{
	assert(L != NULL);
	pLnode p = makenode();
	pLnode s = makenode();
	s = L->head;
	while (s->next != NULL)
	{
		s = s->next;
	}
	p->data = e;
	p->next = NULL;
	p->pre = s;
	s->next = p;
	L->len++;
}
void delhead(pLinklist L)
{
	assert(L != NULL);
	if (L->head->next->next == NULL)
	{
		free(L->head->next);
		L->head->next = NULL;
		L->len--;
	}
	else
	{
		L->head->next = L->head->next->next;
		L->head->next->pre = L->head;
		L->len--;
	}
}
void delback(pLinklist L)
{
	assert(L != NULL);
	pLnode p ;
	p = L->head;
	while (p->next != NULL)
	{
		p = p->next;
	}
	p->pre->next = NULL;
	L->len--;
	free(p);
	p = NULL;
}
void exchange(pLinklist L, int s1,int s2)
{
	assert(L != NULL);
	pLnode p ;
	pLnode s ;
	p = L->head->next;
	s = L->head->next;
	for (int i = 0; i < s1-1; i++)
	{
		p = p->next;
	}
	for (int i = 0; i < s2-1; i++)
	{
		s = s->next;
	}
	int e;
	e = p->data;
	p->data = s->data;
	s->data = e;
}
pLinklist sort(pLinklist L)
{
	assert(L != NULL);
	pLnode p ;
	int s=0;
	for (int i = 0; i < (L->len) - 1; i++)
	{
		p = L->head->next;
		for (int j = 0; j < (L->len) - 1; j++)
		{
			if (p->data > p->next->data)
			{
				s = p->data;
				p->data = p->next->data;
				p->next->data = s;
			}
			p = p->next;
		}
	}
	return L;
}
void show(pLinklist L)
{
	assert(L != NULL);
	pLnode p ;
	p = L->head->next;
	while (p)
	{
		if (p->next == NULL)
		{
			printf("%d\n", p->data);
		}
		else {
			printf("%d->", p->data);
		}
		p = p->next;
	}
}
void input(pLinklist L)
{
	assert(L != NULL);
	int s, e;
	scanf("%d", &s);
	for (int i = 0; i < s; i++)
	{
		scanf("%d", &e);
		pushback(L, e);
	}
}
void clearlist(pLinklist L)
{
	assert(L != NULL);
	pLnode p;
	p = L->head->next;
	while (p != NULL)
	{
		pLnode n;
		n = p->next;
		free(p);
		p = n;
	}
	L->head->next = NULL;
}
void Destorylist(pLinklist L)
{
	assert(L != NULL);
	clearlist(L);
	free(L->head);
	L->head = NULL;
}
int main()
{
	Linklist L;
	Initlist(&L);
	input(&L);
	show(&L);
	delback(&L);
	sort(&L);
	show(&L);
	exchange(&L, 1, 4);
	show(&L);
	clearlist(&L);
	Destorylist(&L);
	return 0;
}

十八岁没有梦想
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言的双链表
04-01
二.内核链表 内核链表是一种链表，Linux内核中的链表都是用这种形式实现的 1.特性 内核链表是一种双向循环链表，内核链表的节点节点结构中只有指针域 使用内核链表的时候，将内核链表作为一个成员放入到一个结构体中使用 我们在链表中找到内核链表结构的地址，通过这个地址就可以找到外部大结构体的地址，通过大结构体就可以访问其中的成员 优势： 内核链表突破了保存数据的限制，可以用内核链表来保存任何数据(使用一种链表表示各种类型的数据，通用性很强) 内核链表中只有指针域，维护起来更加方便，效率更高 2.使用 内核链表在内核中已经被实现，我们只需要调用其接口直接使用即可 内核链表的实现代码在内核源代码的list.h文件中 3.源代码分析 （1）节点结构： struct list_head { struct list_head *next, *prev;//前置指针 后置指针 }; （2）初始化 #define INIT_LIST_HEAD(ptr) do { \ (ptr)->next = (ptr); (ptr)->prev = (ptr); \ } while (0) （3）插入 //从头部插入 static inline void list_add(struct list_head *new, struct list_head *head)//传入要插入的节点和要插入的链表 { __list_add(new, head, head->next); } //从尾部插入 static inline void list_add_tail(struct list_head *new, struct list_head *head) { __list_add(new, head->prev, head); } （4）通过节点找到外部结构体的地址 //返回外部结构体的地址，第一个参数是节点地址，第二个参数是外部结构体的类型名，第三个参数是节点在外部结构体中的成员名 #define list_entry(ptr, type, member) ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) （5）遍历内核链表 //遍历内核链表 #define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); \ pos = pos->next) //安全遍历内核链表 #define list_for_each_safe(pos, n, head) \ for (pos = (head)->next, n = pos->next; pos != (head); \ pos = n, n = pos->next) C语言的双链表，可以增加。插入，删除，修改，销毁等函数接口。
C语言双向链表
anyi365416的专栏
01-17 92
　　今天写了点双向链表的各种操作，写插入的时候费了点时间，不过，现在看来还是值得耗费那点时间去写的，这种小东西应该能信手拈来才行啊。 1 /*双向链表*/ 2 #include <stdio.h> 3 #include <string.h> /*strcmp(const char *,const char *) return 0 is ...
C语言：双链表
最新发布
2301_81214535的博客
06-09 1059
让我们一起在编程的道路上不断前行，创造更加美好的未来！
C语言-双向链表
qq_64831425的博客
02-25 975
C语言-双链表
c语言双向链表
weixin_34194087的博客
09-14 62
typedef int ElemType;typedef struct _Node{ElemType value;struct _Node* pnext;struct _Node* prev;}node, *pNode;//创建双向链表pNode Create_Double_List(int count){pNode pn = NULL;pNode pb = NULL;pNo...
C语言双向链表实现根据使用频率安排元素位置的功能实例代码
12-31
C语言双向链表应用 前言： 平时使用音乐播放器时，播放列表中的歌曲可以很方便地进行增添，删除，去重等操作。但其本质都可以抽象成一个双向链表。为了更方便用户的使用，我认为还可以增加一个将最常播放的音乐放在...
C语言 双向链表操作，普通双向和循环双向
09-23
C语言双向链表操作 C语言双向链表操作是指在C语言中使用结构体来实现双向链表的操作，包括创建、销毁、查找、删除和插入操作。双向链表是一种数据结构，其中每个节点都可以向前和向后进行遍历。在C语言中，可以...
C语言双向链表的表示与实现实例详解
09-04
双向链表，又称为双链表，是数据结构中的一种线性表，它在链表的基础上增加了指向前后节点的指针，使得每个节点不仅可以向前遍历，还可以向后遍历。在C语言中，双向链表的实现涉及到节点结构的定义、链表的初始化、...
C语言实现双链表
qq_59183443的博客
07-28 444
代码】C语言实现双链表。
c语言双链表
qq_40738945的博客
03-05 137
typedef int elemtype; typedef struct Dlink { elemtype data; Dlink *prev; Dlink *next; }Dlink; typedef struct{ int cursize; Dlink *head; }Dlinklist; 下面是 #include"Double_link.h"//循环链表一定要有头节点，并且循环链...
C语言_双链表
Shimmer626的博客
10-03 183
双链表 基操！ 最近博主在学习数据结构，在双链表的创建卡了壳，博主所看的书籍上也没有关于双链表创建的操作，于是乎，网上浏览资料，但大神写的代码，实非博主菜鸟之辈所能轻易看懂，于是在请教之后，博主终于学会了双链表之基操，博主个人感觉比较适合初学者。博主不才，代码献上： #include<stdio.h> #include<stdlib.h> #include<strin......
双向链表（C语言）
17的博客
10-07 811
双向链表
C语言之双向链表
刘同学的博客
06-13 480
双向链表主要是为了克服单线链表的缺点：无法通过后面的节点找到前面的节点。 双向链表的定义： typedef struct student { //数据域 int num; int score; char name[20];//数据域 //指针域 struct student *next;//后继节点指针域 struct student *front;//前驱节点指针域 }STU; 双向...
c语言双向链表的代码
09-12
C语言双向链表的代码如下： ```c #include #include // 定义双向链表节点结构体 typedef struct Node { int data; // 数据域 struct Node* prev; // 指向前一个节点的指针 struct Node* next; // 指向后一个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值