【数据结构---03】链表简述和链表的相关操作(初始化,插入,删除,查找,判空.销毁)~~~~~

最新推荐文章于 2023-07-04 18:49:12 发布
最新推荐文章于 2023-07-04 18:49:12 发布
阅读量1k 收藏 8
点赞数 4
分类专栏： 数据结构初阶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44749767/article/details/89930928
版权

目录

 

什么是链表和链表的分类:

链表:

概念:

数据结构中链表示意图:

无头单向非循环链表：

    带头双向循环链表：

单链表逻辑结构示意图:

带头结点和不带头结点链表:

概念:

带头结点单链表:

插入操作如下

 

删除操作如下

统一空表和非空表的处理

不带头结点单链表:

插入操作如下

删除操作如下

统一空表和非空表的处理:

单链表基本操作:

链表初始化:

头插:

尾插:

头删:

尾删:

普通插入和删除:

结点查找:

结点个数:

链表判空和清空:

链表销毁:

SList.h:

main.c:

运行结果:

什么是链表和链表的分类:

链表:

  1. 线性表可分为顺序存储结构和链式存储结构两种。
  2. 顺序存储结构的特点是逻辑关系上相邻的两个元素在物理位置上也相邻;
  3. 链式存储结构的特点是不需要逻辑上相邻的元素在物理位置上也相邻。
  4. 线性链表可分为单链表,双链表,带头结点单链表,不带头结点单链表,循环单链表,非循环单链表,无头单向非循环链表,带头双向循环链表;

 

概念:

  1. 链表是一种物理存储结构上非连续,非顺序的存储结构;
  2. 链表是一个练市
  3. 数据元素的逻辑顺序,是通过链表的指针链接次序实现的;

数据结构中链表示意图:

  1.  

  • 无头单向非循环链表：

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

  •     带头双向循环链表：

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

单链表逻辑结构示意图:

带头结点和不带头结点链表:

概念:

  1. 头指针：通常使用“头指针”来标识一个链表,头指针为NULL的时表示一个空链表。
  2. 头结点：在单链表的第一个结点之前附加一个结点，称为头结点。
  3. 头结点的Data域可以不设任何信息，也可以记录表长等相关信息。
  4. 链表可以没有头结点，但是必须要有头指针;
  5. 因为要用头指针来标识一个链表。设链表的头指针为pHead。
  6. 除了头结点之外，还需要一个指向链表一般元素的指针pNode
  7. 因为pHead只能指向表头，不能指向其他元素，故需要另设指针;

带头结点单链表:

  1. 若使用头结点，则第1个位置的插入和删除都是对p—>next进行操作，而不用动p本身;

  • 插入操作如下

 

  1. p指向要插入结点的前驱结点，若要插入的结点为第1个位置，则其前驱结点就是头结点，此时p指向头结点。
  2. 让新结点s的next指向p的next，即s—>next = p—>next;
  3. 让p—>next指向s，即p—>next = s;

 

 

  • 删除操作如下

 

  1. p指向要删除结点的前驱结点，若要删除的结点为第1个位置，则其前驱结点就是头结点，此时p指向头结点。
  2. 让临时指针q指向要删除的结点，即q = p—>next；
  3. 让p的next指向要删除结点的下一个结点，即p—>next = q—>next；
  4. 释放q的空间，即free(q);

  • 统一空表和非空表的处理

  1. 若使用头结点，无论表是否为空，头指针都指向头结点，也就是*LNode类型，对于空表和非空表的操作是一致的。

 

 

  • 不带头结点单链表:

若没有头结点，在第1个位置插入或删除时，需要动头指针。

 

  • 插入操作如下

  1. 判断要插入的是否是第1个位置，若是需要特殊处理。
  2. 若是第1个位置，让新结点s的next指向头指针PtrL。
  3. return s，此时s作为链表的头指针。此时的更新了链表的头指针。
  4. 若不是第1个位置，首先找到要插入结点的前驱结点，让p指向这个前驱结点。
  5. 让新结点s的next指向p的next，即s—>next = p—>next;
  6. 让p—>next指向s，即p—>next = s;
  7. return PtrL，此时PtrL还是作为链表的头指针，没有被修改，但考虑到一致性需要这样写。

  • 删除操作如下

 

  1. 判断要删除的是否是第1个位置，若是需要特殊处理。
  2. 若是第1个位置，让s指向要删除的结点。首先判断PtrL是否为空，若是直接return NULL;若不为空，则将链表的头结点挪到下一个位置，即PtrL = PtrL—>next；
  3. free(s);然后return PtrL
  4. 若不是第1个位置，首先找到要删除结点的前驱结点，让p指向这个前驱结点。
  5. 让临时指针q指向要删除的结点，即q = p—>next；
  6. 让p的next指向要删除结点的下一个结点，即p—>next = q—>next；
  7. 释放q的空间，即free(q);
  8. return PtrL

统一空表和非空表的处理:

  1. 若不使用头结点，当表非空时，头指针指向第1个结点的地址，即*LNode类型;
  2. 但是对于空表，头指针指向的是NULL，此时空表和非空表的操作是不一致的。

单链表基本操作:

  1.  
#pragma once
typedef int SDataType;    //int 数据类型重定义

// 链表的节点 
typedef struct SListNode
{
	SDataType _data;  //数据域
	struct SListNode* _pNext;   //指针域
}Node, *PNode;


// 链表的结构，给一个头指针保存链表第一个节点的地址 
typedef struct SList
{
	PNode _pHead; // 指向链表中的第一个节点 
}SList, *PSList;

  • 链表初始化:

  1.  链表初始化;
  2. 创建新结点:
// 链表的初始化 

void SListInit(SList* s) {
	assert(s);
	s->_pHead = NULL;
}
//创建新的节点
PNode BuySListNode(SDataType data) {
	PNode pNewNode = (PNode)malloc(sizeof(Node));

	if (NULL == pNewNode) {
		assert(0);
		return;
	}
	pNewNode->_data = data;
	pNewNode->_pNext = NULL;
	return pNewNode;
}

  • 头插:

  1.  
// 在链表s第一个节点前插入值为data的节点 
void SListPushFront(SList* s, SDataType data) {
	assert(s);
        PNode pNewNode = BuySListNode(data);
	pNewNode->_pNext = s->_pHead;
	s->_pHead = pNewNode;
}

  • 尾插:

// 在链表s最后一个节点后插入值为data的节点 
void SListPushBack(SList* s, SDataType data) {
	assert(s);
	PNode pNewNode = BuySListNode(data);//创建一个新的节点
	if (NULL == s->_pHead) {
		s->_pHead = pNewNode;//如果链表为空,则让头节点指向新建立的节点
	}
	else
	{
		PNode pCur = s->_pHead;//创建一个变量
		while (pCur->_pNext) {
			pCur = pCur->_pNext;//搜索最后一个节点为空时停下
		}
		pCur->_pNext = pNewNode;
	}
}

  • 头删:

// 删除链表s的第一个节点 
void SListPopFront(SList* s) {
	assert(s);
	if (NULL == s->_pHead) {
		return;
	}
	PNode pDelNode = s->_pHead;
	s->_pHead = s->_pHead->_pNext;
	free(pDelNode);
}

  • 尾删:

// 删除链表s最后一个节点 
void SListPopBack(SList* s) {
	assert(s);
	PNode pCur = s->_pHead;
	if (pCur == NULL) {
		return;
	}
	if (pCur->_pNext == NULL) {
		free(pCur);
		s->_pHead = NULL;
		return;
	}
	while (pCur->_pNext->_pNext) {
		pCur = pCur->_pNext;//寻找下下一个元素
	}
	free(pCur->_pNext);//删除指针后需将其置空
	pCur->_pNext = NULL;
}

普通插入和删除:

// 在链表的pos位置后插入值为data的节点 
void SListInsert(PNode pos, SDataType data) {
	if (pos == NULL) {
		return;
	}
	PNode pNewNode = BuySListNode(data);
	pNewNode->_pNext = pos->_pNext;
	pos->_pNext = pNewNode;
}

// 删除链表s中pos位置的节点 
void SListErase(SList* s, PNode pos) {
	assert(s);
	if (NULL == pos || NULL == s->_pHead) {
		return;
	}
	if (pos == s->_pHead) {
		s->_pHead = s->_pHead->_pNext;
	}
	else
	{
		PNode pPrePos = s->_pHead;
		while (pPrePos && pPrePos->_pNext != pos)
			pPrePos = pPrePos->_pNext;
		if (pPrePos)
			pPrePos->_pNext = pPrePos->_pNext->_pNext;
	}
	free(pos);
}

  • 结点查找:

// 在链表中查找值为data的节点，找到返回该节点的地址，否则返回NULL 
PNode SListFind(SList* s, SDataType data) {
	assert(s);
	PNode pCur = s->_pHead;
	while (pCur) {
		//pCur = pCur->_pNext;
		//查找时考虑每个元素都被遍历到,条件顺序考虑好
		if (data == pCur->_data) {
			return pCur;
		}
		pCur = pCur->_pNext;
	}
	return NULL;
}

  • 结点个数:

// 获取链表中有效节点的个数 
size_t SListSize(SList* s) {
	assert(s);
	size_t count = 0;
	PNode pCur = s->_pHead;
	while (pCur) {
		count++;
		pCur = pCur->_pNext;
	}
	return count;
}

  • 链表判空和清空:

// 检测链表是否为空 
int SListEmpty(SList* s) {
	assert(s);
	return NULL == s->_pHead;
}

// 将链表中有效节点清空 
void SListClear(SList* s) {
	assert(s);
	while (SListSize(s)) {
		SListPopBack(s);
	}
	free(s->_pHead);
}

  • 链表销毁:

  • // 销毁链表 
void SListDestroy(SList* s) {
	assert(s);
	while (SListSize(s)) {
		SListPopBack(s);
	}
	free(s->_pHead);
}

void PritfSList(SList* s) {
	assert(s);
	if (s->_pHead == NULL) {
		printf("NULL\n");
		return;
	}
	PNode pCur = s->_pHead;
	while (pCur) {
		printf("%d---->", pCur->_data);
		pCur = pCur->_pNext;
	}
	printf("\n");
}

    SList.h:

#pragma once
typedef int SDataType;    //int 数据类型重定义

// 链表的节点 
//定义一个结构体
typedef struct SListNode
{
	SDataType _data;  //_date 中存放结点数据域
	struct SListNode* _pNext;   //指针域,指向后继结点的指针
}Node, *PNode;
//自定义方式将结构定义为Node类型  在定义一个指向Node的指针类型变量Node *L  等价于 PNode L


// 链表的结构，给一个头指针保存链表第一个节点的地址 
typedef struct SList
{
	PNode _pHead; // 指向链表中的第一个节点 
}SList, *PSList;


// 链表的初始化 
void SListInit(SList* s);

// 在链表s最后一个节点后插入值为data的节点 
void SListPushBack(SList* s, SDataType data);

// 删除链表s最后一个节点 
void SListPopBack(SList* s);

// 在链表s第一个节点前插入值为data的节点 
void SListPushFront(SList* s, SDataType data);

// 删除链表s的第一个节点 
void SListPopFront(SList* s);

// 在链表的pos位置后插入值为data的节点 
void SListInsert(PNode pos, SDataType data);

// 删除链表s中pos位置的节点 
void SListErase(SList* s, PNode pos);

// 在链表中查找值为data的节点，找到返回该节点的地址，否则返回NULL 
PNode SListFind(SList* s, SDataType data);

// 获取链表中有效节点的个数 
size_t SListSize(SList* s);

// 检测链表是否为空 
int SListEmpty(SList* s);

// 将链表中有效节点清空 
void SListClear(SList* s);

// 销毁链表 
void SListDestroy(SList* s);

//打印函数
void PritfSList(SList* s);

  • main.c:

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "SList.h"


// 链表的初始化 

void SListInit(SList* s) {
	assert(s);
	s->_pHead = NULL;
}
//创建新的节点
PNode BuySListNode(SDataType data) {
	PNode pNewNode = (PNode)malloc(sizeof(Node));

	if (NULL == pNewNode) {
		assert(0);
		return;
	}
	pNewNode->_data = data;
	pNewNode->_pNext = NULL;
	return pNewNode;
}

// 在链表s最后一个节点后插入值为data的节点 
void SListPushBack(SList* s, SDataType data) {
	assert(s);
	PNode pNewNode = BuySListNode(data);//创建一个新的节点
	if (NULL == s->_pHead) {
		s->_pHead = pNewNode;//如果链表为空,则让头节点指向新建立的节点
	}
	else
	{
		PNode pCur = s->_pHead;//创建一个变量用于寻找
		while (pCur->_pNext) {
			pCur = pCur->_pNext;//搜索最后一个节点为空时停下
		}
		pCur->_pNext = pNewNode;
	}
}

// 删除链表s最后一个节点 
void SListPopBack(SList* s) {
	assert(s);
	PNode pCur = s->_pHead;
	if (pCur == NULL) {
		return;
	}
	if (pCur->_pNext == NULL) {
		free(pCur);
		s->_pHead = NULL;
		return;
	}
	while (pCur->_pNext->_pNext) {
		pCur = pCur->_pNext;//寻找下下一个元素
	}
	free(pCur->_pNext);//删除指针后需将其置空
	pCur->_pNext = NULL;
}

// 在链表s第一个节点前插入值为data的节点 
void SListPushFront(SList* s, SDataType data) {
	assert(s);
	
	PNode pNewNode = BuySListNode(data);
	pNewNode->_pNext = s->_pHead;
	s->_pHead = pNewNode;
}

// 删除链表s的第一个节点 
void SListPopFront(SList* s) {
	assert(s);
	if (NULL == s->_pHead) {
		return;
	}
	PNode pDelNode = s->_pHead;
	s->_pHead = s->_pHead->_pNext;
	free(pDelNode);
}

// 在链表的pos位置后插入值为data的节点 
void SListInsert(PNode pos, SDataType data) {
	if (pos == NULL) {
		return;
	}
	PNode pNewNode = BuySListNode(data);
	pNewNode->_pNext = pos->_pNext;
	pos->_pNext = pNewNode;
}

// 删除链表s中pos位置的节点 
void SListErase(SList* s, PNode pos) {
	assert(s);
	if (NULL == pos || NULL == s->_pHead) {
		return;
	}
	if (pos == s->_pHead) {
		s->_pHead = s->_pHead->_pNext;
	}
	else
	{
		PNode pPrePos = s->_pHead;
		while (pPrePos && pPrePos->_pNext != pos)
			pPrePos = pPrePos->_pNext;
		if (pPrePos)
			pPrePos->_pNext = pPrePos->_pNext->_pNext;
	}
	free(pos);
}

// 在链表中查找值为data的节点，找到返回该节点的地址，否则返回NULL 
PNode SListFind(SList* s, SDataType data) {
	assert(s);
	PNode pCur = s->_pHead;
	while (pCur) {
		//pCur = pCur->_pNext;
		//查找时考虑每个元素都被遍历到,条件顺序考虑好
		if (data == pCur->_data) {
			return pCur;
		}
		pCur = pCur->_pNext;
	}
	return NULL;
}

// 获取链表中有效节点的个数 
size_t SListSize(SList* s) {
	assert(s);
	size_t count = 0;
	PNode pCur = s->_pHead;
	while (pCur) {
		count++;
		pCur = pCur->_pNext;
	}
	return count;
}

// 检测链表是否为空 
int SListEmpty(SList* s) {
	assert(s);
	return NULL == s->_pHead;
}

// 将链表中有效节点清空 
void SListClear(SList* s) {
	assert(s);
	while (SListSize(s)) {
		SListPopBack(s);
	}
	free(s->_pHead);
}

// 销毁链表 
void SListDestroy(SList* s) {
	assert(s);
	while (SListSize(s)) {
		SListPopBack(s);
	}
	free(s->_pHead);
}

void PritfSList(SList* s) {
	assert(s);
	if (s->_pHead == NULL) {
		printf("NULL\n");
		return;
	}
	PNode pCur = s->_pHead;
	while (pCur) {
		printf("%d-->", pCur->_data);
		pCur = pCur->_pNext;
	}
	printf("\n");
}


int main() {

	SList s;
	SListInit(&s);//链表初始化
	//尾插
	SListPushBack(&s, 1);
	SListPushBack(&s, 2);
	SListPushBack(&s, 3);
	SListPushBack(&s, 4);
	SListPushBack(&s, 5);
	SListPushBack(&s, 6);
	PritfSList(&s);
	//头删
	SListPopFront(&s);
	PritfSList(&s);
	//尾删
	SListPopBack(&s);
	PritfSList(&s);
	//头插
	SListPushFront(&s, 9);
	PritfSList(&s);
	
	printf("%d\n", SListEmpty(&s));
	printf("%d\n", SListSize(&s));

	printf("%p\n", SListFind(&s, 9));
	printf("%p\n", SListFind(&s, 2));
	printf("%p\n", SListFind(&s, 3));
	printf("%p\n", SListFind(&s, 4));
	printf("%p\n", SListFind(&s, 5));

	//指定位置插入
	SListInsert(SListFind(&s, 3), 8);
	PritfSList(&s);

	//指定位置删除
	SListErase(&s, SListFind(&s, 3));
	PritfSList(&s);

	SListClear(&s);
	PritfSList(&s);

	SListDestroy(&s);
	PritfSList(&s);
	system("pause");
	return 0;
}

  • 运行结果:

 

 


 

 

 

 

霜前月下
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】第二章线性表：单链表的定义、插入和删除、查找、建立
weixin_37706349的博客
10-13 3241
2.3.1 单链表的定义 用链式存储的线性表统称为链表，本小节将会依次学习单链表、双链表、循环链表、静态链表。 一、什么是单链表 二、用代码定义一个单链表 （1）结构体变量和结构体类型的定义 菜鸟教程链接： 结构体变量和结构体类型的定义 | 菜鸟教程 typedef 关键字，将 struct LNode 这个结构体类型名字重新定义为 LNode 和 *LinkList（用来表示指向struct LNmde的指针）； 下次想定义一个 struct LNode 结构体变量时，直接 L..
数据结构-链表.pdf
最新发布
04-15
数据结构-链表 单向链表，双向链表、循环链表等
【数据结构与算法】分别以邻接矩阵和邻接表作为存储结构实现以下操作：1.增加一个新顶点v、2.删除顶点v及其相关的边、3.增加一条边＜v，w＞、4.删除一条边＜v，w＞
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
07-04 5103
分别以邻接矩阵和邻接表作为存储结构，实现以下操作：1.增加一个新顶点v、2.删除顶点v及其相关的边、3.增加一条边、4.删除一条边
单链表的定义和操作(超详细——C语言)
weixin_47783699的博客
10-15 3037
你还在为学习链表而烦恼？你还在为老师讲的不够简单？？你是否还在苦苦挣扎着。跟我走,我带你征服链表。
数据结构之邻接表的实现
weixin_47249161的博客
09-15 165
666
关于delete free 与 null
boshuzhang的专栏
01-27 641
delete null; free(null); 这样写是合法的，但是原则上不要写出这样的代码， 最好是先判空再对指针进行释放（注：主要是为了可读性和可维护性）.
数据结构--数组、单链表和双链表介绍以及双向链表 数组和链表.pdf
04-18
数据结构--数组、单链表和双链表介绍以及双向链表 数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。数组、链表是两种常见的数据结构，下面将对它们进行介绍。 一、数组 数组是数据结构中的一...
数据结构实验三-有关线性链表的操作_数据结构实验三-有关线性链表的操作_
10-03
数据结构实验三-有关线性链表的操作，建立线性链表，初始化线性链表，插入元素，删除元素，清空线性链表，摧毁线性链表
比特数据结构课件-Lesson3-顺序表-链表.pdf
07-07
- **接口实现**：包括初始化、检查容量、插入、删除、查找等操作。在实际应用中，由于静态顺序表的空间利用率问题，通常采用动态顺序表。 - **数组相关面试题**：涉及原地移除元素、删除排序数组中的重复项和合并...
数据结构-使用javascript讲解数据结构之链表.zip
02-12
数据结构 数据结构_使用javascript讲解数据结构之链表
C语言实现顺序的建立、查找、插入、删除等基本操作
03-27
C语言实现顺序的建立、查找、插入、删除等基本操作
线性表的实现_代码(初始化、判断是否为空表、求表长、输出表、插入、删除、查找、修改、清空表、释放表空间、退出
10-16
线性表的实现_代码(初始化、判断是否为空表、求表长、输出表、插入、删除、查找、修改、清空表、释放表空间、退出。
C语言实现链表，创建、插入、查找、删除、遍历等基本操作
09-13
C与语言实现链表的创建、插入（头插法、尾插法）、遍历、查找、删除操作
链表的删除结点（各种方法）
热门推荐
weixin_52307528的博客
09-15 1万+
先建立链表（代码在最后） 一、链表中删除第i个结点 int main() { int i; Node *p,*head，*k; head=setlink(); scanf("%d",&i); int v=1; for(p=head->next;p!=NULL;k=p,p=p->next) { if(v==i)break; else{ v++; } } k->next=p-&g
删除单链表中的某个节点
biu__biu_biu的博客
09-06 352
（1）无头单链表 #include #include typedef struct person { int age; struct person *next; }per; per *head_list(per *one,int num) //头插 { per *temp = (per *)malloc(sizeof(per)); temp->age =
9.2链表（三）——删除单向链表中间的某个节点，假定你只能访问该节点
shangqing1123的博客
08-03 611
/** * 功能：删除单向链表中间的某个节点，假定你只能访问该节点。 */ //直接将后继节点的数据复制到当前节点，然后删除后继节点。！！！ //若待删除节点为链表的为节点，则无解。 public static boolean deleteNode(LinkedListNode n){ if( n== null|| n. next
数据结构——图解单链表的初始化、赋值和遍历输出C语言
Suasuasua的博客
03-15 7971
一、单链表存储结构解释说明 typedef struct node{ int data; struct node *next; }Node,*Link; 1.typedef：是将结构体struct node重新定义了新的名称Node和*Link。 2.struct node *next：是让成员next指向struct node这样一个类型的指针。如下图 3.Node：例如Node p=struct node p 4.*Link：例如*Link p=struct node *p，这里的p同上面的ne
单链表的基本操作
Toss_coppt的博客
01-24 745
取值算法的基本操作是比较j和i并后移指针p，while循环体中的语句频度与位置i有关。若1≤i≤n，则频度为i-1，一定能取值成功；若i>n，则频度为n，取值失败。
单链表的相关操作（定义，初始化，插入，删除，查找，求表长）
weixin_45837835的博客
04-03 1477
单链表的相关操作定义一个单链表不带头节点的单链表带头结点的单链表按位序插入（带头结点）按位序插入（不带头结点）指定结点的后插操作指定结点的前插操作按位序删除（带头结点） 定义一个单链表 typedef struct LNode { ElemType data; struct LNode* next; }LNode, * LinkList; 不带头节点的单链表 bool InitList(LinkList& L) { L = NULL; //空表，防止脏数据 return true; } b
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，但是查找某个节点的效率较低。链表的头节点是链表的入口，尾节点的指针指向空。 以下是单向链表的基本操作： 1. 插入操作：在链表的任意位置插入一个新节点。需要修改前一个节点的指针，使其指向新节点，同时新节点的指针指向原来的下一个节点。 2. 删除操作：删除链表中的某个节点。需要修改前一个节点的指针，使其指向下一个节点，同时释放被删除节点的内存空间。 3. 查找操作：遍历链表，逐个比较节点的值，直到找到目标节点或者到达链表末尾。 4. 遍历操作：按顺序访问链表中的每个节点，可以用来打印链表或者进行其他操作。 单向链表常用于需要频繁插入和删除操作的场景，比如实现栈、队列等数据结构，也可以用于实现其他高级数据结构，如图、树等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值