数据结构---非线性--树

1.树的概念及结构

1.1树的概念

树是一种非线性的数据结构，由有限个结点组成一个具有层次关系的集合，看起来像是一颗倒挂的树，故称为树，根朝上，叶朝下。

• 有一个特殊的结点，称为根结点，根节点没有前驱结点
• 除根结点之外，其余结点被分成M(M>0)个互不相交的集合T1、T2......Tm，其中每一个集合Ti（1<=i<=m）又是一个与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。说白了就是树是递归定义的

 

注：树形结构中，子树不能有交集，否则就不是树形结构

 1.2树的相关概念

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

1.3树的表示

树形结构不同于线性结构，存储较为麻烦，既要保存值域，也要保存节点和节点之间的关系，实际中有很多表示方法，双亲表示法、孩子表示法、孩子双亲表示法以及孩子兄弟表示法等，本文了解常用的孩子兄弟表示法。 

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

1.4树在实际中的运用

2.二叉树的概念及结构

2.1概念

一颗二叉树是节点的有限集合，该集合：

1. 或者为空
2. 由一个根结点加上两颗别称wield左子树和右子树的二叉树组成

注：

• 二叉树不存在度大于2的结点
• 二叉树的子树有左右之分，次序不能颠倒，二叉树是有序树

 任意二叉树都是由以下情况复合而成 

 2.2特殊的二叉树：

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

 2.3二叉树的性质

1. 若规定根结点的层数为1，则一颗非空二叉树的第i层上最多有2（i - 1）个结点
2. 若规定根结点的层数为1，则深度为h的二叉树的最大结点数是2^h - 1
3. 对任何一颗二叉树，如果度为0的叶结点个数为N1,度为2的分支结点个数为N2，则有N1 = N2 + 1
4.  若规定根结点的层数为1，具有n个结点的满二叉树的深度，h = log(n + 1).（ps:log（n + 1）是log以2为底，（n + 1）为对数）
5. 对于具有n个节点的完全二叉树，如果按照从上至下总左至右的数组顺序对所有结点从0开始编号，则对于序号为i的结点有：

• 若i > 0，i位置的双亲序号：（i - 1）/ 2; i = 0，i为根结点编号，无双亲结点
• 若2i + 1 < n，左孩子序号：2i + 1
• 若2i + 1 < n，右孩子序号：2i + 2

 2.4二叉树的存储结构

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

2.4.1顺序存储

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

2.4.2链式存储

二叉树的链式存储是指，用链表来表示一颗二叉树，即用链表来指示元素的逻辑关系。常用的方法是链表中的每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链接点的存储位置。链式结构也分为二叉链和三叉链，本文讨论的是二叉链。

 

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

3.1二叉树的顺序结构

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

3.2堆的概念及结构

如果有一个关键码的集合K={k₀,k₁,k₂,...,kₙ₋₁}，把它所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Kᵢ <= K₂ᵢ₊₁且Kᵢ <= K₂ᵢ₊₂（Kᵢ >= K₂ᵢ₊₁且Kᵢ >= K₂ᵢ₊₂）i=0、1、……，则称为小堆（或大堆）。将根节点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或者小根堆；堆具有以下性质：

• 堆中某个结点的值总是不大于或不小于其父节点的值
• 堆总是一颗完全二叉树

3.3堆的实现

3.3.1堆的向下调整算法

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

int array[] = {27,15,19,18,28,34,65,49,25,37};

void AdjustDown(HPDataType* a, int parent,int n)
{
	//假设左孩子小/大
	int child = parent * 2 + 1;
	while (child <= n)
	{
        //'<'建小堆;'>'建大堆
		if (a[child+1] < a[child] && child+1 <= n)
		{
			child = parent * 2 + 2;
		}
		if(a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

3.3.2堆的向上调整算法

同样给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在通过算法，将它构建成一个堆。根结点的左右子树不是堆，就需要用到向上调整算法，从倒数第一个非叶子结点的子树开始调整，一直调整到根结点的树，就可以调整成堆。

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
    //'<'建小堆；'>'建大堆
	while (a[child] < a[parent])
	{
		Swap(&a[child],&a[parent]);
		child = parent;
		parent = (child - 1) / 2;
	}
}

3.2.3建堆时间复杂度

因为堆事完全二叉树，而完全二叉树也是满二叉树，在讨论时间复杂度的时候，都讨论最坏情况，在本文计算建堆时间复杂度时使用满二叉树来证明，多几个结点不影响最终结果：

3.2.4堆的插入

先将数据插入数组的尾巴上，再将其向上调整，直到满足堆。

3.2.5堆的删除

删除堆是删除堆顶的数据，若是直接删除堆顶的数据，然后调整左右子树的话，就会导致原来的堆被打乱，原有的关系也会混乱；并且堆在物理上是数组，删除第一个数据的话，后面的数据全部都要往前挪动；因此在删除数据时，先将堆顶的数据和最后一个数据交换，然后删除数组最后一个数据，这样即不需要挪动数据，也不会将原有的堆打乱，只需要将新的堆顶数据向下调整即可。

3.2.6堆的代码实现 

typedef int HPDataType;
typedef struct Heap
{
	HPDataType*a;
	int size;
	int capacity;
}HP;

void HPInit(HP* obj);
void HPPush(HP* obj, HPDataType x);
void HPDestroy(HP* obj);
void HPPop(HP* obj);
HPDataType HPTop(HP* obj);
bool HPEmpty(HP* obj);
int HPSize(HP* obj);

void Swap(HPDataType* x, HPDataType* y);
void AdjustUp(HPDataType* a, int parent);
void AdjustDown(HPDataType* a, int parent,int n);

void HPInit(HP* obj)
{
	obj->a = NULL;
	obj->capacity = obj->size = 0;
}
void Swap(HPDataType *a,HPDataType *b)
{
	HPDataType tmp = *a;
	*a = *b;
	*b = tmp;
}
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (a[child] < a[parent])
	{
		Swap(&a[child],&a[parent]);
		child = parent;
		parent = (child - 1) / 2;
	}
}
void AdjustDown(HPDataType* a, int parent,int n)
{
	int child = parent * 2 + 1;
	while (child <= n)
	{
		if (a[child+1] < a[child] && child+1 <= n)
		{
			child = parent * 2 + 2;
		}
		if(a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HPPush(HP* obj, HPDataType x) {
	assert(obj);
	if (obj->capacity == obj->size)
	{
		int new_capacity = obj->capacity==0?4:2*obj->capacity;
		HPDataType* tmp = (HPDataType*)realloc(obj->a, new_capacity * sizeof(HPDataType));
		if (tmp == NULL)
		{
			perror("realloc failed");
			exit(1);
		}
		obj->a = tmp;
		obj->capacity = new_capacity;
	}
	obj->a[obj->size] = x;
	obj->size++;
	AdjustUp(obj->a, obj->size-1);
}
void HPPop(HP* obj)
{
	assert(obj);
	assert(obj->size > 0);
	Swap(&(obj->a[0]), &(obj->a[obj->size-1]));
	obj->size--;
	AdjustDown(obj->a, 0,obj->size-1);
}
HPDataType HPTop(HP* obj)
{
	assert(obj);
	assert(obj->size > 0);
	return obj->a[0];
}
bool HPEmpty(HP* obj)
{
	return (obj->size == 0);
}
int HPSize(HP* obj)
{
	return obj->size - 1;
}
void HPDestroy(HP* obj)
{
	assert(obj);
	free(obj->a);
	obj->a = NULL;
}

 3.4堆的应用

3.4.1堆排序

堆排序即利用堆的思想来进行排序，总共分为两步：

1.建堆

• 升序：建大堆
• 降序：建小堆

2.利用堆删除进行排序

建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序；向下调整适合处理这种大规模的堆数据，因为其时间复杂度优于向上调整；还有就是，我们在调整堆的时候，是要不断将最大或最小元素移除堆，并没有插入新元素，因此在首尾交换之后，向下调整更为适合。在这里就可以很好地解释为什么升序不是建小堆而是大堆的原因，因为我们收尾交换之后，大的（小的）就换到后面去了，顺序就和对大小堆的直觉是相反的，交换之后，不删除，这样就逐渐有序了。

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (a[child] < a[parent])
	{
		Swap(&a[child],&a[parent]);
		child = parent;
		parent = (child - 1) / 2;
	}
}
void AdjustDown(HPDataType* a, int parent,int n)
{
	int child = parent * 2 + 1;
	while (child <= n)
	{
		if (a[child+1] < a[child] && child+1 <= n)
		{
			child = parent * 2 + 2;
		}
		if(a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HPSort(int *a,int n)
{
	//建堆:
	//向下调整建堆O(N)
	int k = ((n - 1) - 1) / 2;
	while (k >= 0)
	{
		AdjustDown(a, k, n-1);
		k--;
	}
	//向下调整排序(首尾交换,然后向下调整)  
	int end = (n - 1);
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		end--;
		AdjustDown(a, 0, end);
	}
	for (int j = 0; j < n; j++)
	{
		printf("%d  ", a[j]);
	}
}

3.4.2Top-K问题

Top-K问题：即求数据中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

比如：专业前10名、世界500强、富豪榜、国服榜等。

对于Top-K问题，最简单直接的方式就是直接排序，但是在数据量很大的时候，排序就不太可取（数据不能一下子全部加载到内存中）。最佳的方式就是用堆来解决，具体步骤如下:

1.用数据中的前K个来建堆

• 前K个最大的元素，则建小堆（小堆才能让大的数据进堆）
• 前K个最小的元素，则建大堆（大堆才能让小的数据进堆）

2.用剩余的N-K个元素来比较，不满足则替换堆顶元素

将剩余N-K个元素依次与堆顶元素比较之完后，堆中剩余的K个元素就是所求的前K个最大或最小的元素。

//创造数据进行测试
void CreateData()
{
	int n = 100000;
	srand(time(0));
	const FILE* pFile = fopen("data.txt", "w");
	if (pFile == NULL)
	{
		perror("fopean error");
		exit(1);
	}
	for (int i = 0; i < n; i++)
	{
		int x = rand()+i/1000000;
		fprintf(pFile,"%d\n", x);
	}
	fclose(pFile);
}
void TopK()
{
	int k = 0;
	scanf("%d", &k);
	int* KHeap = (int*)malloc(sizeof(int) * k);
	if (KHeap == NULL)
	{
		perror("Malloc fail");
		return;
	}
	const char* file = "data.txt";
	FILE* pFile = fopen(file, "r");
	if (pFile == NULL)
	{
		perror("fopen error");
		return;
	}
	//从文件中读取前k个数
	for (int j = 0; j < k; j++)
	{
		fscanf(pFile, "%d", &KHeap[j]);
	}
	//建立k个数的小堆
	for (int i = (k-1-1)/2; i >=0; i--)
	{
		AdjustDown(KHeap, i, k-1);
	}
	//剩下的N-K个数和堆顶的数比较
	int tmp = 0;
	while (fscanf(pFile, "%d", &tmp) > 0)
	{
		if (tmp > KHeap[0])
		{
			KHeap[0] = tmp;
			AdjustDown(KHeap, 0, k-1);
		}
	}
	for (int l = 0; l < k; l++)
	{
		printf("%d  ",KHeap[l]);
	}
}

4.二叉树的链式结构及实现

4.1前置声明

本文暂时不介绍创建二叉树，在文中采取简单粗暴的方式手动创建二叉树。

typedef int BTNodeType;
typedef struct BTreeNode
{
	int data;
	struct BTreeNode* left;
	struct BTreeNode* right;
}BTNode;

BTNode* ByNode(BTNodeType x)
{
	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	tmp->data = x;
	tmp->left = NULL;
	tmp->right = NULL;
	return tmp;

}
BTNode* CreateBTNode()
{
	BTNode* node1 = ByNode(1);
	BTNode* node2 = ByNode(2);
	BTNode* node3 = ByNode(3);
	BTNode* node4 = ByNode(4);
	BTNode* node5 = ByNode(5);
	BTNode* node6 = ByNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}

4.2二叉树的遍历

4.2.1前序、中序以及后序遍历

二叉树最简单的操作就是遍历。二叉树遍历就是按照某种特定的规则，依次对二叉树中的结点进行相应操作，并且每个结点只操作一次。访问结点所做的操作依赖于具体应用的问题。遍历是二叉树最重要的运算之一，也是二叉树上进行其他运算的基础。

 按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。 

前序递归图解：

 

前序遍历结果：1 2 3 4 5 6
中序遍历结果：3 2 1 5 4 6
后序遍历结果：3 2 5 6 4 1

4.2.2 层序遍历

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根结点所在层数为1，层序遍历就是从所在二叉树的根结点出发，首先访问第一层的树根结点，然后从左到右访问第2层上的结点，接着是第三层的结点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

层序遍历的时候，先遍历第一层根结点，然后根节点出，带入根结点的下一层（左右子树），需要把结点的指针保存，那保存在什么里面呢？先进去的先出来，没错，就是队列，将根结点的放入队列中，然后依次出队列，并将对应的左右子树入队列，直到队列中的所有数据全部出完，那么二叉树的层序遍历就算是完成了。

void LevelOrder(BTNode* root)
{
	Queue tmp;
	QueueInit(&tmp);
	//root不为空入队列
	if (root)
		QueuePush(&tmp, root);
	//队列不为空，先出一层，带入下一层
	while (!QueueEmpty(&tmp))
	{
		BTNode* tmp_root = QueueFront(&tmp);
		printf("%d ", tmp_root->data);
		if(tmp_root->left)
			QueuePush(&tmp, tmp_root->left);
		if(tmp_root->right)
			QueuePush(&tmp, tmp_root->right);
		QueuePop(&tmp);
	}
	printf("\n");
	QueueDestroy(&tmp);
}

4.3二叉树常见接口

4.3.1二叉树结点个数

递归的方式求结点个数。

int TreeSize(BTNode* root)
{
	return root == NULL ? 0 :
		TreeSize(root->left) + TreeSize(root->right)+1;
}

4.3.2二叉树叶子结点个数

和结点个数求法类似，判断是否为叶子结点即可。

int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->right == NULL && root->left == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

4.3.3二叉树第K层节点个数

用递归的方式来理解，第K层的结点就是第一层＋第K - 1层的结点。

int TreeLevelKSize(BTNode* root,int k)
{
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	return 
		TreeLevelKSize(root->left, k - 1) +
		TreeLevelKSize(root->right, k - 1);
}

4.3.4二叉树查找值为X的结点

查找的时候要特别注意，因为采用的是递归查找，所以要想函数递归返回的时候能够准确的保存查找到的结点，必须要将查找到的节点保存，这样也可以提高效率，不用每次递归都重新查找。

BTNode* TreeSeek(BTNode* root, BTNodeType x)
{
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;
	BTNode* ret1 = TreeSeek(root->left, x);
	if (ret1)
		return ret1;
	BTNode* ret2 = TreeSeek(root->right, x);
	if (ret2)
		return ret2;
	return NULL;
}

4.3.5二叉树的高度

二叉树的高度，可以递归为根结点 的高度+左右子树的高度的最大值。

int TreeHeight(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return (int)fmax(TreeHeight(root->left) , TreeHeight(root->right))+1;
}

4.3.6二叉树的销毁

二叉树在销毁时，和后序一样，最后销毁根结点，就可以把左右子树都销毁。

void TreeDestory(BTNode* root)
{
	if (root == NULL)
		return;
	TreeDestory(root->left);
	TreeDestory(root->right);
	free(root);
}