数据结构C语言版 —— 二叉树的顺序存储堆的实现

已于 2023-05-28 10:31:35 修改
阅读量706 收藏 3
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c语言 算法
于 2022-12-21 13:38:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53946852/article/details/128396033
版权

文章目录

二叉树顺序结构实现(堆)

1. 堆的概念

  • 堆在物理上是一个一维数组，在逻辑上是一颗完全二叉树
  • 满足父亲节点小于等于孩子节点的叫做小堆或者小根堆
  • 满足父亲节点大于等于孩子节点的叫做大堆或者大根堆

堆的孩子和父亲的下标关系

  1. 已知父亲(parent)的下标

    • 左孩子(left)下标等于 l e f t = 2 ∗ p a r e n t + 1 left = 2*parent+1 left=2∗parent+1
    • 右孩子(right)下标等于 r i g h t = 2 ∗ p a r e n t + 2 right = 2 * parent + 2 right=2∗parent+2

  2. 已知左孩子或右孩子下标(child)

    • 父亲节点下标等于 p a r e n t = ( c h i l d − 1 ) / 2 parent = (child-1)/2 parent=(child−1)/2

在这里插入图片描述

2. 堆的基本操作

堆的向下调整算法

下面这个数组逻辑上可以看作是一棵完全二叉树，通过从根节点开的向下调整算法可以把它调整成一个堆(大堆或小堆)，向下调整算法有以有一个前提：左右子树必须是一个堆，才能调整。我这里的是实现小堆的向下调整算法。

建小堆的向下调整的基本思路就是：从堆顶开始，拿自己和较小的一个孩子进行比较大小，如果小就进行交换然后把交换的位置当作父节点继续向下调整，如果两个孩子都比自己小就停止调整，否则一直调整到叶子节点。

在这里插入图片描述

// 向下调整(小堆)
void AdjustDown(HPDataType* arr, int n, int index)
{
	int parent = index;
	int child = 2 * parent+1;
	while (parent < n)
	{
		
		//找出两个孩子里的较小的
		if (child < n && child + 1 < n && arr[child] > arr[child + 1])
		{
			child++;
		}
		// 拿较小的孩子比较和父亲比价大小
		if (child < n && arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			//说明无需调整
			break;
		}
	}
}

堆的向下调整每次调整的一个节点，假设树的高度为 h h h最坏情况下调整的次数就是 h − 1 h-1 h−1，所以向下调整的时间复杂度就是树的深度 l o g 2 ( n − 1 ) log_{2}(n-1) log2​(n−1)，最后得出 l o g 2 n log_{2}n log2​n

堆的创建

我们知道堆的向下调整算法必须满足左右子树都是一个堆，那有的时候是一个普通的数组，也就是一颗普通的完全二叉树，所以要通过建堆来让一个数组变成堆。

建堆的实现思路：从最后一个节点的父节点，也就是第一个非叶子节点的父亲开始不断向下调整，直到整课树都被调整成一个堆。

在这里插入图片描述

//向下调整建堆
int i = 0;
//从倒数第一个非叶子节点开始向下调整
for (i = (n - 2) / 2; i >= 0; --i)//n为数组元素个数
{
    AdjustDown(arr,n ,i);
}

建堆的时间复杂度

我们知道时间复杂度就是计算最坏的时间复杂度，实际上就是计算一个满二叉树，这样每一棵树都会进行调整。

假设这一棵树的高度是 h h h

  1. 第一层的节点个数就是 2 0 2^{0} 20、第二层 2 1 2^{1} 21、第三层 2 2 2^{2} 22，第 n n n层就有 2 n − 1 2^{n-1} 2n−1个，那么最后一层就有 2 h − 1 2^{h-1} 2h−1个节点
  2. 每一层调整的高度：第一层 h − 1 h-1 h−1、第二层 h − 2 h-2 h−2、…、1

那么假设时间复杂度为 T n T_{n} Tn​，时间复杂度就是从第一层到倒数第二层每个节点的调整次数之和

  • 时间复杂度： T ( n ) = 2 0 ∗ ( h − 1 ) + 2 1 ∗ ( h − 2 ) + 2 2 ∗ ( h − 3 ) + 2 3 ∗ ( h − 4 ) + . . . + 2 h − 3 ∗ 2 + 2 h − 2 ∗ 1 T(n) = 2^{0}*(h-1)+2^{1}*(h-2)+2^{2}*(h-3)+2^{3}*(h-4)+...+2^{h-3}*2+2^{h-2}*1 T(n)=20∗(h−1)+21∗(h−2)+22∗(h−3)+23∗(h−4)+...+2h−3∗2+2h−2∗1
  • 等式两边同时乘2： 2 ∗ T ( n ) = 2 1 ∗ ( h − 1 ) + 2 2 ∗ ( h − 2 ) + 2 3 ∗ ( h − 3 ) + 2 4 ∗ ( h − 4 ) + . . . + 2 h − 2 ∗ 2 + 2 h − 1 ∗ 1 2*T(n) = 2^{1}*(h-1)+2^{2}*(h-2)+2^{3}*(h-3)+2^{4}*(h-4)+...+2^{h-2}*2+2^{h-1}*1 2∗T(n)=21∗(h−1)+22∗(h−2)+23∗(h−3)+24∗(h−4)+...+2h−2∗2+2h−1∗1
  • 使用错位相减法(将上面两个等式进行相减)： T ( n ) = 2 1 + 2 2 + 2 3 + 2 4 + . . . + 2 h − 2 + 2 h − 1 − h + 1 T(n) = 2^{1}+2^{2}+2^{3}+2^{4}+...+2^{h-2}+2^{h-1}-h+1 T(n)=21+22+23+24+...+2h−2+2h−1−h+1
  • 错位相减后得到一个等比数列： T ( n ) = 2 0 + 2 1 + 2 2 + 2 3 + 2 4 + . . . + 2 h − 2 + 2 h − 1 − h T(n) = 2^{0}+2^{1}+2^{2}+2^{3}+2^{4}+...+2^{h-2}+2^{h-1}-h T(n)=20+21+22+23+24+...+2h−2+2h−1−h
  • 通过等比数列公式 S n = a 1 ( 1 − q n ) 1 − q S_{n} = \frac{a_{1}(1-q^{n})}{1-q} Sn​=1−qa1​(1−qn)​
  • 1 − 2 ( h − 1 ) ∗ 2 1 − 2 \frac{1-2^{(h-1)}*2}{1-2} 1−21−2(h−1)∗2​
  • T ( n ) = 2 h − 1 − h T(n) = 2^{h}-1-h T(n)=2h−1−h；( h h h是错位相减得到的)
  • 假设有 N N N个节点，于是就推出 N = 2 h − 1 N = 2^{h}-1 N=2h−1,即 h = l o g 2 ( N + 1 ) h =log_{2}(N+1) h=log2​(N+1)（一棵高度为 h h h的满二叉树的节点个数等于 2 h − 1 2^{h}-1 2h−1）
  • 把上面两个公式带入 T ( n ) = 2 h − 1 − h T(n) = 2^{h}-1-h T(n)=2h−1−h得出，得到 T ( n ) = N − l o g 2 ( N + 1 ) T(n) = N - log_{2}(N+1) T(n)=N−log2​(N+1)
  • 通多大O渐近法表示得到最后的时间复杂度 O ( N ) O(N) O(N)

所以建堆的时间复杂度就是 O ( N ) O(N) O(N)，因为当 N N N足够大时，对数的大小就根本不值得一提了。

堆的向上调整算法

堆的向上调整算法是用一个堆中，当我们要在堆的末尾插入一个新元素。

将堆顶元素和最后一个元素进行交换，然后将最后一个位置的元素进行向上调整。

如果是建小堆，拿最后一个元素和父节点进行比较，如果父节点大于自己就进行交换，接着以父节点的位置继续开始向上调整，如果不小于父节点就停止向上调整(说明此时已经满足小堆的条件了)。

在这里插入图片描述

// 交换函数
void Swap(HPDataType* x, HPDataType* y)
{
	HPDataType tmp = *x;
	*x = *y;
	*y = tmp;
}
// 向上调整(建小堆)
void AdjustUp(HPDataType* arr, int index)
{
	int child = index;
	int parent = (child-1) / 2;//获取父节点下标
	while (child > 0)
	{
		if (arr[parent] > arr[child])//如果节点如果大于孩子就交换
		{
			Swap(&arr[parent], &arr[child]);
			child = parent;
			parent = (child-1) / 2;
		}
		else
		{
			//说明无需调整
			break;
		}
	}
}

3. 堆的实现

通过一维数组来实现一个逻辑上的完全二叉树，需要定义以下接口

堆的结构体

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* arr;//数组
	int size;//堆中元素个数
	int capacity;//堆的容量
}Heap;

// 交换函数
void Swap(HPDataType* x, HPDataType* y);
// 堆的创建
Heap* HeapCreate(HPDataType* arr, int n);
// 向下调整
void AdjustDown(HPDataType* arr, int n, int index);
// 向上调整
void AdjustUp(HPDataType* arr, int index);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType data);
// 堆的删除
void HeapPop(Heap* hp);
// 获取堆顶元素
HPDataType HeapTop(Heap* hp);
// 获取堆的元素个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);

堆的创建

首先先通过malloc开辟空间

如果一个数组不是堆，在创建的时候就需要通过向下调整算法，从最后一个叶子节点的父亲开始调整，把它调整成一个小堆

// 交换函数
void Swap(HPDataType* x, HPDataType* y)
{
	HPDataType tmp = *x;
	*x = *y;
	*y = tmp;
}
// 堆的创建
Heap* HeapCreate(HPDataType* arr, int n)
{
	assert(arr);
	Heap* heap = (Heap*)(malloc(sizeof(Heap)));
	if (heap == NULL)
	{
		printf("malloc erro!\n");
		exit(-1);
	}
	heap->arr = (HPDataType*)(malloc(sizeof(HPDataType) * n));
	heap->size = n;
	heap->capacity = n;
	memcpy(heap->arr, arr, sizeof(HPDataType) * n);
	//向下调整建堆
	int i = 0;
	//从倒数第一个非叶子节点开始向下调整
	for (i = (n - 2) / 2; i >= 0; --i)
	{
		AdjustDown(heap->arr,heap->capacity ,i);
	}

	return heap;
}
// 向下调整
void AdjustDown(HPDataType* arr, int n, int index)
{
	int parent = index;
	int child = 2 * parent + 1;
	while (parent < n)
	{
		
		//找出两个孩子里的较小的
		if (child < n && child + 1 < n && arr[child] > arr[child + 1])
		{
			child++;
		}
		// 拿较小的孩子比较和父亲比价大小
		if (child < n && arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			//说明无需调整
			break;
		}
	}
}

向堆中插入元素

  • 堆的插入需要判断扩容，如果堆满了就进行二倍扩容。
  • 每次默认在堆的末尾插入一个元素，再拿这个元素进行向上调整
// 堆的插入
void HeapPush(Heap* hp, HPDataType data)
{
	assert(hp);
	//扩容
	if (hp->size == hp->capacity)
	{
		// 二倍扩容
		HPDataType* ptr = (HPDataType*)(realloc(hp->arr, sizeof(HPDataType)*hp->capacity * 2));
		if (ptr == NULL)
		{
			printf("扩容失败\n %s", strerror(errno));
			exit(-1);
		}
		hp->arr = ptr;
		hp->capacity = 2 * hp->capacity;
	}

	hp->arr[hp->size] = data;
	//向上调整
	AdjustUp(hp->arr,hp->size);
	hp->size++;
}

删除堆顶元素

删堆顶元素实现思路

  • 拿堆顶元素和数组最后一个元素进行交换
  • 在把堆中元素个数减一
  • 再从堆顶进行向下调整
// 堆的删除
void HeapPop(Heap* hp)
{
	//堆中没有元素
	assert(hp && hp->size != 0);

	//拿堆顶元素和数组最后一个元素交换
	Swap(&(hp->arr[0]), &(hp->arr[hp->size - 1]));
	hp->size--;
	//向下调整
	AdjustDown(hp->arr, hp->size, 0);
	
}

获取堆顶元素

这个比价简单，就会返回数组 第一个元素就好

// 获取堆顶元素
HPDataType HeapTop(Heap* hp)
{
	assert(hp && hp->size != 0);

	return hp->arr[0];
}

获取堆中元素个数

// 获取堆的元素个数
int HeapSize(Heap* hp)
{
	assert(hp);

	return hp->size;
}

判断堆是否为空

// 堆的判空
int HeapEmpty(Heap* hp)
{
	assert(hp);

	return hp->size == 0;
}

堆的销毁

// 堆的销毁
void HeapDestory(Heap* hp)
{
	assert(hp);
	free(hp->arr);
	hp->size = 0;
	hp->capacity = 0;
	hp->arr = NULL;
	free(hp);
}

4. TopK问题

Topk问题：给你一个组数据找出前k大的数

思路：对数组排序，取出前k个

size_t IntCmp(const void* x, const void* y)
{
	return *((int*)y) - *((int*)x);
}
void Test(int* arr, int n, int k)
{
	qsort(arr, n, sizeof(arr[0]), IntCmp);
	int i = 0;
	for (i = 0; i < k; i++)
	{
		printf("%d ", arr[i]);
    }
}

qsort底层是通过快排实现的，而快排的时间复杂度为 n ∗ l o g 2 n n*log_{2}n n∗log2​n

问题升级：能不能让时间复杂度在降低一点

此时就可以通过堆来解决这个问题

  • 找前k个大的建小堆
  • 找前k个小的建大堆

假设前面的找前k个大的数，建个小堆，因为小堆的堆顶一定是是一组数里最小的一个数字，如果来了一个数字比最小的数还要大，那么它肯定是要先如堆的。

于是写出代码

// 堆的创建
Heap* HeapCreate(HPDataType* arr, int n)
{
	assert(arr);
	Heap* heap = (Heap*)(malloc(sizeof(Heap)));
	if (heap == NULL)
	{
		printf("malloc erro!\n");
		exit(-1);
	}
	heap->arr = (HPDataType*)(malloc(sizeof(HPDataType) * n));
	heap->size = n;
	heap->capacity = n;
	memcpy(heap->arr, arr, sizeof(HPDataType) * n);
	//向下调整建堆
	int i = 0;
	//从倒数第一个非叶子节点开始向下调整
	for (i = (n - 2) / 2; i >= 0; --i)
	{
		AdjustDown(heap->arr,heap->capacity ,i);
	}

	return heap;
}
// 向下调整
void AdjustDown(HPDataType* arr, int n, int index)
{
	int parent = index;
	int child = 2 * parent;
	while (parent < n)
	{
		
		//找出两个孩子里的较小的
		if (child < n && child + 1 < n && arr[child] > arr[child + 1])
		{
			child++;
		}
		// 拿较小的孩子比较和父亲比价大小
		if (child < n && arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = 2 * parent;
		}
		else
		{
			//说明无需调整
			break;
		}
	}
}
// 堆的删除
void HeapPop(Heap* hp)
{
	//堆中没有元素
	assert(hp && hp->size != 0);

	//拿堆顶元素和数组最后一个元素交换
	Swap(&(hp->arr[0]), &(hp->arr[hp->size - 1]));
	hp->size--;
	//向下调整
	AdjustDown(hp->arr, hp->size, 0);
	
}

// 获取堆顶元素
HPDataType HeapTop(Heap* hp)
{
	assert(hp && hp->size != 0);

	return hp->arr[0];
}

然后不断获取堆顶元素，不断删除堆顶元素，就能得到前K个小的数。于是 O ( n ) O(n) O(n)的时间复杂就解决了问题

问题继续升级：假设有100亿个整数，从中找出前10大的数。

此时用单纯用堆肯定行不通的，因为一个整形4个字节，那么100亿个整形就是400亿个字节，那么这就是将近40G的数据，如果单纯用堆肯定是不行的。

思路：建一个大小为10的小堆，不断往堆中插入元素，如果元素满了，就和堆顶比较，如果小就删除堆顶元素，然后再进行插入，直到遍历完整个数组。

那么此时的时间复杂度为 O ( n ) O(n) O(n)，而空间复杂度则是 O ( k ) O(k) O(k)

爱敲代码的三毛
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C/C++实现二叉树的顺序存储
weixin_44915226的博客
07-02 1271
实现原理 要用顺序存储的方式存储二叉树，前提为该二叉树中，结点顺序与完全二叉树结点顺序一致。   代码 #include <iostream> #include <math.h> #define MaxSize 100 using namespace std; typedef int ElemType; typedef struct TreeNode{ ElemType value; bool isEmpty;//结点是否为空 }TreeNode; int
C语言版数据结构知识点汇总
04-22
### C语言版数据结构知识点汇总 #### 一、引言 使用计算机解决问题的过程通常包括以下步骤：首先，从实际问题中抽象出一个合适的数学模型；其次，设计一个用于解决该数学模型的算法；最后，编写并测试程序直至获得...
使用顺序存储结构实现的二叉树（C语言）
weixin_42909772的博客
01-04 1368
二叉树的顺序存储结构
二叉树（C语言实现）——顺序存储结构
Mr_John
11-08 7047
/* 二叉树顺序存储结构一般仅适合于存储完全二叉树 */ #include<stdio.h> #include<stdlib.h> #include<math.h> #include<stdbool.h> #define MaxSize 100 typedef char DataType; typedef struct { DataType data[MaxSize]; // 存储树结点的数组 int BiTreeNum; // 二叉树的..
二叉树的顺序存储—C++实现
shuang_1998的博客
04-12 3357
二叉树的顺序存储—C++实现 二叉树的顺序存储依靠数组实现，最重要的是前序、中序、后序、层序四种遍历方式及获取深度、求所有结点、叶子结点的操作，总体不难。 头文件如下： #pragma once #include<iostream> #include<queue> using namespace std; #define Maxsize 100 class BinaryTree { public: BinaryTree(); ~BinaryTree(); void CreatT
二叉树：顺序存储结构实现基本操作（C++）
Fexy_的博客
05-03 484
C++，采用顺序存储结构实现二叉树的基本操作
基于C语言10个数据结构课程设计实例二叉树建立遍历冒泡排序快速排序等
最新发布
04-05
本课程设计实例集合了10个核心的数据结构问题，包括二叉树的建立、遍历，以及常用的排序算法——冒泡排序和快速排序。下面将详细解析这些知识点。 一、数据结构 数据结构是编程中用于组织和管理大量数据的方法。...
数据结构实验报告——二叉树
11-14
### 数据结构实验报告——二叉树 #### 实验概述与目的 本次实验的主题是围绕“二叉树”这一核心概念展开。二叉树作为一种重要的非线性数据结构，在计算机科学中有着广泛的应用，例如在搜索算法、排序算法、编译器...
c语言10个数据结构课程设计实例二叉树建立遍历冒泡排序快速排序等
11-27
本课程设计实例聚焦于10个关键的数据结构问题，其中包括二叉树的建立、遍历，以及两种常见的排序算法——冒泡排序和快速排序。 一、数据结构基础 数据结构是存储和组织数据的方式，它可以是简单的线性结构如数组或...
数据结构c语言版——
09-24
如何描述一种新的抽象数据类型？...二叉树的定义、性质、存储结构、遍历算法 图的定义、术语、存储结构 静态查找表、二叉排序树、哈希函数的构造及冲突处理方法。 插入排序、快速排序、选择排序
完全二叉树的顺序储存结构（C++完整代码）
qq_52284035的博客
06-18 8196
完全二叉树的定义：有一颗深度为h、具有n个节点的二叉树，若将它与一颗同深度的满二叉树中的所有节点按从上到下，从左到右的顺序分别进行编号，且该二叉树中的每个节点分别于满二叉树中的编号为1~n ...
顺序存储二叉树
lkking的博客
03-04 267
●顺序存储二叉树 顺序存储二叉树的概念 基本说明 从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组 顺序存储二叉树的特点: 1)顺序二叉树通常只考虑完全二叉树 2）第n个元素的左子节点为2n+ 1 3)第n个元素的右子节点为 2n+ 2 4)第n个元素的父节点为(n-1)/ 2 5) n: 表示二叉树中的第几个元素(按0开始编号如图所示) 顺序存储二叉...
树结构的知识架构+二叉树的知识架构（含顺序与链式存储C语言完整代码实现）+树和森林与二叉树的转换
crr411422的博客
03-30 1176
树的定义、孩子表示法、双亲表示法和孩子兄弟表示法。二叉树顺序结构和链式结构C语言完整代码实现，二叉树的前、中、后和层次四种遍历方式，树和森林与二叉树的转换。
判断完全二叉树（顺序存储）
1900的博客
05-04 1373
Description 假如对二叉树T和具有相同高度的满二叉树编号，如果T与满二叉树相同编号的节点位置相同，那么称二叉树T是一棵完全二叉树。现在根据边的连接情况判断一棵树是否是完全二叉树。 Input 输入分两部分： 第一部分：一个整数T，代表测试组数 第二部分：接下来有T组数据，每组的第一行有2个整数n(0 < n < 1024)和r(1<=r<=n), 表示结点数...
c语言顺序存储构建一棵二叉树,C语言 数据结构堆排序顺序存储（升序）
weixin_30673759的博客
05-19 397
堆排序顺序存储(升序)一：完全二叉树的概念：前h-1层为满二叉树，最后一层连续缺失右结点！二：首先堆是一棵全完二叉树：a:构建一个堆分为两步：⑴创建一棵完全二叉树 ⑵调整为一个堆(标注：大根堆为升序，小根堆为降序)b:算法描述：①创建一棵完全二叉树②while(有双亲){A:调整为大根堆；B:交换根和叶子结点；C:砍掉叶子结点；}c:时间复杂度为 O(nlogn) ,空间复杂度为 O...
二叉树的存储结构和二叉树的遍历方法以及实现代码
qq_51141456的博客
05-25 1631
实现代码在上述代码段中，函数为 PostOrder1(BiTree TT)、InOrder1(BiTree TT)、PreOrder1(BiTree TT)；如果二叉树如下图中所示，补全节点使其成为完全二叉树的方法太浪费空间；给定一个序列，在给定一个遍历的方法，能否将还原出二叉树呢？下图中的左右 要理解为树木，不要片面的理解成节点；答案是：不能，如下图，给定先序遍历 123。先看动图看遍历步骤，再看实例；先序遍历序列+中序遍历序列。后序遍历序列+中序遍历序列。层次遍历序列+中序遍历序列。
数据结构-顺序存储二叉树
weixin_73869209的博客
10-06 1877
大家好,今天给大家讲一下顺序存储二叉树顺序存储二叉树是一种将二叉树的节点按照从上到下、从左到右的顺序存储在数组中的方法。具体来说，顺序存储二叉树将二叉树的根节点存储在数组的第一个位置，然后按照从上到下、从左到右的顺序将二叉树的其他节点依次存储在数组中。对于任意一个节点的索引为i（i从1开始),其左子节点的索引为2i右子节点的索引为2i+1。这样，通过数组的索引关系，可以方便地找到节点的父节点、左子节点和右子节点。顺序存储二叉树的优点是可以使用数组的随机访问特性快速找到节点，不需要通过指针进行遍历。
[数据结构]二叉树的顺序存储结构
qq_66767938的博客
03-23 4865
二叉树的顺序存储结构
c语言实现二叉树的存储结构,数据结构之---C语言实现二叉树的顺序存储
weixin_33941707的博客
05-18 1256
//二叉树的顺序存储//这里利用循环队列存储数据//杨鑫#include#include#include#include#define MAXQSIZE 5 // 最大队列长度(对于循环队列，最大队列长度要减1)#define MAX_TREE_SIZE 100 // 二叉树的最大结点数#define ClearBiTree InitBiTree // 在顺序存储结构中，两函数完全一样typede...
《数据结构》C语言版讲义——严蔚敏版解析
"这是一份由严蔚敏教授编写的《数据结构》讲义，特别针对C语言实现。此讲义适合计算机专业学习者，特别是准备考研的学生，它涵盖了数据结构的基础知识，包括线性表、栈、队列、串、树和二叉树等重要概念。讲义的语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱敲代码的三毛

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

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

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

打赏作者

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

抵扣说明：

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

余额充值