【数据结构基础_双向链表（有[*pHead]和[*pEnd]）_(C语言实现)】

最新推荐文章于 2024-08-21 05:12:14 发布
最新推荐文章于 2024-08-21 05:12:14 发布
阅读量750 收藏 3
点赞数 1
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sugar_wolf/article/details/121619454
版权

c语言 数据结构 开发语言

双向链表（含头尾指针）

双向链表呢，顾名思义，就是比单向多一个向前指向节点的一个指针

本文主要是针对（含头尾指针）双向链表进行增、删、改、查操作

创建一个结构体当做节点
struct Node
{
	int iData;
	struct Node* pNext;		//记录后一个节点地址
	struct Node* pPre;		//记录前一个节点的地址
};

前面我用的是局部定义头尾指针（每次调用都需要传参），这次咱们使用全局的
定义头尾指针

struct Node* g_pHead = NULL;
struct Node* g_pEnd = NULL;
int g_iNodeCount = 0;

g_iNodeCount是记录节点数的

增加：1.尾添加
//尾添加
void AddToEnd(int iData)
{
	//参数合法性检测
	if (g_iNodeCount < 0)
		return;
	//申请节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	if (NULL == pTemp)
		return;
	//节点成员赋值
	pTemp->iData = iData;
	pTemp->pNext = NULL;
	pTemp->pPre = NULL;
	//连接链表
	if (NULL == g_pHead)	//无节点
	{
		g_pHead = pTemp;
		//g_pEnd = pTemp;
	}
	else
	{
		g_pEnd->pNext = pTemp;
		pTemp->pPre = g_pEnd;
		//g_pEnd = pTemp;
	}
	g_pEnd = pTemp;
	//节点数量++
	g_iNodeCount++;
}
增加：2.头添加
void AddToHead(int iData)
{
	//创建节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	if (pTemp == NULL)
		return;
	//节点赋值
	pTemp->iData = iData;
	pTemp->pNext = NULL;
	pTemp->pPre = NULL;
	//连接到链表上
	if (NULL == g_pHead)
	{
		//g_pHead = pTemp;
		g_pEnd = pTemp;
	}
	else
	{
		pTemp->pNext = g_pHead;
		g_pHead->pPre = pTemp;
		//g_pHead = pTemp;
	}
	g_pHead = pTemp;
	g_iNodeCount++;
}

此时咱们链表的最简单的两个添加，已经完成，我们可以遍历链表来查看，并且释放链表

遍历链表

由于是双向链表所以既可以正向遍历，也可以反向遍历

void LookZheng()
{
	if (NULL == g_pHead)
		return;
	//循环遍历
	printf("共有 %d 个节点： ", g_iNodeCount);
	struct Node* pTemp = g_pHead;
	while (pTemp != NULL)
	{
		printf("%d  ", pTemp->iData);
		pTemp = pTemp->pNext;
	}
	putchar('\n');
}

void LookFan()
{
	if (NULL == g_pEnd)
		return;
	//循环遍历
	printf("共有 %d 个节点： ", g_iNodeCount);
	struct Node* pTemp = g_pEnd;
	while (pTemp != NULL)
	{
		printf("%d  ", pTemp->iData);
		pTemp = pTemp->pPre;
	}
	putchar('\n');
}
释放链表
void FreeList()
{
	//参数合法性检测
	if (NULL == g_pHead)
		return;
	//申请中间变量
	struct Node* pTemp = g_pHead;
	while (pTemp != NULL)
	{
		//记录要被释放的节点
		struct Node* pT = pTemp;
		//指向下一个节点
		pTemp = pTemp->pNext;
		//释放当前节点
		free(pT);
	}
	g_pHead = NULL;
	g_pEnd = NULL;
	g_iNodeCount = 0;
}

释放链表记得指针要置空哈
并且计数器置零

查找：1.根据下标查询
struct Node* GetByIndex(int iIndex)
{
	//参数合法性检测
	if (NULL == g_pHead || iIndex < 0 || iIndex >= g_iNodeCount)
		return NULL;
	//循环遍历
	struct Node* pTemp = g_pHead;
	for (int i = 0; i < iIndex; i++)
		pTemp = pTemp->pNext;
	//返回
	return pTemp;
}
查找：2.根据数值查询
struct Node* GetByData(int iData)
{
	//参数合法性检测
	if (NULL == g_pHead)
		return NULL;
	//循环遍历
	struct Node* pTemp = g_pHead;
	while (pTemp != NULL)
	{
		if (pTemp->iData == iData)
			break;//return pTemp;
		pTemp = pTemp->pNext;
	}
	//return NULL;
	return pTemp;
}
升级版添加：1.指定的下标位置添加
void InsertNodeByIndex(int iIndex, int iCount, int iData)
{
	//参数合法性检测
	if (iIndex < 0 || iIndex>g_iNodeCount || iCount <= 0)
		return;
	//分类判断
	if (0 == iIndex)					//头添加
	{
		for (int i = 0; i < iCount; i++)
			AddToHead(iData);
	}
	else if (iIndex == g_iNodeCount)	//尾添加
	{
		for (int i = 0; i < iCount; i++)
			AddToEnd(iData);
	}
	else								//中间添加
	{
		//找位置
		struct Node* pTemp = g_pHead;
		for (int i = 0; i < iIndex; i++)
			pTemp = pTemp->pNext;
		//循环
		for (int i = 0; i < iCount; i++)
		{
			//申请节点
			struct Node* pNew = (struct Node*)malloc(sizeof(struct Node));
			if (pNew == NULL)
				return;
			//节点赋值
			pNew->iData = iData;
			pNew->pNext = NULL;
			pNew->pPre = NULL;
			//链接
			//指定位置前一个节点与新节点相连
			pTemp->pPre->pNext = pNew;
			pNew->pPre = pTemp->pPre;
			//指定位置节点与新节点相连
			pNew->pNext = pTemp;
			pTemp->pPre = pNew;
		}
		//节点数量++
		g_iNodeCount += iCount;
	}
}
升级版添加：2.指定数据位置添加节点
void InsertNodeByData(int iValue, int iData)
{
	//参数合法性检测
	if (NULL == g_pHead)
		return;
	//找节点
	struct Node* pTemp = g_pHead;
	while (pTemp != NULL)
	{
		if (pTemp->iData == iValue)
			break;
		pTemp = pTemp->pNext;
	}
	//判断是否找到
	if (pTemp != NULL)
	{
		if (pTemp == g_pHead)
			AddToHead(iData);
		else
		{
			//申请节点
			struct Node* pNew = (struct Node*)malloc(sizeof(struct Node));
			if (NULL == pNew)
				return;
			//节点成员赋值
			pNew->iData = iData;
			pNew->pNext = NULL;
			pNew->pPre = NULL;
			//链接
			//指定位置前一个节点与新节点相连
			pTemp->pPre->pNext = pNew;
			pNew->pPre = pTemp->pPre;
			//指定位置节点与新节点相连
			pNew->pNext = pTemp;
			pTemp->pPre = pNew;
			//节点数量++
			g_iNodeCount += 1;
		}
	}
}
修改：1.根据数值改变此节点数据
void ChangeByData(int iData,int iValue)
{
	//参数合法性检测
	if (NULL == g_pHead)
		return;
	//循环遍历
	struct Node* pTemp = g_pHead;
	while (pTemp != NULL)
	{
		if (pTemp->iData == iData)
			pTemp->iData = iValue;
		pTemp = pTemp->pNext;
	}
}
修改：2.根据下标改变此节点数据
void ChangeByIndex(int iIndex,int iValue)
{
	//参数合法性检测
	if (NULL == g_pHead || iIndex < 0 || iIndex >= g_iNodeCount)
		return;
	struct Node* pTemp = GetByIndex(iIndex);
	if (pTemp != NULL)
	{
		pTemp->iData = iValue;
	}
}
删除：1.根据下标删除节点
void DeleteByIndex(int iIndex)
{
	//查找节点
	struct Node* pTemp = GetByIndex(iIndex);
	//判断是否找到
	if (pTemp != NULL)
	{
		//找到了删除节点
		DeleteNode(pTemp);
	}
}
删除：2.删除结点
void DeleteNode(struct Node* pTemp)
{
	//是否为头结点
	if (pTemp == g_pHead)
	{
		if (g_pHead == g_pEnd)
		{
			free(g_pHead);
			g_pHead = NULL;
			g_pEnd = NULL;
		}
		else
		{
			//方法1.
			//记录头
			//struct Node* pT = g_pHead;
			头指向下一个
			//g_pHead = g_pHead->pNext;
			头前设置为NULL
			//g_pHead->pPre = NULL;
			释放
			//free(pT)
			方法2.记录头
			头指向下一个
			//g_pHead = g_pHead->pNext;
			头前设置为NULL
			//g_pHead->pPre = NULL;
			释放
			//free(pTemp);
			//方法3.头指向下一个
			g_pHead = g_pHead->pNext;
			//释放头的前一个节点
			free(g_pHead->pPre);
			//头前置NULL
			g_pHead->pPre = NULL;
		}
	}
	//尾节点
	else if (pTemp == g_pEnd)
	{
		g_pEnd = g_pEnd->pPre;
		free(g_pEnd->pNext);
		g_pEnd->pNext = NULL;
	}
	//中间节点
	else
	{
		//让其前一个节点的pNext 指针指向其后一个节点
		pTemp->pPre->pNext = pTemp->pNext;
		//让其后一个节点的pPre 指针指向其前一个节点
		pTemp->pNext->pPre = pTemp->pPre;
		//释放此节点
		free(pTemp);
	}
	g_iNodeCount--;
}
删除：3.根据数据删除所有与之相同的节点
void DeleteByData(int iValue)
{
	//while (1)
	//{
	//	//找
	//	struct Node* pTemp = GetByData(iValue);
	//	if (pTemp == NULL)
	//		break;
	//	DeleteNode(pTemp);
	//}
	struct Node* pTemp = NULL;
	while (NULL != (pTemp = GetByData(iValue)))
		DeleteNode(pTemp);
}

下面是合并有序双向链表简单操作方便大家更加熟悉双向链表

合并链表
void HeBing(struct Node** pHA, struct Node** pEA, int* pCA, struct Node** pHB, struct Node** pEB, int* pCB)
{
	//参数合法性检测
	if (NULL == pHA || NULL == *pHA || NULL == pHB || NULL == *pHB)
		return;
	//循环
	while(1)
	{
		//获取头
		struct Node* pTemp = GetHead(pHA, pEA, pCA);
		if (pTemp == NULL)
			return;
		//比头小
		if (pTemp->iData <= (*pHB)->iData)
		{
			//新节点下一个指向头
			pTemp->pNext = (*pHB);
			// 头前一个指向新节点
			(*pHB)->pPre = pTemp;
			// 头向前移
			(*pHB) = pTemp;
			//数量++
			(*pCB)++;
		}
		// 比尾大
		else if (pTemp->iData >= (*pEB)->iData)
		{
			//尾巴的pNext指向新节点
			(*pEB)->pNext = pTemp;
			//新节点的pre指向尾巴
			pTemp->pPre = (*pEB);
			//尾后移
			(*pEB) = pTemp;
			//尾巴的pNext置NULL
			(*pEB)->pNext = NULL;
			//数量++
			(*pCB)++;
		}
		else  // 中间
		{
			//在链表B中找到合适的位置
			struct Node* pT = *pHB;
			if (pT == NULL)
				return;
			while (pT->pNext != NULL)
			{
				if (pTemp->iData >= pT->iData && pTemp->iData <= pT->pNext->iData)
					break;
				pT = pT->pNext;
			}
			//中间添加
			if (NULL == pT->pNext)
				return;
			//新节点的pNext 指向pT的下一个
			pTemp->pNext = pT->pNext;
			//pT的下一个的pPre指向新节点
			pT->pNext->pPre = pTemp;
			//pT和新节点相连
			pT->pNext = pTemp;
			pTemp->pPre = pT;
			//数量++
			(*pCB)++;
		}
	}
}

实现合并链表的完整代码

#include<stdio.h>
#include<stdlib.h>

struct Node
{
	int iData;
	struct Node* pNext;		//记录后一个节点地址
	struct Node* pPre;		//记录前一个节点的地址
};

//尾添加
void AddToEnd(struct Node** pHead, struct Node** pEnd, int* pCount, int iData);
//释放链表
void FreeList(struct Node** pHead, struct Node** pEnd, int* pCount);
//遍历链表 1.正向 2.反向
void LookZheng(struct Node* pHead, int* pCount);
//得到链表头
struct Node* GetHead(struct Node** pHead, struct Node** pEnd, int* pCount);
//合并函数
void HeBing(struct Node** pHA, struct Node** pEA, int* pCA, struct Node** pHB, struct Node** pEB, int* pCB);


int main()
{
	struct Node* g_pAH = NULL;
	struct Node* g_pAE = NULL;
	int g_iA = 0;
	struct Node* g_pBH = NULL;
	struct Node* g_pBE = NULL;
	int g_iB = 0;
	AddToEnd(&g_pAH, &g_pAE, &g_iA, 1);
	AddToEnd(&g_pAH, &g_pAE, &g_iA, 5);
	AddToEnd(&g_pAH, &g_pAE, &g_iA, 2);
	AddToEnd(&g_pAH, &g_pAE, &g_iA, 8);
	AddToEnd(&g_pAH, &g_pAE, &g_iA, 10);
	
	AddToEnd(&g_pBH, &g_pBE, &g_iB, 2);
	AddToEnd(&g_pBH, &g_pBE, &g_iB, 6);
	AddToEnd(&g_pBH, &g_pBE, &g_iB, 9);

	LookZheng(g_pAH, &g_iA);
	LookZheng(g_pBH, &g_iB);
	
	HeBing(&g_pAH, &g_pAE, &g_iA, &g_pBH, &g_pBE, &g_iB);
	LookZheng(g_pBH, &g_iB);
	
	FreeList(&g_pAH, &g_pAE, &g_iA);
	FreeList(&g_pBH, &g_pBE, &g_iB);
	return 0;
}
void HeBing(struct Node** pHA, struct Node** pEA, int* pCA, struct Node** pHB, struct Node** pEB, int* pCB)
{
	//参数合法性检测
	if (NULL == pHA || NULL == *pHA || NULL == pHB || NULL == *pHB)
		return;
	//循环
	while(1)
	{
		//获取头
		struct Node* pTemp = GetHead(pHA, pEA, pCA);
		if (pTemp == NULL)
			return;
		//比头小
		if (pTemp->iData <= (*pHB)->iData)
		{
			//新节点下一个指向头
			pTemp->pNext = (*pHB);
			// 头前一个指向新节点
			(*pHB)->pPre = pTemp;
			// 头向前移
			(*pHB) = pTemp;
			//数量++
			(*pCB)++;
		}
		// 比尾大
		else if (pTemp->iData >= (*pEB)->iData)
		{
			//尾巴的pNext指向新节点
			(*pEB)->pNext = pTemp;
			//新节点的pre指向尾巴
			pTemp->pPre = (*pEB);
			//尾后移
			(*pEB) = pTemp;
			//尾巴的pNext置NULL
			(*pEB)->pNext = NULL;
			//数量++
			(*pCB)++;
		}
		else  // 中间
		{
			//在链表B中找到合适的位置
			struct Node* pT = *pHB;
			if (pT == NULL)
				return;
			while (pT->pNext != NULL)
			{
				if (pTemp->iData >= pT->iData && pTemp->iData <= pT->pNext->iData)
					break;
				pT = pT->pNext;
			}
			//中间添加
			if (NULL == pT->pNext)
				return;
			//新节点的pNext 指向pT的下一个
			pTemp->pNext = pT->pNext;
			//pT的下一个的pPre指向新节点
			pT->pNext->pPre = pTemp;
			//pT和新节点相连
			pT->pNext = pTemp;
			pTemp->pPre = pT;
			//数量++
			(*pCB)++;
		}
	}
}
struct Node* GetHead(struct Node** pHead, struct Node** pEnd, int* pCount)
{
	//参数合法性检测
	if (NULL == pHead || NULL == *pHead)
		return NULL;
	//摘头
	struct Node* pT = *pHead;		//记录头
	if (*pHead == *pEnd)			//只有一个节点
	{
		*pHead = NULL;
		*pEnd = NULL;
	}
	else
	{
		*pHead = (*pHead)->pNext;	//头往后走
		(*pHead)->pPre = NULL;
	}
	(*pCount)--;
	return pT;
}
void LookZheng(struct Node* pHead,int* pCount)
{
	if (NULL == pHead)
		return;
	//循环遍历
	printf("共有 %d 个节点： ", *pCount);
	struct Node* pTemp = pHead;
	while (pTemp != NULL)
	{
		printf("%d  ", pTemp->iData);
		pTemp = pTemp->pNext;
	}
	putchar('\n');
}
void FreeList(struct Node** pHead, struct Node** pEnd, int* pCount)
{
	//参数合法性检测
	if (NULL == *pHead)
		return;
	//申请中间变量
	struct Node* pTemp = *pHead;
	while (pTemp != NULL)
	{
		//记录要被释放的节点
		struct Node* pT = pTemp;
		//指向下一个节点
		pTemp = pTemp->pNext;
		//释放当前节点
		free(pT);
	}
	*pHead = NULL;
	*pEnd = NULL;
	*pCount = 0;
}
void AddToEnd(struct Node** pHead, struct Node** pEnd, int* pCount, int iData)
{
	//参数合法性检测
	if (*pCount < 0)
		return;
	//申请节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	if (NULL == pTemp)
		return;
	//节点成员赋值
	pTemp->iData = iData;
	pTemp->pNext = NULL;
	pTemp->pPre = NULL;
	//连接链表
	if (NULL == *pHead)	//无节点
	{
		*pHead = pTemp;
	}
	else
	{
		(*pEnd)->pNext = pTemp;
		pTemp->pPre = *pEnd;
	}
	*pEnd = pTemp;
	//节点数量++
	(*pCount)++;
}
千北@
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言实用算法系列之学生管理系统_单向链表内操作_选择排序
业精于勤，荒于嬉
12-17 332
单向链表实现 #include <stdio.h> #include <malloc.h> typedef int DATA; struct SNode { DATA data; SNode* pNext; }; SNode* g_pHead = NULL; void AddHead(DATA data) { SNode* p = (SNode*)malloc(sizeof(SNode)); p->data = data; p->pNext = g_pHe
数据结构-双向链表的基本操作 （c语言实现）
weixin_59799963的博客
10-19 3601
1.创造一个节点,函数实现 DListNode* BuyListNode(Datetype x) { DListNode*node = (DListNode*)malloc(sizeof(DListNode)); node->date = x; node->next = NULL; node->prev = NULL; return node; } 2. 初始化 DListNode* DListInit() { DListNode*plist = BuyListNod
（20200411）C语言链表（增、删、改、查）
sinat_32602421的博客
04-11 271
1】 2】 3】
C语言链表初试
weixin_43769045的博客
12-06 225
// DataLink.cpp : 定义控制台应用程序的入口点。 // #include “stdafx.h” #include &amp;amp;lt;stdlib.h&amp;amp;gt; typedef int DATA;// struct SNode { DATA data; SNode* pNext; }; SNode * g_pHead = NULL; //链表头添加节点 void AddHead(DATA dat...
单链表的排序
weixin_43411789的博客
06-07 284
单链表排序 单链表节点交换 单链表节点交换原理
数据结构（一）
qq_52048593的博客
09-17 258
一.链表 （1）单链表 1.head 表示头指针下标 2.e[i]储存节点的值，ne[i]储存下一节点的地址。
_数据结构_双向链表
MPF1230的博客
05-21 267
文章目录双向链表结点双向链表初始化双向链表的插入头插法 双向链表结点 单链表的链式储存只有一个指示后继的指针域，所以，从某个结点出发只能顺指针往后寻查其他结点。若要寻查结点的直接前端，则需要从表头指针出发。     为了克服单链表的单向性缺点，在双向链表的结点中有两个指针域，一个指向直接后继，一个指向直接前趋。 typedef struct double_list { int val; //结点的值 struct double_list* next; //后继结点
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
学习和掌握链表操作，尤其是双向循环链表，对于理解和编写复杂的数据结构和算法至关重要，这对于软件开发人员来说是必不可少的技能。在实际应用中，链表常用于实现如队列、栈、哈希表等高级数据结构，以及解决各种...
DOUBLE_LINK.rar_DOUBLE_LINK_doublelink_双向链表_双向链表C语言_链表 实现
09-24
**双向链表详解** 双向链表（Double-Linked List）是一种数据结构，它与单向链表相似，但每个节点不仅包含指向下一个节点的指针，还包含一个...熟练掌握双向链表的操作对于理解和实现复杂的数据结构和算法至关重要。
tushuguan.cpp.rar_C语言双向链表_数据结构 管理_数据结构 管理系统_链表图书馆
09-21
本系统“tushuguan.cpp.rar”就是一个基于C语言实现的图书馆管理系统，它巧妙地运用了双向链表这一数据结构，实现了对图书信息的有效管理和操作。 双向链表是一种高级数据结构，与单链表不同，它在每个节点中不仅...
tongxunlu.rar_C语言双向链表_city_doubly linked list_tongxunlu_数据结构 通讯录
09-22
用〈〈数据结构〉〉中的双向链表作数据结构，结合C语言基本知识。编写一个通讯录管理系统。以把所学数据结构知识应用到实际软件开发中去。 设计内容：本系统应完成一下几方面的功能： 输入信息——enter() 显示信息...
C语言实现数据结构和双向链表操作
08-31
C语言实现数据结构和双向链表操作 本文主要介绍了C语言实现数据结构双向链表操作的相关知识点。双向链表是一种常用的数据结构，它可以从两个方向搜索某个结点，且可以从头结点和尾结点进行遍历。 1. 双向链表的...
数据结构与算法 | 带头双向循环链表
凌桓丶的博客
02-13 462
上一节里实现的是最简单的链表，在实际中那种链表不会单独用来存储数据，更多是作为其他数据结构的子结构，如图的邻接表等。而比较常用的就是带头双向循环链表。 通过对比我们可以看出有三个不同，多了头节点，链表中的元素之间不再是单向而是双向，头尾节点相连，构成循环链表。 虽然结构比起之前的复杂了一点，但是优势却十分明显。 如普通链表要访问最后的元素时，只能通过遍历链表来取得，而这个可以直接取头节点的前一...
数据结构 带头尾结点的双链表
weixin_53272394的博客
07-17 300
带头尾结点的双链表 头文件 #ifndef DLINKED_LIST_H__ #define DLINKED_LIST_H__ #include <stdio.h> #include <stdlib.h> #include <stdbool.h> typedef int ETYPE; typedef struct DNode{ ETYPE elem; //结点元素 数据域 struct DNode *prev; //前结点位置 内存地址 s
引发了异常: 读取访问权限冲突。 **g_pHead** 是 nullptr。
loneth的博客
12-31 2896
引发了异常: 读取访问权限冲突。 g_pHead 是 nullptr。
C语言开发简单的学生成绩管理系统（附源码）
热门推荐
渣渣的夏天
04-15 27万+
学生成绩管理系统 开发语言：C语言 开发工具：Visual Studio 2019 开发时间：2019.4.14 开发者：summer @一、系统使用展示 @二、系统功能 @三、菜单 @四、录入学生信息 @五、打印学生信息 @六、保存学生信息 @七、读取学生信息 @八、统计所有学生人数 @九、查找学生信息 @十、修改学生信息 @十一、删除学生信息 @十二、退出系统 @十三、出错 一、系统使用展示 ...
【数据结构基础_有[*pHead]和[*pEnd]的单向链表_(C语言实现)】
Sugar_wolf的博客
11-18 1273
单向链表（含头尾指针） 本文主要是针对（含头尾指针）单向链表进行增、删、改、查操作 创建一个结构体当做节点 struct Node { int iData; struct Node* pNext; }; 定义头尾指针 struct Node* pHead = NULL; struct Node* pEnd = NULL; pEnd指针是为了增加尾添加的效率，否则就要循环找尾 增加：1.尾添加 无（*pEnd）指针的尾添加 void AddToEndNopEnd(struct Node**
快速排序（算法）
liu94264yu的博客
07-03 136
一、简介 快速排序是一种高效的排序方法，且应用广泛，有时在面试中也会遇到。二、排序思路 总体思路：首先选择一个基准数，一般为第一个数，将所有比基准数小的数据放到其左右，比基准数大的数据放到其右边，然后使用递归的方式对两边的数据进行同样的处理，这样就可以达到排序的目的。 原始数据：30、4、32、56、12、24 基准数 base 为30，这里还需要借助两个整数指针，实现数据的移动。分别是p_start和p_end，p_start指向开头的数，这是是30
C语言 | Leetcode C语言题解之第354题俄罗斯套娃信封问题
最新发布
m0_59237910的博客
08-21 252
C语言 | Leetcode C语言题解之第354题俄罗斯套娃信封问题
C语言实现数据结构：双向循环链表操作与算法应用
1. **双向循环链表**：双向循环链表是一种链式数据结构，每个节点包含指向前一个节点和后一个节点的指针。这种结构允许从两个方向遍历链表，增加了数据操作的灵活性。在文中，双向循环链表被用于动态建立和操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

千北@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值