初阶数据结构2 顺序表和链表

已于 2024-07-30 20:27:32 修改
阅读量1.2k 收藏 27
点赞数 33
文章标签： 数据结构
于 2024-07-29 16:17:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yusei_0523/article/details/140757561
版权

顺序表

1. 线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是⼀种在实际中⼴泛使⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储
相同特性：逻辑结构和物理结构相同

  • 逻辑结构:人为想象出来的数组的组织结构
  • 物理结构:数组在内存的存储形式

2. 顺序表

2.1 概念与结构

概念：顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组存储。
在这里插入图片描述

顺序表和数组的区别？
顺序表的底层结构是数组，对数组的封装，实现了常⽤的增删改查等接⼝。

2.2分类

  • 静态顺序表：数组是定长的（往往不使用）
typedef int SLDatatype;//当想要更改数组元素类型时可以直接更改
//静态顺序表
typedef struct SeqList {
	SLDatatype array [N];
	int size;
};
  • 动态顺序表:数组是根据需求重新开辟的
typedef int SLDatatype;
typedef struct SeqList {
	SLDatatype *arr;
	int capacity;//容量
	int size;//有效数据个数
}SL;

对数组封装我们还提供了两个属性容量和有效数据个数，当数组没有初始化时都是一些垃圾值，我们通过size可以标识数组中有效的数据个数，而容量对静态顺表表中就是定长数组的大小，对动态顺序表中则需要额外开辟。

2.3动态顺表表的实现

初始化 void SLInitialize(SL*s);

销毁 void SLDestroy(SL*s );

打印顺序表 void SLPrint(SL* ps);

插入数据 检查容量 void SLCheckCapacity(SL* ps)； 尾插 void SLPushBack(SL*s,
SLDatatype x);

头插 void SLPushFront(SL*s, SLDatatype x);

尾删 void SLPopBack(SL* s);

头删 void SLPopFront(SL* s);

在指定位置插入数据 void SLInsert(SL* s, SLDatatype x, int pos);

在指定位置删除数据 void SLErase(SL* s,int pos);

查找数据 int SLFind(SL* s, SLDatatype x);

编写代码

void SLInitialize(SL* ps)
{
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

形参应为传址否则我们只是对实参进行了拷贝并没有真实修改实参

void SLDestroy(SL* ps)
{
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

一定要注意销毁顺序表时ps不能为空指针因为我们不能对空指针进行解引用（->）操作或者简便来写assert(ps)下同

void SLCheckCapacity(SL* ps)
{
	//判断空间是否充足
	if (ps->size == ps->capacity)
	{
		//增容//0*2 = 0
		//若capacity为0，给个默认值，否则×2倍
		int NewCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDatatype* tmp = (SLDatatype*)realloc(ps->arr, NewCapacity * sizeof(SLDatatype));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = NewCapacity;
	}
}

我们可能遇到capacity为0的情况此时我们可以用一个三目操作符对当capacity为0时提供一个默认值，我们扩容往往是进行二倍的扩容（这会造成空间的浪费，但是对内存反复的进行realloc会导致性能的下降，我们取其轻，同时realloc可能会开辟失败，为了保证程序的鲁棒性我添加了if条件，当新开辟的空间不为空指针，我们再将原数组指向新开辟的空间）

void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

void SLPushBack(SL*ps, SLDatatype x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->arr[ps->size++] = x;
}

进行插入操作时一定要检查容量是否充足，插入新数据时size即为下标的位置，同时插入操作不要忘记对size++
时间复杂度为O（1）


void SLPushFront(SL* ps, SLDatatype x)
{
	assert(ps);
	SLCheckCapacity(ps);
	//数据整体后移
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i-1];
	}
	ps->arr[0] = x;

	ps->size++;
}

时间复杂度为O（N）


void SLPopBack(SL* ps)
{
	assert(ps && ps->size);
	ps->size--;
}

时间复杂度为O(1)

void SLPopFront(SL* ps)
{
	assert(ps && ps->size);
	for (int i = 0; i < ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

时间复杂度为O（N）


void SLInsert(SL* ps, SLDatatype x, int pos)
{
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	for (int i = ps->size; i >pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[ps->size] = x;
	ps->size++;

}


void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size&& ps->size);
	for (int i=pos; i < ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i+1];
	}
	ps->size--;
}

时间复杂度为O(N )(最坏情况下)


int SLFind(SL* ps, SLDatatype x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
			return i;
	}
	return -1;
}

2.4 顺序表问题与思考

• 中间/头部的插⼊删除，时间复杂度为O(N)
• 增容需要申请新空间，拷⻉数据，释放旧空间。会有不⼩的消耗。
• 增容⼀般是呈2倍的增⻓，势必会有⼀定的空间浪费。例如当前容量为100，满了以后增容到200，
我们再继续插⼊了5个数据，后⾯没有数据插⼊了，那么就浪费了95个数据空间。

3.单链表

3.1 概念与结构

概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的
指针链接次序实现的（人为实现）。
在这里插入图片描述
在这里插入图片描述

3.3.1结点

与顺序表不同的是，链表⾥的每节"⻋厢"都是独⽴申请下来的空间，我们称之为“结点”
结点的组成主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。
图中指针变量 plist保存的是第⼀个结点的地址，我们称plist此时“指向”第⼀个结点，如果我们希望
plist“指向”第⼆个结点时，只需要修改plist保存的内容为0x0012FFA0。
链表中每个结点都是独⽴申请的（即需要插⼊数据时才去申请⼀块结点的空间），我们需要通过指针
变量来保存下⼀个结点位置才能从当前结点找到下⼀个结点。

3.1.2 链表的性质

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

3.2 实现单链表

typedef int SLTDataType;

定义结点结构;
typedef struct SListNode {
SLTDataType data;
struct SListNode* next;}SLTNode;

链表的打印
void SLTPrint(SLTNode*);
申请新结点 SLTNode* SLTBuyNode(SLTDataType);
插入数据
尾插
void SLTPushBack(SLTNode**, SLTDataType);
头插
voidSLTPushFront(SLTNode** , SLTDataType );

删除
尾删
void SLTPopBack(SLTNode**);
头删
void SLTPopFront(SLTNode**);

查找
SLTNode* SLTFind(SLTNode*, SLTDataType);

在指定位置之前插入数据
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);

编写代码

注意我这里用的都是二级指针，因为你想改变实参就一定要传地址，实参是一个一级指针要想改变它传参必须是传一个二级指针。同时插入等操作都应该先把新结点的指向确立

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

使用一个临时指针来改变进入循环而不是使用头指针（下同）

SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	node->data = x;
	node->next = NULL;

	return node;
}

void SLTPushBack(SLTNode**pphead, SLTDataType x)
{
	//申请新结点
	SLTNode*NewNode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = NewNode;
	}
	//尾结点->新结点
	//找尾结点
	else
	{
		SLTNode* pcur = *pphead;
		while (pcur->next)
		{
			pcur = pcur->next;
		}
		pcur->next = NewNode;
	}
}

注意思考链表为空的情况，因为链表为空时找尾结点就对空指针解引用了

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//申请新结点
	SLTNode* NewNode = SLTBuyNode(x);
	//进行头插
	NewNode->next = *pphead;
	*pphead = NewNode;
}

void SLTPopBack(SLTNode** pphead)
{
	//链表为空不可以删除
	assert(pphead && *pphead);
	//处理链表只有一个结点的情况
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//找prev和ptail
		SLTNode* ptail = *pphead;
		SLTNode* prev = NULL;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}

尾删要找尾结点和它的前驱结点，但是只有一个结点的情况下没有前驱结点

void SLTPopFront(SLTNode** pphead)
{
	//链表为空不可以删除
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = NULL;
	*pphead = next;
}

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		else
		{
			pcur = pcur->next;
		}
	}
	return NULL;
}

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
		SLTPushFront(pphead, x);
	else
	{
		SLTNode* prev = *pphead;
		SLTNode* NewNode = SLTBuyNode(x);
			while (prev->next != pos)
			{
				prev = prev->next;
			}
		prev->next = NewNode;
		NewNode->next = pos;
	}
}

插入指定结点影响的是前一个结点，但是头结点没有前一个结点因此我们要判断pos为头结点的情况

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* NewNode = SLTBuyNode(x);
	NewNode->next = pos->next;
	pos->next = NewNode;
}

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead&&*pphead);
	assert(pos);
	if (*pphead = pos)
		SLTPopBack(pphead);
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

删除当前结点影响的是它的前驱结点，但是头指针没有前驱结点所有要单独考虑

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

void SListDestroy(SLTNode** pphead)
{
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

4. 双向链表

4.1 概念与结构

在这里插入图片描述

注意：这⾥的“带头”跟“头结点”是两个概念，带头链表⾥的头结点，实际为“哨兵位”，哨兵位结点不存储任何有效元素，只是站在这⾥“放哨"的

4.2双向链表的实现

#pragma once

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

定义双向链表节点的结构
typedef int LTDataType;
typedef struct ListNode
{
LTDataType data;
struct ListNode* next;
struct ListNode* prev;
}LTNode;

为了保持接口的一致性，优化接口都为一级指针
初始化
void LTInit(LTNode** pphead);
LTNode* LTInit();

销毁
void LTDesTroy(LTNode** pphead);
void LTDesTroy2(LTNode* phead);//传一级，需要手动将plist置为NULL

void LTPrint(LTNode* phead);

插入
void LTPushBack(LTNode* phead, LTDataType x);
void LTPushFront(LTNode* phead, LTDataType x);

删除
void LTPopBack(LTNode* phead);
void LTPopFront(LTNode* phead);

bool LTEmpty(LTNode* phead);

LTNode* LTFind(LTNode* phead, LTDataType x);
在pos位置之后插入节点
void LTInsert(LTNode* pos, LTDataType x);
删除指定位置节点
void LTErase(LTNode* pos);

编写代码

#define _CRT_SECURE_NO_WARNINGS 1
#include"list.h"
ListNode* BuyNode(LTDateType x)
{
	ListNode* NewNode = malloc(sizeof(ListNode));
	if (NewNode == NULL)
	{
		perror("Malloc Fail!");
		exit(1);
	}
	NewNode->data = x;
	NewNode->next = NewNode->prev = NewNode;
	return NewNode;
}

//void LTInitialise(ListNode** pphead)
//{
//	//创建一个头结点（哨兵卫）
//	*pphead = BuyNode(-1);
//}
ListNode* LTInitialise(ListNode*phead)
{
  phead=BuyNode(-1)
  return BuyNode(-1);
}

void LTDestroy(ListNode** pphead)
{
	assert(*pphead && pphead);
	ListNode*pcur = (*pphead)->next;
	while (pcur!=*pphead)
	{
		ListNode* Next = pcur->next;
		free(pcur);
		pcur = Next;
	}
	free(*pphead);
	*pphead = NULL;
	pcur = NULL;
}
//void LTDestroy(ListNode* phead)
//{
//	assert(phead);
//	ListNode* pcur = phead->next;
//	while (pcur != phead)
//	{
//		ListNode* Next = pcur->next;
//		free(pcur);
//		pcur = Next;
//	}
//	free(phead);
//	phead = NULL;
//	pcur = NULL;//实参手动置为空或者重新封装一个函数
//}

void LTPushBack(ListNode* phead, LTDateType x)
{
	assert(phead);
	ListNode* NewNode = BuyNode(x);
	NewNode->next = phead;
	NewNode->prev = phead->prev;
	phead->prev->next = NewNode;
	phead->prev = NewNode;
}

void LTPushFront(ListNode* phead, LTDateType x)
{
	assert(phead);
	ListNode* NewNode = BuyNode(x);
	NewNode->prev = phead;
	NewNode->next = phead->next;
	phead->next->prev = NewNode;
	phead->next = NewNode;
}

//打印双向链表
void LTPrint(ListNode* phead)
{
	ListNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

bool LTEmpty(ListNode* phead)
{
	if (phead->next == phead)
		return false;
	else
		return true;
}

void LTPopBack(ListNode* phead)
{
	assert(phead);
	assert(LTEmpty(phead));
	ListNode* del = phead->prev;
	ListNode* prev = del->prev;
	prev->next = phead;
	phead->prev = prev;
	free(del);
	del = NULL;
}

void LTPopFront(ListNode* phead)
{
	assert(phead);
	assert(LTEmpty(phead));
	ListNode* del = phead->next;
	ListNode* Next = del->next;
	Next->prev = phead;
	phead->next = Next;
	free(del);
	del = NULL;
}

ListNode* LTFind(ListNode* phead, LTDateType x)
{
	ListNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

void LTInsert(ListNode* pos,LTDateType x)
{
	assert(pos);
	ListNode* NewNode = BuyNode(x);
	NewNode->next = pos->next;
	NewNode->prev = pos;
	pos->next->prev = NewNode;
	pos->next = NewNode;
}

void LTErase(ListNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

	free(pos);
	pos = NULL;
}

因为只有初始化结点和销毁结点我们需要对原来的实参进行修改，所以只有它传参是二级指针，而其他都是一级指针但是为了保持接口的一致性，优化接口都为一级指针。

尽管双向链表看起来比单向链表难，但实现起来却很简单，因为双向链表绝对有前驱结点和下一个结点，不会出现单链表时任意位置插入删除要判断是不是头结点啊（在单向链表中头结点没有前驱结点）的情况，也不用对链表为空单独考虑，因为当链表为空时它仍然有一个哨兵位

Yusei_0523
关注
  • 33
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构】顺序表与链表
洛初_Rakuui的博客
12-05 190
顺序表存储 原理： 顺序表存储是将数据元素放到一块连续的内存存储空间，相邻数据元素的存放地址也相邻(数组就是典型的顺序表) 优点： 空间利用率高。（局部性原理，连续存放，命中率高） 存取速度高效，通过下标来直接存储。 缺点： 插入和删除比较慢，比如：插入或者删除一个元素时，整个表需要遍历移动元素来重新排一次顺序。 不可以增长长度，有空间限制,当需要存取的元素个数可能多于顺序表的...
数据结构--顺序表&链表
imp0128的博客
07-26 371
数据结构--顺序表&链表1.线性表2.顺序表2.1概念及基本结构2.2 接口实现 1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以顺序结构和链式结构的形式存储。 特征： 对于同一个线性表，其每一个数据元素的值虽然不同，但必须具有相同的数据类型； 数据元素之间具有一
初阶数据结构—顺序表和链表
Awkwardx的博客
05-10 1183
新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点。假设A链表相交之前的节点数是a，B链表相交之前的节点数是b，相交(含相交节点)之后的节点是c。由于快指针的速度是慢指针的2倍，相当于同样的时间快指针走过的距离（即链表的长度）是慢指针的两倍。假设链表长度为n，快指针先走k步，那么快慢指针的距离就是k，然后快慢指针同时往后走，那么当快指针遍历完链表时，慢指针走的距离就是n-k。
初阶数据结构——顺序表和链表(单链表)
Adz1119的博客
04-28 811
初阶数据结构——顺序表和链表
数据结构初阶数据结构初阶
02-12
2. **栈和队列**：栈是后进先出（LIFO）的数据结构，常用于函数调用、表达式求值等；队列是先进先出（FIFO）的数据结构，常用于任务调度和消息传递。 3. **树形数据结构**：包括二叉树、平衡树、堆等。二叉树每个...
C语言初阶-(单向链表)
03-08
适用于数据结构初学者使用 线性表的单链表存储结构，整个链表的存取必须从头指针开始进行，头指针指示链表中第一个结点 (第一个数据元素的存储映像，也称首元结点)的存储位置。同时，由于最后一个数据元素没有 直接...
【数据结构初阶】顺序表
m0_60624580的博客
10-25 2256
前言前言线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表的数据在存储的时候是成一条线性相互紧邻存放的。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，是连续的一条直线。但是在物理结构上（内存）并不一定是连续的。线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是在物理上是线性连续的，链表是不连续的。
C语言实现数据结构算法初阶算法
06-15
1. **顺序表**：顺序表是一种基本的数据结构，它的元素在内存中是连续存储的。C语言中，我们可以使用数组来实现顺序表。在实际应用中，插入和删除操作可能涉及大量的元素移动，效率较低，但在特定场景如全量数据处理...
[数据结构笔记]二叉树初阶
niokia0v0的博客
01-28 1921
null
数据结构 数据结构
qq_69971969的博客
09-03 297
空间不连续 访问数据不方便（需要遍历） 插入和删除比较方便 不需要预分配，动态增长。空间连续 访问数据方便 插入和删除需要移动大量数据 需要预分配存储空间。数据的物理结构：数据的逻辑结构在计算机内存中的存储方式。线性结构：一对一的元素关系（数组，链表。图形结构：元素之间的多对多的关系（网状结构）数据的逻辑结构：数据元素与元素之间的关系。树型结构：一对多的元素关系（二叉树）链式存储：一段非连续的空间。程序：数据结构 + 算法。顺序存储：一段连续的空间。数据与数据之间的关系。
冒泡排序；选择排序；插入排序；快排；判断大小端；位运算
qq_56797509的博客
09-03 189
假设有10个元素a[1]-a[10]，将a[1]与a[2]-a[10]比较，若a[1]比a[2]-a[10]都小，则不进行交换。若a[2]-a[10]中有一个以上比a[1]小，则将其中最小的一个与a[1]交换，此时a[1]就存放了10个数中最小的一个。同理，第二轮拿a[2]与a[3]-a[10]比较，a[2]存放a[2]-a[10]中最小的数，以此类推。选一个key值（选第一个值），从后面选一个比其小的值，从前面选一个比其大的值，key值放中间。1.小端：内存低地址存放低数据位称为内存小端。
嵌入式开发高频面试题——第四章 常见算法（上）
Java、C语言、嵌入式开发，计算机科学与技术专业
09-03 640
【代码】嵌入式开发高频面试题——第四章 常见算法（上）
【笔记】数据结构——8月27日
m0_52024881的博客
08-27 1384
考研用笔记
数据结构基本知识
weixin_63722559的博客
09-03 561
--------》内存（存储）
MATLAB 中双引号 ““ 和单引号 ‘‘ 的区别详解
2202_75569688的博客
09-03 279
在 MATLAB 中，双引号""和单引号''都可以用来表示字符串，但它们的作用和底层类型是不同的。理解它们之间的区别，对于正确使用字符串处理功能非常重要。本文将深入探讨 MATLAB 中""和''的区别，以及在实际编程中的应用场景。
数据结构---链表
2301_78040391的博客
09-03 189
【代码】数据结构---链表。
【数据结构初阶】——栈和队列
最新发布
2302_78420373的博客
09-03 703
小伙伴们，大家好呀，今天我们学习的是数据结构中的栈和队列之前我们写过【栈和队列的OJ题】，但是有很多小伙伴不知道栈和队列讲的是什么，咱们就好好聊聊这些就是栈和队列(初阶)的全部内容了，要是想做一点题的可以看看这篇哦【栈和队列OJ题】
【数据结构】-----哈希
m0_73470633的博客
08-29 1731
一文看懂哈希结构！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值