1. Toy模板网首页
  2. > Toy博客

数据结构：树和二叉树之-堆排列 (万字详解)

10月前 作者：努力学c的楼下小王 分类：Toy博客 阅读(40) 违法举报

这篇具有很好参考价值的文章主要介绍了数据结构：树和二叉树之-堆排列 (万字详解)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

树概念及结构

1.1树的概念

1.2树的表示

​编辑2.二叉树概念及结构

2.1概念

2.2数据结构中的二叉树：​编辑

2.3特殊的二叉树：

​编辑

2.4 二叉树的存储结构

2.4.1 顺序存储：

2.4.2 链式存储：

二叉树的实现及大小堆排列

1功能展示

2 定义基本结构

3 初始化

4打印

5销毁

6插入

7向上调整

8交换两数组元素之间的值

9删除

10向下调整

11取堆顶的元素

12 判断二叉树是否为空

13计算该二叉树元素个数

3，堆排列

1建堆

建堆方式1 时间复杂度：O(N*log(N))

建堆方式2 时间复杂度：O(N)

2排列数组 O(N * log(N))

成品展示

Head.h

Head.c

Test.c

树概念及结构

1.1树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它
叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
有一个特殊的结点，称为根结点，根节点没有前驱结点
除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集
合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以
有0个或多个后继
因此，树是递归定义的。

数据结构：树和二叉树之-堆排列 (万字详解),算法,数据结构

数据结构：树和二叉树之-堆排列 (万字详解),算法,数据结构

 数据结构：树和二叉树之-堆排列 (万字详解),算法,数据结构

 数据结构：树和二叉树之-堆排列 (万字详解),算法,数据结构

 数据结构：树和二叉树之-堆排列 (万字详解),算法,数据结构

节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6
叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I…等节点为叶节点
非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G…等节点为分支节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次； 如上图：树的高度为4
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m（m>0）棵互不相交的多颗树的集合称为森林；（数据结构中的学习并查集本质就是一个森林）

1.2树的表示

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，实际中树有很多种表示方式，
如：双亲表示法，孩子表示法、孩子兄弟表示法等等。我们这里就简单的了解其中最常用的孩子
兄弟表示法。

typedef int DataType;
struct Node
{
struct Node* _firstChild1; // 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据域
};

2.二叉树概念及结构

2.1概念

一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子
树和右子树的二叉树组成。
二叉树的特点：

  1. 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
  2. 二叉树的子树有左右之分，其子树的次序不能颠倒。

2.2数据结构中的二叉树：

2.3特殊的二叉树：

  1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉
    树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
  2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对
    于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号
    从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉
    树

数据结构：树和二叉树之-堆排列 (万字详解),算法,数据结构

2.4 二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。
二叉树的性质

  1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
  2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
  3. 对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2
    ＋1
  4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=LogN

2.4.1 顺序存储：

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树
会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲
解。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。数据结构：树和二叉树之-堆排列 (万字详解),算法,数据结构

2.4.2 链式存储：

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面课程学到高阶数据结构如红黑树等会用到三叉链。

二叉树的实现及大小堆排列

本文将以写代码思路进行讲述，故中间会出现代码的优化以便梳理思路，渐入佳境

本文分成三个文件：

Head.h//函数的声明
Head.c//函数的创建
Test.c //用于测试文件

1功能展示

    //用数组的方式来表示二叉树基本结构
	typedef int HPDataType;
	typedef struct Heap
	{
		HPDataType* a;
		int size;
		int capacity;
	}HP;

	//初始化
	void HeapInit(HP* php);

	//交换两数组元素之间的值
	void Swap(HPDataType* p1,HPDataType* p2);

	//打印
	void HeapPrint(HP* php);

	//销毁
	void HeapDestroy(HP* php);

	//插入
	void HeapPush(HP* php,HPDataType x);

	//向下调整
	void AdjustDown(HPDataType* a, int size, int paarent);
	
	//向上调整
    void AdjustUp(HPDataType* a, int child);

	//删除
	void HeapPop(HP* php);

	//取堆顶的元素
	HPDataType HeapTop(HP* php);

	//判断是否为空
	bool HeapEmpty(HP* php);

	//计算该二叉树元素个数
	int HeapSize(HP* php);

2 定义基本结构

使用数组实现二叉树相较于链表有以下优势：
1. 内存连续性：数组在内存中是连续存储的，而链表中的节点可以分布在内存的任意位置。在某些场景下，数组的内存连续性可以提高访问效率，尤其对于计算机的缓存机制来说，连续的数组元素可以更好地利用缓存行，减少缓存缺失。
2. 索引访问：数组可以通过索引直接访问元素，而链表需要从头节点开始顺序遍历才能找到指定位置的节点。通过索引可以快速访问数组中的元素，这在一些特定的操作中是非常有优势的，例如查找某个特定位置的节点、根据节点索引快速更新或删除元素等。
3. 空间效率：相比链表，数组实现二叉树可以更加节省空间。链表除了存储节点本身的数据之外，还需要额外的指针来连接节点，而数组只需要存储节点数据，不需要额外的指针。
需要注意的是，链表在插入和删除节点的操作上通常比数组更加高效，因为插入和删除只需要改变相邻节点之间的指针指向，而数组需要移动元素。因此，在对二叉树进行频繁的插入和删除操作时，链表可能更适合。而数组适合于对二叉树进行频繁的随机访问和操作的场景。

//用数组的方式来表示二叉树基本结构
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

3 初始化

void HeapInit(HP* php)
{
	assert(php);

	php->a = NULL;
	php->size = php->capacity = 0;
}

4打印

void HeapPrint(HP* php)
{
	assert(php);
	for (int i = 0;i < php->size;i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

5销毁

void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a=NULL;
	php->size = php->capacity = 0;
}

6插入

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//扩容
	if (php->size == php->capacity)
	{
		//判断capacity是否为0，并进行赋值
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newcapacity);
		
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;

	//	   当前数组  插入数值的位置
	AdjustUp(php->a, php->size-1);
}

7向上调整

在插入元素之时，直接进行向上排序
将插入的元素与父辈元素进行比较，并进行互换

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	
	//孩子被调到顶是结束(即数组首元素)
	while (child>0)
	{
		//if (a[child]<a[parent])  小堆
		if (a[child] > a[parent])//大堆
		{
			//孩子 小于/小于 父亲
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			//孩子 大于/小于 父亲
			break;
		}
	}
}

8交换两数组元素之间的值

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

9删除

将头部元素与尾部元素呼唤，以防直接删除头元素，倒是数据混乱
将其换到尾部进行删除，在将换到同部的尾元素进行向下比较，
进行替换，寻找新的(最大/最小)头部元素

void HeapPop(HP* php)
{
	assert(php);
	assert(php->size>0);
	Swap(&(php->a[0]), &(php->a[php->size - 1]));
	php->size--;

	//向下调整
	AdjustDown(php->a, php->size, 0);
}

10向下调整

void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child<size)
	{
		//选出左右孩子中 小/大 的那个
		//if (child+1<size && a[child + 1] < a[child])
		if (child + 1 < size && a[child + 1] > a[child])
		{
			++child;
		}

		//跟孩子父亲比较
		//if (a[child]<a[parent])
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			//左右孩子都大于/小于父亲，结束交换
			break;
		}
	}
}

11取堆顶的元素

//取堆顶的元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

12 判断二叉树是否为空

bool HeapEmpty(HP* php)
{
	assert(php);
	
	return php->size == 0;
}

13计算该二叉树元素个数

int HeapSize(HP* php)
{
	assert(php);

	return php->size ;
}

3，堆排列

此时二叉树已近成型，但进行排列时会设计到复杂度的问题，之前的代码中存在问题，效率低下
此时的问题：
1,你得先写一个Hp数据结构，反而复杂
2，有o(N)空间复杂度
每次使用建堆选数据
整体时间复杂度O(N^2)
效率太低，没有使用到堆的优势
每次使用堆排列时都要重新创建一个数据结构，并依次插入进行排序无疑是增加了时间复杂度
应该直接利用本身的数组进行堆排列

1建堆

建堆方式1 时间复杂度：O(N*log(N))

一共N个数，每个数向上调整log(N)次(层数，依次对父辈进行交换)
故为 O(Nlog(N))

for (int  i = 1; i < n; i++)
	{
	 //每插入一个，进行一次向上调整
		AdjustUp(a, i);
	}

这段代码使用了一个循环，其中执行了n-1次迭代（从i=1到i<n）。每次循环内部都会调用AdjustUp(a, i)进行向上调整的操作。
在循环内部，执行向上调整的操作的时间复杂度是O(log(i))，其中i是当前循环的迭代次数。因为每次执行向上调整时，需要比较和交换的次数与当前节点所在二叉树的高度有关，而二叉树的高度是随着节点的插入逐渐增加的，即高度与插入的节点数量有关。
根据每次迭代的时间复杂度为O(log(i))，加上n-1次的循环，总的时间复杂度为: O(log(1) + log(2) + … + log(n-1))
对于这个求和过程，并没有一个简单的封闭解析解。但根据级数求和的性质，可以得到这个求和结果的上界为O(n * log(n))。因此，可以将上述代码的时间复杂度近似地表示为O(n * log(n))。
需要注意，这个时间复杂度是在假设AdjustUp的时间复杂度为O(log(i))的情况下得到的。如果AdjustUp的时间复杂度比O(log(i))更高，那么整个代码块的时间复杂度将会增加。

建堆方式2 时间复杂度：O(N)

从最后一个非叶节点进行插入

for (int i = (n - 1) / 2; i >= 0; i--)
	{
		//最后一个非叶节点：(n - 1) / 2
		//向下调整前提是字树必须是大/小堆
		AdjustDown(a, n, i);
	}

这段代码使用了一个循环，其中执行了(n-1)/2+1次迭代，从i=(n-1)/2到i=0。
每次循环内部都会调用AdjustDown(a, n, i)进行向下调整的操作。
在循环内部，执行向下调整的操作的时间复杂度是O(log(n))，其中n是当前二叉树的节点数量。因为每次执行向下调整时，需要比较和交换的次数与当前节点所在的子树的节点数量有关，而每个节点至多有两个子节点，所以向下调整的时间复杂度是与当前节点所在的子树高度相关，即O(log(n))。
根据每次迭代的时间复杂度为O(log(n))，加上(n-1)/2+1次的循环，总的时间复杂度为: O(log(n) + log(n) + … + log(n))
展开求和后，得到 (n-1)/2+1 次 log(n) 相加。根据级数求和的性质，这个求和结果为 O(n)。因此，可以将上述代码的时间复杂度近似地表示为 O(n)。

2排列数组 O(N * log(N))

此时二叉树已经排列完成，在二叉树图像中元素已经按照 大堆/小堆 排好
但在数组中依旧是混乱排列，要做到像堆排列，就需要将数组进行排列
升序打印数组：大堆
降序打印数组：小堆
这里似乎与之前相反

之前：
升序/降序 打印是要将首元素置换到末元素，并进行打印删除，被置换的元素向下调整
故为升序打印为小堆，降序为大堆

而此处我们要将数组按照大小堆的形式排列：

	while (end>0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;//--end缩小范围保证是按照数组 大/小 堆排序
	}

数据结构：树和二叉树之-堆排列 (万字详解),算法,数据结构数据结构：树和二叉树之-堆排列 (万字详解),算法,数据结构
若原本二叉树排列为大堆，该代码就将数组排列成大堆
故 升序建大堆，降序建小堆

成品展示

Head.h

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

//用数组的方式来表示二叉树基本结构
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

//初始化
void HeapInit(HP* php);

//交换两数组元素之间的值
void Swap(HPDataType* p1, HPDataType* p2);

//打印
void HeapPrint(HP* php);

//销毁
void HeapDestroy(HP* php);

//插入
void HeapPush(HP* php, HPDataType x);

//向上调整
void AdjustUp(HPDataType* a, int child);

//向下调整
void AdjustDown(HPDataType* a, int size, int paarent);

//删除
void HeapPop(HP* php);

//取堆顶的元素
HPDataType HeapTop(HP* php);

//判断是否为空
bool HeapEmpty(HP* php);

//计算该二叉树元素个数
int HeapSize(HP* php);

Head.c

#include "Head.h"

//初始化
void HeapInit(HP* php)
{
	assert(php);

	php->a = NULL;
	php->size = php->capacity = 0;
}

//打印
void HeapPrint(HP* php)
{
	assert(php);
	for (int i = 0;i < php->size;i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

//销毁
void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

//交换两数组元素之间的值
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向上调整
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

	//孩子被调到顶是结束(即数组首元素)
	while (child > 0)
	{
		if (a[child]<a[parent])  //小堆
		{
			//孩子 小于/小于 父亲
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			//孩子 大于/小于 父亲
			break;
		}
	}
}

//插入
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//扩容
	if (php->size == php->capacity)
	{
		//判断capacity是否为0，并进行赋值
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newcapacity);

		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;

	//	   当前数组  插入数值的位置
	AdjustUp(php->a, php->size - 1);

}

//向下调整
void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		//选出左右孩子中 小/大 的那个
		if (child+1<size && a[child + 1] < a[child])
		{
			++child;
		}

		//跟孩子父亲比较
		if (a[child]<a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			//左右孩子都大于/小于父亲，结束交换
			break;
		}
	}
}

//删除
void HeapPop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	Swap(&(php->a[0]), &(php->a[php->size - 1]));
	php->size--;

	//向下调整
	AdjustDown(php->a, php->size, 0);
}

//取堆顶的元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

//判断是否为空
bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

//计算该二叉树元素个数
int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

Test.c

Test.c只是用于测试代码，菜单的写法本文将不进行讲解。
但Test.c中含有对查找and销毁and存储链元素个数的使用方法进行了示例可以当参考。

#include "Head.h"

void test1()
{
	//升序打印--小堆
	//降序打印--大堆
	HP hp;
	HeapInit(&hp);
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };

	int sz = sizeof(a) / sizeof(a[0]);
	//将数组插入新的堆
	for (int i = 0;i < sz;i++)
	{
		HeapPush(&hp, a[i]);
	}

	while (!HeapEmpty(&hp))
	{
		printf("%d ", HeapTop(&hp));
		HeapPop(&hp);
	}
}

void test2()
{
	HP hp;
	HeapInit(&hp);
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };

	int sz = sizeof(a) / sizeof(a[0]);
	//将数组插入新的堆
	for (int i = 0;i < sz;i++)
	{
		HeapPush(&hp, a[i]);
	}
	int i = 0;
	while (!HeapEmpty(&hp))
	{
		a[i++] = HeapTop(&hp);
		HeapPop(&hp);
	}
	HeapDestroy(&hp);
}

void test3()
{
	HP hp;
	HeapInit(&hp);
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };

	int sz = sizeof(a) / sizeof(a[0]);
	//将数组插入新的堆
	for (int i = 0;i < sz;i++)
	{
		HeapPush(&hp, a[i]);
	}
	HeapPrint(&hp);
}
//此时的问题：
//1,你得先写一个Hp数据结构，反而复杂
//2，有o(N)空间复杂度
/*
	每次使用建堆选数据
	整体时间复杂度O(N^2)
	效率太低，没有使用到堆的优势
*/
void test4(int*a ,int n)
{
	//本生就是一个数组，直接利用自身建堆
	//建堆
	//  建堆方式1  时间复杂度：O(N*log(N))
	//for (int  i = 1; i < n; i++)
	//{
	// //每插入一个，进行一次向上调整
	//	AdjustUp(a, i);
	//}

	//  建堆方式2  时间复杂度：O(N)
	for (int i = (n - 1) / 2; i >= 0; i--)
	{
		//最后一个非叶节点：(n - 1) / 2
		//向下调整前提是字树必须是大/小堆
		AdjustDown(a, n, i);
	}

}

/*
	1.将 最大的数/最小的数 换到 最小的数/最大的数，
	并删除被换的数(最后的数)
	2.然后对 头部进行降序(将 最小的数/最大的数 下移，
	重新找到 最大/最小 的数换到头部) 
	
	将效率提升至O(N*log(N))
*/
//升序 --建大堆
//降序 --建小堆
void test5(int* a, int n)
{
	//时间复杂度：O(N)
	for (int i = (n - 1) / 2; i >= 0; i--)
	{
		//最后一个非叶节点：(n - 1) / 2
		//向下调整前提是字树必须是大/小堆
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	//O(N * log(N))->O(N)+O(N * log(N))=O(N * log(N))
	while (end>0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

int main()
{
	int a[] = { 5, 3, 2, 9, 7, 4, 1, 10, 8, 6};
	int sz = sizeof(a) / sizeof(a[0]);
	test5(a,sz);

	return 0;
}

本文到这就结束啦，本文为万字解读，创作不易，若喜欢请留下免费的赞吧！
感谢阅读😊😊😊

数据结构：树和二叉树之-堆排列 (万字详解),算法,数据结构文章来源地址https://www.toymoban.com/news/detail-727080.html

到了这里，关于数据结构：树和二叉树之-堆排列 (万字详解)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 数据结构-树和二叉树篇

    数据结构-树和二叉树篇

    思维导图（基于教材） 错题复盘+计算题（基于习题解析） 课后习题 从这章开始，要是上课听不懂的话，推荐去看B站青岛大学王卓王卓老师讲解的很细节，基本上每个知识点十几二十分钟，刚开始看的时候，可能会不习惯王老师的语气词，别退出，视频重要的是老师讲解的

    2024年01月17日
    浏览(48)
  • 【数据结构】树和二叉树——堆

    【数据结构】树和二叉树——堆

    目录 🍉一.树的概念及结构🍉 1.树的概念 2.树的相关术语 3.树的表示 4.树在实际中的应用 🍊二.二叉树的概念和结构🍊 1.二叉树的概念  2.特殊的二叉树 2.1.满二叉树 2..2.完全二叉树 3.二叉树的性质 4.二叉树的存储结构          4.1.顺序存储 4.2.链式存储 🍎三.堆的顺序结构

    2023年04月14日
    浏览(47)
  • 【数据结构】树和二叉树概念

    【数据结构】树和二叉树概念

    树是一种 非线性 的数据结构，它是由n（n=0）个有限结点组成一个具有层次关系的集合。 把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个 特殊的结点，称为根结点 ，根节点没有前驱结点 除根节点外， 其余结点被分成M(M0)个互不相交

    2024年02月09日
    浏览(40)
  • 【Java 数据结构】树和二叉树

    【Java 数据结构】树和二叉树

    篮球哥温馨提示：编程的同时不要忘记锻炼哦！ 目录 1、什么是树？ 1.1 简单认识树  1.2 树的概念  1.3 树的表示形式 2、二叉树 2.1 二叉树的概念 2.2 特殊的二叉树 2.3 二叉树的性质 2.4 二叉树性质相关习题 3、实现二叉树的基本操作 3.1 了解二叉树的存储结构 3.2 简单构造一棵

    2024年01月16日
    浏览(45)
  • 【数据结构之树和二叉树】

    【数据结构之树和二叉树】

    前言： 前篇学习了 数据结构的栈和队列，那么这篇继续学习树及其相关内容基础内容。 / 知识点汇总 / 概念 ：树是一种非线性结构，是由有限个节点组成的具有层次关系的集合。倒立的树模样。 有一个特殊的结点，称为根节点，根节点没有前驱。 另外的子树有且只有一个

    2024年01月16日
    浏览(55)
  • 数据结构之树和二叉树

    数据结构之树和二叉树

    目录 一、树简介 二、二叉树 1、简介 2、二叉树的性质 3、满二叉树和完全二叉树  三、二叉树的遍历 四、二叉树遍历代码实现 五、二叉搜索树（Binary Search Tree） 1、简介 2、二插搜索树的局限性 六、平衡二叉搜索树（AVL树） 七、红黑树（Red-Black Tree） 1、简介 2、性质 3、使

    2024年02月05日
    浏览(40)
  • 【数据结构】树和二叉树的概念及结构

    【数据结构】树和二叉树的概念及结构

      树是一种非线性的数据结构，它是由n（n=0）个有限结点组成一个具有层次关系的集合。 把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个 特殊的结点，称为根结点 ，根节点没有前驱结点。 除根节点外， 其余结点被分成M(M0)个互不相

    2024年02月13日
    浏览(39)
  • 数据结构之树和二叉树定义

    数据结构之树和二叉树定义

      数据结构是程序设计的重要基础，它所讨论的内容和技术对从事软件项目的开发有重要作用。学习数据结构要达到的目标是学会从问题出发，分析和研究计算机加工的数据的特性，以便为应用所涉及的数据选择适当的逻辑结构、存储结构及其相应的操作方法，为提高利用

    2024年01月21日
    浏览(50)
  • 【数据结构】——树和二叉树的相关习题

    【数据结构】——树和二叉树的相关习题

    1、设高度为h的二叉树上只有度为0和度为2的结点，则该二叉树中所包含的结点数至少为（），最多为（）。 A、h ；2 h -1 B、2h-1 ； 2 h -1 C、2h+1； 2 h-1 -1 D、h+1；2 h -1 解析： （B） 最少的情况下，除了根结点该层为1个结点以外，其余h-1层都有2个结点，得2(h-1)，即2(h-1)+1=2h-1。

    2024年02月03日
    浏览(44)
  • 数据结构期末复习（4）串 树和二叉树

    数据结构期末复习（4）串 树和二叉树

    在数据结构中，串是由零个或多个字符组成的有限序列。它是一种线性数据结构，常用于表示和处理文本、字符串等信息。 串的特点包括： 顺序性：串中的字符按照一定的先后顺序排列，每个字符都有一个唯一的位置。 有限性：串的长度是有限的，它由字符的个数决定。

    2024年01月17日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包