数据结构：如果写代码，就写一棵树

Posted 2021-10-09 lxkeepcoding

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了数据结构：如果写代码，就写一棵树相关的知识，希望对你有一定的参考价值。

前言

hello，大家好，这期文章呢，来介绍一下关于树的知识点。在介绍树之前呢，首先先要了解什么是树。如果你已经学会了离散数学，那么概念你自然已经懂的了，如果你学过离散但和博主一样学了等于没学，那你还需要和博主一起重新了解一下什么叫树。
提到树啊，我们总会想起那句著名的话“如果有来生，要做一棵树，站成永恒”。其实实现做一棵树的梦想也许不必等到来生，打开VS，给自己写一棵吧。

1. 树的概念及结构

1. 树的概念

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

当然，并不是所有树都如此繁茂，比如空树。

1.2 树中的一些名称

1.2.2 节点

父节点和子节点：A、B、C、D、E、F、G……都是节点。其中，A为B、C、D、E、F、G的父节点（或双亲节点）。B、C、D、E、F、G为A的子节点（或孩子节点）。同理，D为H、I的父节点，H、I为D的子节点。I为L、M、N的父节点，L、M、N为i的子节点。
根节点和叶节点：没有父节点的节点成为根节点，没有子节点的节点称为叶节点。A为根节点，H、G、L、M、N、O、P为叶节点。

1.2.3 子树

以非根节点的其他节点为根节点构成的“小树”为字树。

这些均为子树。

1.2.4 树的高度或深度

节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次；如上图：树的高度为4。

1.2.5 度

节点的度：一个节点含有的子树的个数称为该节点的度；如上图：A的为6。B的为0，D的为2。
树的度：一棵树中，最大的节点的度称为树的度；如上图：树的度为6。
叶节点或终端节点：度为0的节点称为叶节点。如B、C、F、H、G、L、M、N、O、P。
非终端节点或分支节点：度不为0的节点。如A、D、G、I、K。

1.2.6 树中的亲戚关系

双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点。
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点。如O和P。
堂兄弟节点：双亲在同一层的节点互为堂兄弟如H和G。
节点的祖先：从根到该节点所经分支上的所有节点
子孙：以某节点为根的子树中任一节点都称为该节点的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林。

1.3 非树

树需要满足以下条件：
1.子树不相交

2.除根节点外每一个节点都有且仅有一个父节点。

3.一棵N个节点的树有N-1条边。

根据以上条件可以看出，树里面是不包含环的，有环则不为树。

1.4 树的表示

由于树的结构复杂，表示起来也十分困难。在树的多种表示方式中如：双亲表示法，孩子表示法、孩子兄弟表示法等等。最常用的孩子兄弟表示法。

1.4.1 双亲表示法

每个值存双亲的下标。这种表示方法虽然可能知道双亲，但遗憾的是不能知道孩子。如果要找孩子，就要遍历整个结构。

#define MAX_TREE_SIZE 100
typedef struct TreeNode
{
	int  data;  //结点数据域
	int parent; //双亲位置
}TNode;
typedef struct
{              
	TNode nodes[MAX_TREE_SIZE];    //结点数组
	int  r, n;                     //根节点的位置和结点数
};

1.4.2 孩子表示法

每一棵树都是有根和子树构成，子树也是一样的构成，但是树并不确定有多少个孩子。
我们要使用孩子表示法，就要给每一个孩子对应一个指针。但并不是每一个节点都拥有相同数量的孩子，这就会造成很大的浪费。

struct TreeNode
{
	int data;
	struct TreeNode*child1;
	struct TreeNode*child2;
	struct TreeNode*child2;
	……
};

我们也可以采用动态增长的顺序表来通过指针数组来实现孩子指针，在C++中也可以通过vector来解决问题。但这种方法仍然没有从本质上解决问题，还是有许多麻烦。

struct TreeNode
{
	int data;
	SeqList childarr;//指针数组，顺序表中存的是struct TreeNode*
};

所以这种方法是不太友好的。

1.4.3 孩子兄弟表示法

struct TreeNode
{
	int data;
	struct TreeNode*FirstChild;//指向第一个孩子的节点
	struct TreeNode*pNextBrother;//指向下一个兄弟的节点
};

这是一种很奇妙的表示方法，由孩子找孩子。解决了多孩子不好找问题。

每一个节点都有两个指针，一个指向兄弟，有兄弟则指向兄弟，没有兄弟指向空。一个指针指向最左边的子节点也就是第一个孩子，由第一个孩子去找到第二个孩子，以此类推。
这不由得使我想起了乔祖望，这个不靠谱的渣爹。他管过孩子是甩手掌柜，所有的孩子都是由老大一成来带的。乔祖望就相当于父节点，而一成就是最左边的子节点，而连接乔家的兄弟姐妹的感情的，就是指向兄弟节点的指针。

1.5 树在实际中的应用

目录系统就是树的一个典型应用。

2. 树的计划生育——二叉树

我们通过上面对树的介绍，已经对树有了初步了了解。我们也已经发现，一棵树如果孩子太多，就会很麻烦。要是树也能计划生育一下就好了，只生一个好，树树皆好找。但是树也是逐渐放开了二胎政策的，于是二叉树就出现了。（放开了三胎政策后，会不会三叉树成为主流呢？）

2.1 二叉树的概念

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

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

也就是说，二叉树里面，一个父节点可以没有孩子，或者一个孩子，或者两个孩子，孩子不能再多了，最多两个。而且，大孩子和小孩子要区分开，顺序不能颠倒。

上图为一个二叉树，里面有独生子女家庭，有二胎家庭，也有丁克家庭。但没有三胎及以上的家庭。
注意，这样的也是二叉树哦。

2.2 特殊的二叉树

2.2.1 满二叉树

满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。

所谓的满二叉树就是，除了最小的一辈没有孩子外，其他的都是二胎家庭。下一层的节点是上一节的二倍。

2.2.2 完全二叉树

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

完全二叉树是一种允许非最小一辈丁克的二叉树。也就是，最小一辈没孩子，其他辈分的，要么生二胎，要么选择丁克。完全二叉树前n-1层都是满的，最后一层可以不满，但从左到右是连续的，不可以跳着不满。简而言之就是，老大不生老二不可以生，老大一胎老二不许二胎。

这样是不可以的：

注意，满二叉树是一种特殊的完全二叉树。

2.3 二叉树的性质

若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2＋1
若规定根节点的层数为1，具有n个结点的满二叉树的深度,h=Log2(n+1). (ps：Log2(n+1)是log以2为
底，n+1为对数)
对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
1.若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
2.若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
3.若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

根据以上性质，我们来看几道题：

某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（）
A 不存在这样的二叉树
B 200
C 198
D 199
根据度为0比度为二多一，所以要选200.而200+199正好得399，又可以证明是二叉树。
2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（）
A n
B n+1
C n-1
D n/2
设度为0的叶子有m个，设度为1的节点有p个，度为2的有q个，则有m+p+q=2n,并且m=q+1.而且，对于完全二叉树度为1的节点最多有一个。如果p=0.则2q+1=2n。n是正整数，所以不存在，所以p=1.则有2q+1+1=2n。所以m=n。答案为A。
3.一棵完全二叉树的节点数位为531个，那么这棵树的高度为（）
A 11
B 10
C 8
D 12
设深度为h，最后一层相对于满二叉树缺的节点为x，x的范围为0到2^(h-1)-1.所以可以将选项带入进行求证，最后选B。

2.4 二叉树的存储结构

2.4.1 顺序存储

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

顺序存储在存储非完全二叉树时会存在空间的浪费。

2.4.2 链式存储

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构又分为二叉链和三叉链

二叉链：只能找孩子

三叉链：可以找孩子，也可以找父亲

二叉链表和三叉链表：

// 二叉链
struct BinaryTreeNode
{
struct BinTreeNode* pLeft; // 指向当前节点左孩子
struct BinTreeNode* pRight; // 指向当前节点右孩子
BTDataType data; // 当前节点值域
}
// 三叉链
struct BinaryTreeNode
{
struct BinTreeNode* pParent; // 指向当前节点的双亲
struct BinTreeNode* pLeft; // 指向当前节点左孩子
struct BinTreeNode* pRight; // 指向当前节点右孩子
BTDataType data; // 当前节点值域
}；

链式存储无论是完全二叉树还是非完全二叉树都不存在空间的浪费的情况。

3. 二叉树的顺序结构及实现（堆）

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

3.1 堆的概念及结构

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆的性质：
堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。

3.1.1 大根堆小根堆

堆的物理结构是数组，堆的逻辑结构是一个完全二叉树，大根堆中所有的父亲大于等于孩子，小根堆中所有的父亲小于等于孩子。
大根堆：

小根堆：

3.1.2 下标规律

3.2 堆的实现

3.2.1 堆向下调整算法

3.2.1.1 思路分析

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。

1.选出左右孩子中小的那一个
2.小的孩子和父亲比
3.如果孩子比父亲小，则与父亲交换，并把原来孩子的位置当成父亲继续往下调整。
4.如果小的孩子比父亲大，则完成调整。

3.2.1.2 代码实现

#include<stdio.h>

void Swap(int *p, int *q)
{
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;
}

void AdjustDown(int *a,int n,int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//选出左右孩子较小的一个
		if (child+1<n&&a[child + 1] < a[child])
		{
			++child;
		}
		//孩子和父亲比大小
		if (a[child] < a[parent])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

int main()
{
	int a[] = { 28, 16, 20, 19, 29, 35, 66, 50, 26, 38 };
	int n = sizeof(a) / sizeof(a[0]);
	AdjustDown(a, n, 0);
	for (int i = 0; i < n; i++)
	{
		printf("%d  ", a[i]);
	}
	printf("\\n");
	return 0;
}

3.2.2 向上调整排序算法

3.2.2.1 思路分析

向上排序算法和向下排序算法类似，如果我们插入的值比父亲大，就交换。依次向上。

3.2.2.2 代码实现

void AdjustUp(int*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;
		}
	}
}

3.2.3 堆的创建

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根节点左右子树不是堆，我们怎么调整呢？这里我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆。

当左右子树不是小堆时，也就是说，我们需要多次调用向下调整算法。

从倒数第一个非叶子节点，从后往前排。按编号，一次作为子树去向下调整。


#include<stdio.h>

void Swap(int *p, int *q)
{
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;
}

void AdjustDown(int *a,int n,int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//选出左右孩子较小的一个
		if (child+1<n&&a[child + 1] < a[child])
		{
			++child;
		}
		//孩子和父亲比大小
		if (a[child] < a[parent])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

int main()
{
	int a[] = { 20, 16, 38, 29, 50, 35, 66, 19, 26, 28 };
	int n = sizeof(a) / sizeof(a[0]);
	for (int j = (n - 1 - 1) / 2; j >= 0; --j)
	{
		AdjustDown(a, n,j);
	}
	for (int i = 0; i < n; i++)
	{
		printf("%d  ", a[i]);
	}
	printf("\\n");
	return 0;
}

注意，如果是大根堆，只需要将比较时的小于号全部换成大于号就可以。

3.2.4 堆的排序

首先，我们要思考这样一个问题。当我们想要排升序时，应该建大根堆还是小根堆呢？降序时呢？答案是升序时建大堆，降序时建小堆。
我们以升序为例，升序为什么不能建小堆呢？建堆的时间复杂度为O(N)。如果我们建小堆，堆选出最小的数花了O(N)。紧接着剩下的N-1个数如何选出次小呢？剩下的数父子关系依旧全是乱的需要重新建堆。消耗很大。但如果我们建大堆，我们选出最大的后，将其和最后一个数字互换位置，紧接着选出次大的时，不把最后一个数字看出堆里面的，父子关系未变，向下调整就能选出次大的。
我们以升序排列为例观察一下排序流程：

从这个流程中我们就可以感受到，如果排升序建小堆的话，会混乱很多。

接下来的代码展示升序建大堆：

#include<stdio.h>

void Swap(int *p, int *q)
{
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;
}

void AdjustDown(int *a,int n,int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//选出左右孩子较大的一个
		if (child+1<n&&a[child + 1] > a[child])
		{
			++child;
		}
		//孩子和父亲比大小
		if (a[child] > a[parent])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int *a, int n)
{
	for (int j = (n - 1 - 1) / 2; j >= 0; --j)
	{
		AdjustDown(a, n, j);
	}
	int end = n - 1;
	while (end>0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}
int main()
{
	int a[] = { 20, 16, 38, 29, 50, 35, 66, 19, 26, 28 };
	int n = sizeof(a) / sizeof(a[0]);
	HeapSort(a, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d  "Json解析工具类
 鼓励师加成太刺激了，鼻血喷了半斤，代码不一会儿就写完了...
 鼓励师加成太刺激了，鼻血喷了半斤，代码不一会儿就写完了...
 如何封装JSON数据
 查看发票组代码后的总结和有感
 有啥软件可以自定义字 也就是自己想写啥就写啥 并把写的字弄成