嵌入式C语言入门——循环链表、双链表、循环双链表

最新推荐文章于 2024-08-25 13:44:16 发布
最新推荐文章于 2024-08-25 13:44:16 发布
阅读量1.1k 收藏 41
点赞数 16
分类专栏： 心得总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35599308/article/details/84948236
版权

循环链表、双链表、循环双链表

循环链表

  • 循环链表最后一个结点node->next重新指向头结点ls->head
  • 在单向链表的基础上将所有NULL的判断改写成是否为头结点

循环链表的创建

  1. 链表没有结点的时候,头结点指向自身
    ls->head->next = ls->head;
List *CreateList()
{
	List *ls = (List*)malloc(sizeof(List)/sizeof(char));
	if (NULL == ls)
		return NULL;
	
	// 创建头结点
	ls->head = (Node*)malloc(sizeof(Node)/sizeof(char));
	if(NULL == ls->head)
	{
		free(ls);
		return NULL;
	}
	
	ls->head->next = ls->head;   // 空链表
	
	return ls;
}

循环链表的头插

BOOL Insert_Head(List *ls, Data data)
{
	if (NULL == ls)
		return ERROR;
	
	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
	if (NULL == node)
		return ERROR;
	
	node->data = data;
	node->next = ls->head->next;
	ls->head->next = node;
	
	return TRUE;
}

循环链表的尾插


BOOL Insert_Last(List *ls, Data data)
{
	if (NULL == ls)
		return ERROR;
	
	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
	if (NULL == node)
		return ERROR;
	
	node->data = data;
	node->next = ls->head;
	
	Node *tmp = ls->head;         // 头结点
	while (tmp->next != ls->head)
	{
		tmp = tmp->next;
	}
	
	tmp->next = node;
	
	return TRUE;
}

循环链表的任意位置插入

BOOL Insert_Pos(List *ls, int pos, Data data)
{
	if(NULL == ls|| pos<1)
		return ERROR;
	
	Node *tmp = ls->head;
	int i;
	for (i = 0; i<pos-1; i++)
	{
		tmp = tmp->next;
		if (tmp == ls->head)  // 越界
		{
			printf ("长度越界: %d\n", pos);
			return ERROR;
		}
	}
	
	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
	if (NULL == node)
		return ERROR;
	
	node->data = data;
	node->next = tmp->next; 		
	tmp->next  = node;
	
				
	return TRUE;
}

循环链表按位置删除

BOOL Delete_Pos(List *ls, int pos)
{
	if(NULL == ls|| pos<1)
		return ERROR;
	
	Node *tmp = ls->head;
	int i;
	for (i = 0; i<pos-1; i++)
	{
		tmp = tmp->next;
		if (tmp == ls->head || tmp->next == ls->head)  // 越界
		{
			printf ("长度越界: %d\n", pos);
			return ERROR;
		}
	}
	
	Node *p = tmp->next;
	tmp->next = p->next;
	free(p);
				
	return TRUE;
}

循环链表的逆序

BOOL Reverse(List *ls)
{
	// NULL ==ls || NULL == ls->head    链表不存在
	// NULL == ls->head->next           空链表
	// NULL == ls->head->next->next     只有一个结点的链表
	if (NULL == ls || NULL == ls->head || ls->head == ls->head->next || ls->head == ls->head->next->next)
		return ERROR;
	
	Node *pre = ls->head->next;    // 第一个结点
	Node *cur = pre->next;         // 第二个结点
	Node *tmp;                     // 保存当前结点的下一个结点
	
	while (cur != ls->head)
	{
		tmp = cur->next;
		cur->next = pre;
		
		pre = cur;
		cur = tmp;
	}
	
	ls->head->next->next = ls->head;	//将原来第一个结点的指针域指向NULL
	ls->head->next = pre;				//将头结点的next指向最后一个元素
	
	return TRUE;
}

循环链表的销毁

void Destroy(List *ls)
{
	if (NULL == ls)
		return;
	
	Node *tmp = ls->head;
	while (tmp->next != ls->head)
	{
		Node *p = tmp->next;
		tmp->next = p->next;
		free(p);
	}
	
	free(ls->head);
	free(ls);
}

双链表

双链表有指针域有两个指针,一个指向下一个结点,一个指向前一个结点

双链表的创建

vList *CreateList()
{
	List *ls = (List*)malloc(sizeof(List)/sizeof(char));
	if (NULL == ls)
		return NULL;
	
	// 创建头结点
	ls->head = (Node*)malloc(sizeof(Node)/sizeof(char));
	if(NULL == ls->head)
	{
		free(ls);
		return NULL;
	}
	
	ls->head->next = NULL;   // 空链表
	ls->head->pre  = NULL;     //包含两个指针
	
	return ls;
}

双链表的头插

BOOL Insert_Head(List *ls, Data data)
{
	if (NULL == ls)
		return ERROR;
	
	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
	if (NULL == node)
		return ERROR;
	
	node->data = data;

	node->next = ls->head->next;
	ls->head->next = node;
	node->pre = ls->head;
	if (NULL != node->next)
	node->next->pre = node;
	
	return TRUE;
}

双链表的尾插

BOOL Insert_Last(List *ls, Data data)
{
	if (NULL == ls)
		return ERROR;
	
	
	Node *tmp = ls->head;         // 头结点
	while (tmp->next)
	{
		tmp = tmp->next;
	}
	
	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
	if (NULL == node)
		return ERROR;
	
	node->data = data;

	node->next = NULL;
	tmp->next = node;
	node->pre = tmp;
	
	return TRUE;
}

双链表按任意位置插

BOOL Insert_Pos(List *ls, int pos, Data data)
{
	if(NULL == ls|| pos<1)
		return ERROR;
	
	Node *tmp = ls->head;
	int i;
	for (i = 0; i<pos-1; i++)
	{
		tmp = tmp->next;
		if (tmp == NULL)  // 越界
		{
			printf ("长度越界: %d\n", pos);
			return ERROR;
		}
	}
	
	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
	if (NULL == node)
		return ERROR;
	
	node->data = data;


	node->next = tmp->next; 		
	tmp->next  = node;
	if (node->next != NULL)
		node->next->pre = node;
	
				
	return TRUE;
}

双链表按位置删除

BOOL Delete_Pos(List *ls, int pos)
{
	if(NULL == ls|| pos<1)
		return ERROR;
	
	Node *tmp = ls->head;
	int i;
	for (i = 0; i<pos-1; i++)
	{
		tmp = tmp->next;
		if (tmp == NULL || tmp->next == NULL)  // 越界
		{
			printf ("长度越界: %d\n", pos);
			return ERROR;
		}
	}
	
	Node *p = tmp->next;
	tmp->next = p->next;

	if (NULL != p->next)
		p->next->pre = tmp;
	free(p);
				
	return TRUE;
}

双链表的逆序

BOOL Reverse(List *ls)
{
	// NULL ==ls || NULL == ls->head    链表不存在
	// NULL == ls->head->next           空链表
	// NULL == ls->head->next->next     只有一个结点的链表
	if (NULL == ls || NULL == ls->head || NULL == ls->head->next || NULL == ls->head->next->next)
		return ERROR;
	
/*	Node *pre = ls->head->next;    // 第一个结点
	Node *cur = pre->next;         // 第二个结点
	Node *tmp;                     // 保存当前结点的下一个结点
	
	while (cur)
	{
		tmp = cur->next;
		cur->next = pre;
		
		pre = cur;
		cur = tmp;
	}
	
	ls->head->next->next = NULL;	//将原来第一个结点的指针域指向NULL
	ls->head->next = pre;			//将头结点的next指向最后一个元素*/

	Node *cur = ls->head->next;
	while(cur->next)//最后结点不交换
	{
		Node *tmp = cur->next;	//保存cur的next指针
		cur->next = cur->pre;	//next和pre交换
		cur->pre = tmp;			
		cur = tmp;				//移动

	}
	
	ls->head->next->next = NULL;//第一个元素nextNULL
	ls->head->next = cur;
	cur->next = cur->pre;	//手动交换
	cur->pre = ls->head;

	return TRUE;
}

双链表的销毁

void Destroy(List *ls)
{
	if (NULL == ls)
		return;
	
	Node *tmp = ls->head;
	while (tmp->next)
	{
		Node *p = tmp->next;
		tmp->next = p->next;
		free(p);
	}
	
	free(ls->head);
	free(ls);
}

双向循环链表

双向循环链表在双链表的基础上,将最后一个结点的尾指针重新指向头结点

双向循环链表的创建

List *ls = (List*)malloc(sizeof(List)/sizeof(char));
	if (NULL == ls)
		return NULL;
	
	// 创建头结点
	ls->head = (Node*)malloc(sizeof(Node)/sizeof(char));
	if(NULL == ls->head)
	{
		free(ls);
		return NULL;
	}
	
	ls->head->next = ls->head;   // 空链表
	ls->head->pre  = ls->head;
	
	return ls;

双向循环链表的头插

	if (NULL == ls)
		return ERROR;
	
	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
	if (NULL == node)
		return ERROR;
	
	node->data = data;

	node->next = ls->head->next;
	ls->head->next = node;
	node->pre = ls->head;
	node->next->pre = node;
	
	return TRUE;

双向循环链表的尾插

BOOL Insert_Last(List *ls, Data data)
{
	if (NULL == ls)
		return ERROR;
	
	
	Node *tmp = ls->head;         // 头结点
	while (tmp->next != ls->head)
	{
		tmp = tmp->next;
	}
	
	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
	if (NULL == node)
		return ERROR;
	
	node->data = data;

	node->next = ls->head;
	tmp->next = node;
	node->pre = tmp;
	ls->head->pre = node;
	
	return TRUE;
}

双向循环链表的按任意位置插

BOOL Insert_Pos(List *ls, int pos, Data data)
{
	if(NULL == ls|| pos<1)
		return ERROR;
	
	Node *tmp = ls->head;
	int i;
	for (i = 0; i<pos-1; i++)
	{
		tmp = tmp->next;
		if (tmp == ls->head)  // 越界
		{
			printf ("长度越界: %d\n", pos);
			return ERROR;
		}
	}
	
	Node *node = (Node *)malloc(sizeof(Node)/sizeof(char));
	if (NULL == node)
		return ERROR;
	
	node->data = data;


	node->next = tmp->next; 		
	tmp->next  = node;
	node->next->pre = node;
	
				
	return TRUE;
}

双向循环链表的按任意位置删除

BOOL Delete_Pos(List *ls, int pos)
{
	if(NULL == ls|| pos<1)
		return ERROR;
	
	Node *tmp = ls->head;
	int i;
	for (i = 0; i<pos-1; i++)
	{
		tmp = tmp->next;
		if (tmp == NULL || tmp->next == NULL)  // 越界
		{
			printf ("长度越界: %d\n", pos);
			return ERROR;
		}
	}
	
	Node *p = tmp->next;
	tmp->next = p->next;

	if (NULL != p->next)
		p->next->pre = tmp;
	free(p);
				
	return TRUE;
}

双向循环链表的逆序

BOOL Reverse(List *ls)
{
	// NULL ==ls || NULL == ls->head    链表不存在
	// NULL == ls->head->next           空链表
	// NULL == ls->head->next->next     只有一个结点的链表
	if (NULL == ls || NULL == ls->head || NULL == ls->head->next || NULL == ls->head->next->next)
		return ERROR;
	
/*	Node *pre = ls->head->next;    // 第一个结点
	Node *cur = pre->next;         // 第二个结点
	Node *tmp;                     // 保存当前结点的下一个结点
	
	while (cur)
	{
		tmp = cur->next;
		cur->next = pre;
		
		pre = cur;
		cur = tmp;
	}
	
	ls->head->next->next = NULL;	//将原来第一个结点的指针域指向NULL
	ls->head->next = pre;			//将头结点的next指向最后一个元素*/

	Node *cur = ls->head->next;
	while(cur->next != ls->head)
	{
		Node *tmp = cur->next;	//保存cur的next指针
		cur->next = cur->pre;	//next和pre交换
		cur->pre = tmp;			
		cur = tmp;				//移动

	}
	
	cur->next = cur->pre;
	cur->pre = ls->head;
	ls->head->pre = ls->head->next;	//逆序
	ls->head->next = cur;

	return TRUE;
}

双向循环链表的销毁

void Destroy(List *ls)
{
	if (NULL == ls)
		return;
	
	Node *tmp = ls->head;
	while (tmp->next != ls->head)
	{
		Node *p = tmp->next;
		tmp->next = p->next;
		free(p);
	}
	
	free(ls->head);
	free(ls);
}
Neo_0
关注
专栏目录
嵌入式单片机中链表操作与实现详解
嵌入式技术开发
06-08 533
包含单链表，双链表，循环单链表，实际应用中的功能不同，但实现方式都差不多。单链表就像是美国男篮，一代一代往下传；双链表像是中国男足，你传球给我，我传球给你，最终传给了守门员；循环链表就像是中国男篮，火炬从姚明传给王治郅，王治郅传给易建联，现在易建联伤了，又传给了姚明单链表是指结点中只有一个指向其后继的指针，具有单向性，但是有时需要搜索大量数据的时候，就需要多次进行从头开始的遍历，这样的搜索就不是很高效了。
七万字千锤百炼，Java基础知识大总结
热门推荐
耀的博客
11-18 1万+
目录 ✨写在前面 ✨初识Java与开发环境的安装 ????Java语言概述 ????Java语言是什么 ????Java祖师爷 ????为什么选择Java ????Java是最好的语言么 ????开发环境的安装 ????JDK的安装 ????IEDA的安装 ✨数据类型与运算符 ????变量和类型 ????长整型变量 ????双精度浮点型变量 ????单精度浮点型变量 ????字符类型变量 ????字节类型变量 ????短整型变量 ????布尔类型变量 ????字符串类
嵌入式链表
12-11
这是一个万能的链表，将其嵌入到自己的结构体当中使用，免去编写一个结构体一套操作函数之苦。
嵌入式必修数据结构——“链表”
m0_58168670的博客
06-19 376
首先我们从简单的开始讲，单链表，其余的双链表，循环链表也就是在这个基础上增加了更多的逻辑关系罢了。
【嵌入式Linux C编程】数据结构之链表
qq_39612543的博客
03-26 219
链接表是线性表的链接储存形式。线性表的储存空间是有限的，而链表的储存空间是无限的。表中每个元素由节点Node构成，每个节点中分为一个数据区域，如 int data ，和一个指针区域  struct struct_name *next。一条链表的第一个节点为头结点，一般不存放数据，当做头指针使用，指向下一个用来存放数据的节点。链表的定义typedef char ListData; typedef ...
嵌入式学习之C语言链表
weixin_58528235的博客
07-16 325
这段代码实现了从头节点开始插入新节点，所以这样出来的链表中节点的顺序要注意一下：第一个插入的节点是尾节点。我们分析这段代码可以看到只有我们不输入0就可以不断创建新节点，而且把每个新malloc出来的新节点的next指向上一个malloc出来的节点，这里要注意每次malloc一个新节点一定要把其next指向NULL，因为我之前是在虚拟机里写得代码，会默认malloc后节点的next会指向NULL，这也导致我把代码拷贝到windows中的编译器中运行会出现错误。从某个节点前面插入一个新节点。
记录嵌入式学习之链表
weixin_61530885的博客
10-20 399
使用链表虽然写起来麻烦，但是方便了对数据的增删改，作用是大于数组的。
嵌入式Linux C编程入门(第2版) PPT
03-11
8.1.4　循环链表　234 8.1.5　arm linux中链表使用实例　235 8.2　树、二叉树、平衡树　237 8.2.1　树　237 8.2.2　二叉树　238 8.2.3　平衡树　245 8.2.4　arm linux中红黑树使用实例　247 8.3　哈希表　249...
嵌入式linux应用程序开发-课程大纲
01-25
本部分作为课程的入门阶段，旨在帮助学生建立起扎实的Linux基础与嵌入式开发技能，为后续深入学习奠定基石。 **1. Linux操作系统基础** - **Linux系统安装与配置**：学习如何在不同环境中安装Linux系统，包括...
嵌入式软件开发的面试题
最新发布
扬帆起航
08-25 394
嵌入式软件开发的面试题
循环双链表
09-12
基于C高级的双向循环链表，可以选择头插还是尾插两种插入方式，及增加节点，删除节点
嵌入式c的链表与指针操作
11-02
嵌入式c语言的链表与内存动态分配和指针操作。
嵌入式C语言基础链表
FHNCSDN
04-23 688
什么是链表？ 链表其实就是一种数据结构，所谓的数据结构就是数据存放的思想。 数组、链表优缺点： 增加一个元素或者删除一个元素都很难，因为地址是连续的，删除一个元素可能会挪动多个元素，不灵活。但是对于链表来说就很轻松了，链表的每一个节点都是一个结构体，可以通过指针指向的方式将链表串起来，很灵活。 ...
嵌入式c语言单向链表
weixin_46146281的博客
04-13 201
注意：这种方法是判断prev指向的是不是尾节点，current保存的地址是不是尾节点的下一项NULL，current本身指向的就是尾节点的next，当current指向NULL时循环已经退出了，此时prev保存的就是为尾节点，prev的next指向的就是新的节点。注意：这种方法是判断current保存的下一个地址是不是NULL，current本身指向的是尾节点，在current后面就是新的节点。链表是结合结构体和指针的综合应用，学习之前务必复习结构体和指针的相关知识。找到尾节点后添加新节点到链表尾部。
嵌入式数据结构（单链表）
afddasfa的博客
09-24 327
链表
链表之循环双链表
蓝亚之舟的博客
05-09 806
双节点类：public class DoubleNode&lt;T&gt; { public T data; public DoubleNode&lt;T&gt; prev, next; public DoubleNode(T data, DoubleNode&lt;T&gt; prev, DoubleNode&lt;T&gt; next) { this.data = data; ...
嵌入式0基础开始学习 Ⅱ 数据结构（2）链表
qq_63137715的博客
05-24 1018
因此：1） 只需要知道首结点的地址，则其他结点的数据都能被访问2） 保存新的数据，只需要创建一个结点再把这个结点加入到链表中即可。
双链表与循环链表
thdwx的博客
09-19 649
双链表与循环链表 最好在表头和表尾都加上哑节点，这样不论是增加还是删除，都不会改变表头和表尾的地址。因为在增删表头或表尾元素时，必须要记住表尾或是表头的地址，如果不适用哑节点的话，就需要两个专门的变量来存放表头和表尾的地址。在实现单链表时，如果在表头加上哑节点，实现起来就会比较容易，因为这样表头的地址就是始终不变的。双链表是指在单链表的基础上，每一个结构体中多出来一个指针用来指向上一个结构体。在单链表的基础上，使得表尾部的元素的next指针指向表头。
【数据结构】-循环链表(双链表）
RunningSnail的博客
07-21 963
循环双链表-带头结点1.头文件及类型定义2.循环双链表结点类型定义3.函数声明4.基本操作4.1 初始化循环双链表4.2 判空4.3 判断表尾结点4.4 按位查找4.5 指定结点后插4.6 删除指定结点后继结点4.7 创建循环双链表4.8 遍历4.9 销毁循环双链表4.10 main函数5.小结 1.头文件及类型定义 #include<stdio.h> #include<stdlib.h> #define ElemType int using namespace std; 2.循环
C语言实现双向循环链表插入操作
在C语言中，双向循环链表是一种数据结构，它允许节点在链表的前后两个方向上进行遍历。这种链表的每个节点包含一个指向前一个节点（prior）和一个指向后一个节点（next）的指针。本资源主要讲解如何创建、显示以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值