C语言.数据结构.单链表

最新推荐文章于 2024-10-04 18:59:43 发布
最新推荐文章于 2024-10-04 18:59:43 发布
阅读量819 收藏 12
点赞数 15
分类专栏： C语言基本语法 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Joseit/article/details/139349810
版权

数据结构.单链表

1.链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针链表中的指针链表次序实现的。

在这里插入图片描述

  • 链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉 / 加上，不会影响其他车厢，每节车厢都是独立存在的。
  • 车厢是独立存在的，且每节车厢都有车门。想象一下这样的场景，假设每节车厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带一把钥匙的情况下如何从车头走到车尾？

最简单的做法：每节车厢里都放一把下一节车厢的钥匙。

在链表里，每节“车厢”是什么样的呢？
在这里插入图片描述

  1. 与顺序表不同的是，链表里的每一个“车厢”都是独立申请下来的空间，称之为“节点/结点”。
  2. 节点的组成主要有两个部分：当前节点要保存的数据和保存下一个节点的地址(指针变量)。
  3. 图中的指针 plist 保存的是第一个节点的地址，称之为“指向”第一个节点，如果希望 plist “指向”第二个节点时，只需要修改plist保存的内容0x0012FFA0。

为什么还需要指针变量来保存下一个节点的位置？

链表中的每一个节点都是独立申请的(即需要插入数据时才去申请一块结点的空间)，需要通过指针变量来保存下一个节点位置才能从当前节点找到下一个节点。

结合前面学过的结构体知识，可以给出每个节点对应的结构体代码：

假设当前保存的节点为整型：

struct SListNode
{
	int data;//节点数据
	struct SListNode* next;//指针变量用保存下一个节点的地址
};

  • 当想要保存一个整型数据时，实际是向操作系统申请一块内存，这个内存不仅要保存整型数据，也要保存下一个节点的地址(当下一个节点为空时保存的地址为空)。

  • 当想要从第一个节点走到最后一个节点时，只需要在前一个结点拿上下一个节点地址(下一个结点的钥匙)就可以了。

给定的链表结构中，如何实现节点从头到尾的打印？

在这里插入图片描述

void SListTest01()
{
	//链表是由一个个节点组成
	//创建几个节点
	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 1;

	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
	node2->data = 2;

	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
	node3->data = 3;

	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
	node4->data = 4;

	//将四个节点连接起来：
	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;

	//调用链表的打印
	SLTNode* plist = node1;
	SLTPrint(plist);
}

思考：当想要保存的数据类型为字符串类型、浮点型或者其他自定义类型时，该如何修改？

补充说明：

  1. 链式结构在逻辑上是连续的，在物理结构上不一定连续
  2. 节点一般是从堆上申请的
  3. 从堆上申请的空间，是按照一定的策略分配出来的，每次申请的空间可能连续，可能不连续。

2.单链表的实现

2.1链表的打印

//链表的打印
void SLTPrint(SLTNode* phead)
{
	//相当于遍历链表
	SLTNode* pcur = phead;
	while (pcur)//等价于pcur != NULL
	{
		printf("%d->", pcur->data);
		//让pcur走到下一个节点
		pcur = pcur->next;
	}
	printf("NULL\n");
}

图文理解：

在这里插入图片描述

2.2节点的申请

//节点的申请
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	//判断是否申请空间失败
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

2.3单链表的尾插

//单链表的尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//*pphead就是指向第一个节点的指针
	//空链表与非空链表
	//假如是空链表，就说明*pphead是头结点的指针，也是尾节点的指针
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找到尾节点
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			//遍历链表
			ptail = ptail->next;
		}
		//ptail指向的就是尾节点
		ptail->next = newnode;
	}
}

图文理解：

在这里插入图片描述

2.4单链表的头插

//单链表的头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	//直接把新节点插在头节点之前
	newnode->next = *pphead;
	//再让*pphead走到newnode的位置
	*pphead = newnode;
}

图文理解：

在这里插入图片描述
解释：

情况1就是正常的头插，没有问题。情况2头插的是空链表，也符合要求。

2.5单链表的尾删

//单链表的尾删
void SLTPopBack(SLTNode** pphead)
{
	//既然要删除节点，那链表不能为空
	assert(pphead && *pphead);
	//链表只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//链表不止一个节点
	else
	{
		SLTNode* prev = *pphead;
		SLTNode* ptail = *pphead;
		while(ptail->next)
		{
			//prev为ptail前一个指针
			prev = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		
		prev->next = NULL;
	}
}

图文理解：

在这里插入图片描述

2.6单链表的头删

//单链表的头删
void SLTPopFront(SLTNode** pphead)
{
	//既然要删除节点，那链表不能为空
	assert(pphead && *pphead);
	//先把下一个节点的指针存储下来，防止等到删除掉头节点之后，找不到后面的节点
	SLTNode* next = (*pphead)->next;//->的优先级高于*
	free(*pphead);
	//让*pphead走到next位置，变成新的头节点
	*pphead = next;
}

图文理解：

在这里插入图片描述

2.7单链表节点的查找

//单链表节点的查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	//本质也是遍历单链表
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//到这一步，已经证明找不到x了
	return NULL;
}

2.8在指定位置之前插入数据

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	//若pos == *pphead;说明是头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else 
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//就是把新节点newnode插在prev与pos中间：
		//prev -> newnode -> pos
		newnode->next = pos;
		prev->next = newnode;
	}
}

图文理解：

在这里插入图片描述

2.9在指定位置之后插入数据

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	//在pos之后插入数据，证明这个链表就不为空，不用判断
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	//就是在pos与pos->next之间插入新的节点：
	//pos -> newnode -> pos->next
	newnode->next = pos->next;
	pos->next = newnode;
}

图文理解：

在这里插入图片描述

2.10删除pos节点

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	//pos是头节点 / 不是头节点
	if (pos == *pphead)
	{
		//调用头删的方法
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//就是在pos与pos->next删除节点
		//prev -> pos -> pos->next
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

图文理解：

在这里插入图片描述

2.11删除pos之后的节点

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	//就是在pos与del->next删除节点
	//pos -> del -> del->next
	pos->next = del->next;
	free(del);
	del = NULL;
}

图文理解：

在这里插入图片描述

2.12单链表的销毁

//单链表的销毁
void SListDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		//从第一个节点开始销毁，每销毁一个节点之前，先保存当前节点的下一个节点的指针，
		//否则销毁当前结点的时候，后面的节点找不到了
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = NULL;
	}
	//把头节点手动置为空
	*pphead = NULL;
}

2.13整体代码展示

SList.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//定义结点的结构
//数据＋下一个结点的地址
typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

//链表的打印
void SLTPrint(SLTNode* phead);

//单链表的尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);

//单链表的头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);

//单链表的尾删
void SLTPopBack(SLTNode** pphead);

//单链表的头删
void SLTPopFront(SLTNode** pphead);

//单链表节点的查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);

//单链表的销毁
void SListDestroy(SLTNode** pphead);

SList.c

#include "SList.h"

//节点的申请
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	//判断是否申请空间失败
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//链表的打印
void SLTPrint(SLTNode* phead)
{
	//相当于遍历链表
	SLTNode* pcur = phead;
	while (pcur)//等价于pcur != NULL
	{
		printf("%d->", pcur->data);
		//让pcur走到下一个节点
		pcur = pcur->next;
	}
	printf("NULL\n");
}

//单链表的尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//*pphead就是指向第一个节点的指针
	//空链表与非空链表
	//假如是空链表，就说明*pphead是头结点的指针，也是尾节点的指针
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找到尾节点
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			//遍历链表
			ptail = ptail->next;
		}
		//ptail指向的就是尾节点
		ptail->next = newnode;
	}
}

//单链表的头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	//直接把新节点插在头节点之前
	newnode->next = *pphead;
	//再让*pphead走到newnode的位置
	*pphead = newnode;
}

//单链表的尾删
void SLTPopBack(SLTNode** pphead)
{
	//既然要删除节点，那链表不能为空
	assert(pphead && *pphead);
	//链表只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//链表不止一个节点
	else
	{
		SLTNode* prev = *pphead;
		SLTNode* ptail = *pphead;
		while(ptail->next)
		{
			//prev为ptail前一个指针
			prev = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		
		prev->next = NULL;
	}
}

//单链表的头删
void SLTPopFront(SLTNode** pphead)
{
	//既然要删除节点，那链表不能为空
	assert(pphead && *pphead);
	//先把下一个节点的指针存储下来，防止等到删除掉头节点之后，找不到后面的节点
	SLTNode* next = (*pphead)->next;//->的优先级高于*
	free(*pphead);
	//让*pphead走到next位置，变成新的头节点
	*pphead = next;
}

//单链表节点的查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	//本质也是遍历单链表
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//到这一步，已经证明找不到x了
	return NULL;
}



//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	//若pos == *pphead;说明是头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else 
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//就是把新节点newnode插在prev与pos中间：
		//prev -> newnode -> pos
		newnode->next = pos;
		prev->next = newnode;
	}
}

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	//在pos之后插入数据，证明这个链表就不为空，不用判断
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	//就是在pos与pos->next之间插入新的节点：
	//pos -> newnode -> pos->next
	newnode->next = pos->next;
	pos->next = newnode;
}

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	//pos是头节点 / 不是头节点
	if (pos == *pphead)
	{
		//调用头删的方法
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//就是在pos与pos->next删除节点
		//prev -> pos -> pos->next
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	//就是在pos与del->next删除节点
	//pos -> del -> del->next
	pos->next = del->next;
	free(del);
	del = NULL;
}

//单链表的销毁
void SListDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		//从第一个节点开始销毁，每销毁一个节点之前，先保存当前节点的下一个节点的指针，
		//否则销毁当前结点的时候，后面的节点找不到了
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = NULL;
	}
	//把头节点手动置为空
	*pphead = NULL;
}

test.c

#include "SList.h"

void SListTest02()
{
	SLTNode* plist = NULL;
	//1.单链表的尾插
	SLTPushBack(&plist, 1);
	SLTPrint(plist);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
	
	//2.单链表的头插
	SLTPushFront(&plist, 4);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 1);
	SLTPrint(plist);

	//3.单链表的尾删
	SLTPopBack(&plist);
	SLTPopBack(&plist);
	SLTPopBack(&plist);
	SLTPopBack(&plist);
	SLTPrint(plist);

	//4.单链表的头删
	SLTPopFront(&plist);
	SLTPopFront(&plist);
	SLTPopFront(&plist);
	SLTPopFront(&plist);
	SLTPrint(plist);

	//5.单链表节点的查找
	SLTNode* find = SLTFind(plist, 1);
	if (find == NULL)
	{
		printf("找不到！\n");
	}
	else
	{
		printf("找到了！\n");
	}

	//6.在指定位置之前插入数据
	SLTNode* find = SLTFind(plist, 3);
	SLTInsert(&plist, find, 6);
	SLTPrint(plist);

	//7.在指定位置之前插入数据
	SLTNode* find = SLTFind(plist, 3);
	SLTInsertAfter(find, 6);
	SLTPrint(plist);

	//8.删除pos节点
	SLTNode* find = SLTFind(plist, 3);
	SLTErase(&plist, find);
	SLTPrint(plist);

	//9.删除pos之后的节点
	SLTNode* find = SLTFind(plist, 3);
	SLTEraseAfter(find);
	SLTPrint(plist);

	//10.单链表的销毁
	SListDestroy(&plist);
	SLTPrint(plist);
}
int main()
{
	SListTest02();
	return 0;
}

3.链表的分类

链表的结构非常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：

在这里插入图片描述

链表说明：
在这里插入图片描述
虽然有这么多的链表的结构，但是实际上中最常用还是两种结构：单链表和双向带头循环链表。

  1. 无头单向非循环链表：结构简单，一般不会单独用来存放数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等。

  2. 带头双向循环链表：结构最复杂，一般用于单独存储数据。实际中使用的是链表数据结构，都是带头双向循环链表。另外，这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

Joseit
关注
专栏目录
2.C语言数据结构 单链表反转
Scroll_C的博客
11-25 1347
单链表反转（4 种算法实现） 已经对单链表以及它的用法有了一个完整的了解。在此基础上，本节再带领大家研究一个和单链表有关的问题，即如何实 现单链表的反转。 反转链表，又可以称为翻转或逆置链表，它们表达的是同一个意思。以图 1 所示的链表为例： 图 1 未反转的链表 图 1 未反转的链表 经过反转（翻转、逆置）后，得到的新链表如图 2 所示：...
【数据结构】【C语言】------ 单链表
m0_63601181的博客
05-14 4245
前言 大家好，我是Abert。 这篇文章和大家分享用C语言实现数据结构中的单链表。 单链表可以看作是“拆分开”的顺序表。在顺序表的基础上，单链表做了一些优化，但同时也丧失了一些顺序表有的功能。 我们一起来学习单链表吧！！！ 文章目录 一、单链表的讲解 二、程序基本框架的搭建与讲解 2.1 文件的创建 2.2 变量的创建 三、各种功能的实现及逻辑关系的讲解 3.1 尾插 3.2 头插 3.3 尾删 ...
单链表—C语言实现数据结构
2201_76062618的博客
05-28 4693
本文具体讲解单链表的结构，内容较为丰富，干货多多
数据结构——单链表详解（C语言实现）
sinzz的博客
03-08 1330
首先，我们需要知道，单链表内所需要的数据有两种，一种是数据，还有就是下一个节点的指针。所以我们需要定义一个结构体。//重命名单链表的数据 //便于不同数据类型的切换 typedef struct SLTNode {//SLTNode* next//错误 //改写法C语言是不支持的 //struct SLTNode//错误 } SLTNode;
数据结构——单链表（C语言实现）
weixin_57154303的博客
08-23 4260
单链表的基本操作有 初始化，头插，尾插，按位置插，头删，尾删，按位置删，查找，按值删，获取有效值个数，判空，清空，销毁，打印 - 单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点的构成：==元素(数据元素的映象)== + ==指针(指示后继元素存储位置)==，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。
单链表数据结构代码（C语言）
m0_51512094的博客
04-25 2478
利用单链表数据结构实现一组数据的存储，通过简单的交互实现单链表的增删改查。 //ADT 线性表（List） 链式存储结构 LinkList #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; //定义单链表 typedef struct Node {
【数据结构】C语言实现单链表
SHLYYY
04-30 3033
SLLNode;// 打印 void SLLPrint(SLLNode * phead);// 头插、尾插 void SLLPushFront(SLLNode * * pphead , SLLDataType x);// 头删、尾删 void SLLPopFront(SLLNode * * pphead);// 查找 SLLNode * SLLFind(SLLNode * phead , SLLDataType x);
单链表（c语言数据结构）
awm123453的博客
04-28 3610
老师的代码如下： #include<stdio.h> #include<malloc.h> /* *Linked list of characters. The key is data. */ typedef struct LinkNode{ char data; struct LinkNode *next; }LNode, *LinkList, *NodePtr; /** * Initialize the list with a header. *@return The p
数据结构c语言代码实现单链表
小洁洁
01-03 470
今天让我们一起来看看如何用c语言实现单链表尼？废话不多说，直接上代码。这是分装的代码，直接合并即是全部代码。主要内容如下：声明头文件，结构体。 随便一位置删除元素。初始化链表。头插法添加。尾插法添加 ，打印链表
C语言单链表
myCs05的博客
01-18 511
【代码】C语言单链表。
数据结构C语言版之单链表的逆置.cpp
10-07
数据结构老师布置的作业，运用课本代码，较为基础经典，适合大学本科在上数据结构这门课的同学参考，简单易懂，关于单链表的逆置问题
算法数据结构学习笔记-C语言.zip
01-01
在C语言中实现数据结构，能够深入理解底层逻辑，提高编程能力。本学习笔记将深入探讨数据结构的基础知识，以及如何在C语言中实现这些结构。 1. **数组**：数组是最基本的数据结构，它是由相同类型元素的集合组成，...
C语言单链表.pdf
09-27
在给定的“C语言单链表.pdf”文件中，它详细介绍了如何使用C语言来实现单链表的各种操作，包括创建、遍历、删除、插入和查找。下面将深入解释这些知识点。 首先，单链表的每个节点由两部分组成：数据域（data）和...
C语言自定义类型：结构体
吴先生的博客
09-28 738
我们知道C语言有内置的类型，char,int,float等，但是在日常生活中会存在很多复杂的类型无法用内置类型来表示，比如一个人，人有身高，体重，年龄等，这个时候我们就要人为的创造类型；—结构体。位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以 选择其他类型。位段的成员名后边有⼀个冒号和⼀个数字。注：有的课本会说一般结构体成员的名字都是‘_’开头；int _b : 5;A就是⼀个位段类型。
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 337
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】【顺序表算法】 删除特定范围内的元素
最新发布
Indigo____的博客
10-04 231
题目：从顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。
【数据结构初阶】排序算法(中)快速排序专题
fhvyxyci的博客
09-28 1272
1. 快排主框架 2. 快排的不同实现 2. 1 hoare版本 2. 2 挖坑法 2. 3 lomuto前后指针法 2. 4 快排的非递归版本 3. 快排优化 3. 1 快排性能的关键点分析: 3. 1 三路划分 3. 2 introsort自省排序
数据结构-3.8.栈在括号匹配中的应用
ADCvbV的博客
10-01 515
把左括号依次压入栈中，越往后压入栈的左括号越先被匹配即被弹出栈->先进后出，后进先出当遇到左括号就压入栈中，当遇到右括号就把栈顶的左括号弹出，检查该右括号和左括号是否匹配当遇到一个不匹配的就停止压入栈，因为之后的括号必定都不匹配。其中Y代表Yes，N代表No1.对于bracketCheck函数，形参str[]是传入的一个字符串，length是该字符串的长度；字符topElem代表栈顶元素；return StackEmpty(S)如果是return false说明栈不为空，则左括号单身；创建栈顶元素topEl
（JAVA）队列 和 符号表 两种数据结构的实现
ZunXin_2580的博客
09-27 671
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值