数据结构初阶：二叉树（一）

树概念及结构

树的概念

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

 树的相关概念

节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6

叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I...等节点为叶节点

树的表示

typedef int DataType ;

struct Node

{

struct Node * _firstChild1 ; // 第一个孩子结点

struct Node * _pNextBrother ; // 指向其下一个兄弟结点

DataType _data ; // 结点中的数据域

};

 树在实际中的运用（表示文件系统的目录树结构）

 二叉树概念及结构

概念

从上图可以看出：

注意：对于任意的二叉树都是由以下几种情况复合而成的：

 现实中的二叉树：

特殊的二叉树：

二叉树的性质

性质练习题：

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）

A 不存在这样的二叉树

B 200

C 198

D 199

2. 下列数据结构中，不适合采用顺序存储结构的是（ ）

A 非完全二叉树

B 堆

C 队列

D 栈

3. 在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）

A n

B n+1

C n-1

D n/2

4. 一棵完全二叉树的节点数位为 531 个，那么这棵树的高度为（ ）

A 11

B 10

C 8

D 12

5. 一个具有 767 个节点的完全二叉树，其叶子节点个数为（）

A 383

B 384

C 385

D 386

答案：

1.B

2.A

3.A

4.B

5.B

二叉树的存储结构 

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

typedef int BTDataType ;

// 二叉链

struct BinaryTreeNode

{

struct BinTreeNode * _pLeft ; // 指向当前节点左孩子

struct BinTreeNode * _pRight ; // 指向当前节点右孩子

BTDataType _data ; // 当前节点值域

}

// 三叉链

struct BinaryTreeNode

{

struct BinTreeNode * _pParent ; // 指向当前节点的双亲

struct BinTreeNode * _pLeft ; // 指向当前节点左孩子

struct BinTreeNode * _pRight ; // 指向当前节点右孩子

BTDataType _data ; // 当前节点值域

} ；

二叉树的顺序结构及实现

二叉树的顺序结构

堆的概念及结构

堆的实现

堆向下调整算法

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

堆的创建

建堆时间复杂度

向下调整建堆的时间复杂度：O(N)

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明 ( 时间复杂度本来看的就是近似值，多几个节点不影响最终结果) ：

 因此：建堆的时间复杂度为O(N)。故实际中我们选用向下调整建堆

向上调整建堆的时间复杂度：O(N*logN)

简单理解：

// O(N*logN)
for (int i = 0; i < n; i++)  //插入N个数据，每个数据挪动logN次(因为h=log(N+1))，合计N*logN
{
	AdjustUp(a, i); //logN
}

其实光看最后一层（占了一半的结点）就知道N/2个数据挪动logN次，即时间复杂度：O(N*logN)

堆的插入

堆的删除

堆的代码实现(小堆)

Heap.h

#pragma once
#include<stdio.h>
#include<stdlib.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 HeapDestroy(HP* php);
void HeapPush(HP* php, HPDataType x);
// 规定删除堆顶（根节点）
void HeapPop(HP* php);
HPDataType HeapTop(HP* php);
int HeapSize(HP* php);
bool HeapEmpty(HP* php);
 
void Swap(HPDataType* p1, HPDataType* p2);
void AdjustUp(HPDataType* a, int child);
void AdjustDown(HPDataType* a, int size, int parent);

Heap.c

#include"Heap.h"
 
// 小堆
void HeapInit(HP* php)
{
	assert(php);
 
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}
 
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;
		}
	}
}
 
// O(logN)
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newCapacity * sizeof(HPDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		
		php->a = tmp;
		php->capacity = newCapacity;
	}
 
	php->a[php->size] = x;
	php->size++;
 
	AdjustUp(php->a, php->size - 1);
}
 
void AdjustDown(int* a, int size, int parent)
{
	int child = parent * 2 + 1;
 
	while (child < size)
	{
		// 假设左孩子小，如果解设错了，更新一下
        // child+1 < 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];
}
 
int HeapSize(HP* php)
{
	assert(php);
 
	return php->size;
}
 
bool HeapEmpty(HP* php)
{
	assert(php);
 
	return php->size == 0;
}

Test.c

#include"Heap.h"
 
int main()
{
	int a[] = { 4,6,2,1,5,8,2,9};
	HP hp;
	HeapInit(&hp);
	for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
	{
		HeapPush(&hp, a[i]);
	}
 
	/*int k = 3;
	while (k--)
	{
		printf("%d\n", HeapTop(&hp));
		HeapPop(&hp);
	}*/
 
	while (!HeapEmpty(&hp))
	{
		printf("%d ", HeapTop(&hp));
		HeapPop(&hp);
	}
	printf("\n");
 
	return 0;
}

堆的应用

堆排序（选择排序）

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

代码：

// 升序：建大堆
void HeapSort(int* a, int n)
{
	// 建大堆
	// O(N*logN)
	/*for (int i = 0; i < n; i++)
	{
		AdjustUp(a, i);
	}*/
 
	// 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;
	}
}

TOP-K问题 

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

对于 Top-K 问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了 ( 可能数据都不能一下子全部加载到内存中) 。最佳的方式就是用堆来解决，基本思路如下：

1. 用数据集合中前K个元素来建堆

前 k 个最大的元素，则建小堆

前 k 个最小的元素，则建大堆

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

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

例如：求数据集合中前 K 个最大的元素

void CreateNDate()
{
	// 造数据
	int n = 10000000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}
 
	for (int i = 0; i < n; ++i)
	{
		int x = (rand()+i) % 10000000;
		fprintf(fin, "%d\n", x);
	}
 
	fclose(fin);
}
 
void PrintTopK(const char* file, int k)
{
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}
 
	// 建一个k个数小堆
	int* minheap = (int*)malloc(sizeof(int) * k);
	if (minheap == NULL)
	{
		perror("malloc error");
		return;
	}
 
	// 读取前k个，建小堆
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &minheap[i]);
		AdjustUp(minheap, i);
	}
 
	int x = 0;
	while (fscanf(fout, "%d", &x) != EOF)
	{
		if (x > minheap[0])
		{
			minheap[0] = x;
			AdjustDown(minheap, k, 0);
		}
	}
 
	for (int i = 0; i < k; i++)
	{
		printf("%d ", minheap[i]);
	}
	printf("\n");
 
	free(minheap);
	fclose(fout);
}
 
int main()
{
	 CreateNDate();
	PrintTopK("data.txt", 5);
 
	return 0;
}