数据结构（二叉树-1）

文章目录

一、树

　　1.1 树的概念与结构

　　1.2 树的相关术语

　　1.3 树的表示

二、二叉树

　　2.1 二叉树的概念与结构

　　2.2特殊的二叉树

　　　　满二叉树

　　　　完全二叉树

　　2.3 二叉树的存储结构

三、实现顺序结构二叉树

　　3.1 堆的概念与结构

　　3.2 堆的实现

　　Heap.h

　　Heap.c

　　　　默认初始化堆

　　　　堆的销毁

　　　　堆的插入

　　删除堆顶数据

一、树

1.1 树的概念与结构

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

树形结构中，⼦树之间不能有交集，否则就不是树形结构

⼦树是不相交的（如果存在相交就是图了，图以后得课程会有讲解）
除了根结点外，每个结点有且仅有⼀个⽗结点
⼀棵N个结点的树有N-1条边

1.2 树的相关术语

⽗结点/双亲结点：若⼀个结点含有⼦结点，则这个结点称为其⼦结点的⽗结点；如上图：A是B的⽗结点
⼦结点/孩⼦结点：⼀个结点含有的⼦树的根结点称为该结点的⼦结点；如上图：B是A的孩⼦结点
结点的度：⼀个结点有⼏个孩⼦，他的度就是多少；⽐如A的度为6，F的度为2，K的度为0
树的度：⼀棵树中，最⼤的结点的度称为树的度；如上图：树的度为 6
叶⼦结点/终端结点：度为 0 的结点称为叶结点；如上图： B、C、H、I... 等结点为叶结点
分⽀结点/⾮终端结点：度不为 0 的结点；如上图： D、E、F、G... 等结点为分⽀结点
兄弟结点：具有相同⽗结点的结点互称为兄弟结点(亲兄弟)；如上图： B、C 是兄弟结点结点的层次：从根开始定义起，根为第 1 层，根的⼦结点为第 2 层，以此类推；
树的⾼度或深度：树中结点的最⼤层次；如上图：树的⾼度为 4
结点的祖先：从根到该结点所经分⽀上的所有结点；如上图： A 是所有结点的祖先
路径：⼀条从树中任意节点出发，沿⽗节点-⼦节点连接，达到任意节点的序列；⽐如A到Q的路径为：A-E-J-Q；H到Q的路径H-D-A-E-J-Q
⼦孙：以某结点为根的⼦树中任⼀结点都称为该结点的⼦孙。如上图：所有结点都是A的⼦孙
森林：由 m（m>0）棵互不相交的树的集合称为森林；

1.3 树的表示

孩⼦兄弟表⽰法：

struct TreeNode
 {
     struct Node* child; // 左边开始的第⼀个孩⼦结点
     struct Node* brother; // 指向其右边的下⼀个兄弟结点
     int data; // 结点中的数据域
 };

二、二叉树

2.1 二叉树的概念与结构

在树形结构中，我们最常⽤的就是⼆叉树，⼀棵⼆叉树是结点的⼀个有限集合，该集合由⼀个根结点加上两棵别称为左⼦树和右⼦树的⼆叉树组成或者为空。

从上图可以看出⼆叉树具备以下特点：

⼆叉树不存在度⼤于 2 的结点
⼆叉树的⼦树有左右之分，次序不能颠倒，因此⼆叉树是有序树

注意：对于任意的⼆叉树都是由以下⼏种情况复合⽽成的：

2.2特殊的二叉树

满二叉树

⼀个⼆叉树，如果每⼀个层的结点数都达到最⼤值，则这个⼆叉树就是满⼆叉树。也就是说，如果⼀个⼆叉树的层数为 K ，且结点总数是 2 k − 1 ，则它就是满⼆叉树。

完全二叉树

完全⼆叉树是效率很⾼的数据结构，完全⼆叉树是由满⼆叉树⽽引出来的。对于深度为 K 的，有 n 个结点的⼆叉树，当且仅当其每⼀个结点都与深度为K的满⼆叉树中编号从 1 ⾄ n 的结点⼀⼀对应时称之为完全⼆叉树。要注意的是满⼆叉树是⼀种特殊的完全⼆叉树。

（假设二叉树层次为 k ，除了第 k 层外，每层结点的个数达到最大结点数，第 k 层结点个数不一定达到最大结点数）

⼆叉树性质

根据满⼆叉树的特点可知：

1）若规定根结点的层数为 1 ，则⼀棵⾮空⼆叉树的第i层上最多有 2 i −1 个结点

2）若规定根结点的层数为 1 ，则深度为 h 的⼆叉树的最⼤结点数是 2 h − 1 3）若规定根结点的层数为 1 ，具有 n 个结点的满⼆叉树的深度 ( log

以2为底， n+1 为对数)

2.3 二叉树的存储结构

⼆叉树⼀般可以使⽤两种结构存储，⼀种顺序结构，⼀种链式结构。

下面我们先来使用顺序结构实现二叉树。

顺序结构存储就是使⽤数组来存储，⼀般使⽤数组只适合表⽰完全⼆叉树，因为不是完全⼆叉树会有空间的浪费，完全⼆叉树更适合使⽤顺序结构存储。

现实中我们通常把堆（⼀种⼆叉树）使⽤顺序结构的数组来存储，需要注意的是这⾥的堆和操作系统虚拟进程地址空间中的堆是两回事，⼀个是数据结构，⼀个是操作系统中管理内存的⼀块区域分段。

三、实现顺序结构二叉树

⼀般堆使用顺序结构的数组来存储数据，堆是⼀种特殊的⼆叉树，具有⼆叉树的特性的同时，还具备其他的特性。

3.1 堆的概念与结构

如果有⼀个关键码的集合，把它的所有元素按完全⼆叉树的顺序存储⽅式存储，在⼀个⼀维数组中，并满⾜：（且）， i = 0、1 、 2... ，则称为⼩堆(或⼤堆)。将根结点最⼤的堆叫做最⼤堆或⼤根堆，根结点最⼩的堆叫做最⼩堆或⼩根堆。

小根堆大根堆

堆中某个结点的值总是不⼤于或不⼩于其⽗结点的值；
堆总是⼀棵完全⼆叉树。

⼆叉树性质

对于具有 n 个结点的完全⼆叉树，如果按照从上⾄下从左⾄右的数组顺序对所有结点从0 开始编号，则对于序号为 i 的结点有：

若 i>0 ， i 位置结点的双亲序号： (i-1)/2 ； i=0 ， i 为根结点编号，⽆双亲结点
若 2i+1<n ，左孩⼦序号： 2i+1 ， 2i+1>=n 否则⽆左孩⼦
若 2i+2<n ，右孩⼦序号： 2i+2 ， 2i+2>=n 否则⽆右孩⼦

3.2 堆的实现

以小根堆为例子：

Heap.h

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

//定义堆的结构---数组

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* arr;
	int size;//有效的数据个数
	int capacity;//空间大小
}HP;

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

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

//堆的插入
void HPPush(HP* php, HPDataType x);

//出堆，删除堆顶数据
void HPPop(HP* php);

//返回堆顶数据
HPDataType HPTop(HP* php);

// 判空
bool HPEmpty(HP* php);

Heap.c

默认初始化堆

void HPInit(HP* php)
{
	assert(php);
	php->arr = NULL;
	php->capacity = php->size = 0;
}

堆的销毁

void HPDestroy(HP* php)
{
	assert(php);
	if (php->arr)
	{
		free(php->arr);
		php->arr = NULL;

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

堆的插入

如果要在下一个数据 “50” 到 arr【6】的位置上就不满足小堆的特性，

此时我们就要用到：堆的向上调整算法

向上调整算法

• 先将元素插⼊到堆的末尾,即最后⼀个孩⼦之后

• 插⼊之后如果堆的性质遭到破坏，将新插⼊结点顺着其双双亲往上调整到合适位置即可

void swap(int* x, int* y)
{
	int z = *x;
	*x = *y;
	*y = z;
}

void Adjustup(HPDataType* arr, int child)
{
	int parent = (child - 1) / 2;

	while (child > 0)
	{
		if (arr[child] < arr[parent])             //如果插入的数据大小小于他的父节点
		{
			swap(&arr[child], &arr[parent]);      //交换
			child = parent;                       //交换后的孩结点来到原来他的父节点的位置  
			parent = 2 * child - 1;
		}
		else
		{
			break;
		}
	}
}

void HPPush(HP* php, HPDataType x)
{
	assert(php);

	//判断空间是否足够
	if (php->size == php->capacity)
	{
		//扩容
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->arr, newcapacity * sizeof(HPDataType));
	
		if (tmp  == NULL)
			{
				perror("realloc fail!");
				exit(1);
			}
		php->arr = tmp;
		php->capacity = newcapacity;
	}
	php->arr[php->size] = x;
	php->size++;

	Adjustup(php->arr, php->size - 1);
}

删除堆顶数据

如果直接删除 arr【0】，就会改变原先堆的结构，所以我么可以先先将头和尾的数据交换，在删除 arr【5】，但是又有问题出现。交换删除后的数据有可能不满足小堆的特性，此时就要用到:堆的向下调整算法

向下调整算法

• 将堆顶元素与堆中最后⼀个元素进⾏交换

• 删除堆中最后⼀个元素

• 将堆顶元素向下调整到满⾜堆特性为⽌

void AdjustDown(HPDataType* arr, int parent, int n)
{
	int child = parent * 2 + 1;  //左孩子
	
	while (child < n)     //这里注意循环的条件
	{
		//找左右孩子中找最小的
		if (child + 1 < n && arr[child] > arr[child + 1])
		{
			child++;
		}
		if (arr[child] < arr[parent])
		{
			swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;

		}
		else
		{
			break;
		}
	}
}

void HPPop(HP* php)
{
	assert(php && php->size);

	         //arr[0]         arr[size-1]
	swap(&php->arr[0], &php->arr[php->size - 1]);

	php->size--;

	AdjustDown(php->arr, 0, php->size);


}

test.c

最后测试一下代码的实现

#include"Heap.h"

void Hptest()
{
	HP hp;
	HPInit(&hp);

	int arr[] = { 17,25,60,54,30,70 };
	
	for (int i = 0; i < 6; i++)
	{
		HPPush(&hp, arr[i]);
	}

	HPPop(&hp);
}


int main()
{
	Hptest();
	return 0;
}

3.3 堆的应用

堆排序

方法一：基于已有数组建堆、取堆顶元素完成排序版本

// 1、需要堆的数据结构
// 2、空间复杂度 O(N)
void HeapSort(int* a, int n)
{
    HP hp;
    for(int i = 0; i < n; i++)
    {
            HPPush(&hp,a[i]);
    }
    int i = 0;
    while (!HPEmpty(&hp))
    {
        a[i++] = HPTop(&hp);
        HPPop(&hp);
    }
   HPDestroy(&hp);
}

方法二：

// 升序，建⼤堆
// 降序，建⼩堆
// O(N*logN)
void HeapSort(int* a, int n)
 {
 // a数组直接建堆 O(N)
 for (int i = (n-1-1)/2; i >= 0; --i)
 {
 AdjustDown(a, n, i);
 }

 // O(N*logN)
 int end = n - 1;
 while (end > 0)
 {
 Swap(&a[0], &a[end]);
 AdjustDown(a, end, 0);
 --end;
 }
 }