[数据结构]二叉树的顺序存储结构

目录

二叉树的顺序存储结构：：

                                            1.二叉树的顺序结构

                                            2.堆的概念及结构

                                            3.堆的创建

                                            4.建堆时间复杂度的证明

                                            5.堆的插入

                                            6.堆的删除

                                            7.堆的代码实现

                                            8.堆排序

                                            9.Top-K问题

二叉树的顺序存储结构：：

二叉树的顺序结构

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

堆的概念及结构：

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

堆的性质：

1.堆中某个节点的值总是不大于或不小于其父节点的值.

2.堆总是一颗完全二叉树.

 选择题：

1.下列关键字序列为堆的是：（）
A 100,60,70,50,32,65
B 60,70,65,50,32,100
C 65,100,70,32,50,60
D 70,65,100,32,50,60
E 32,50,100,70,65,60
F 50,100,70,65,60,32
2.已知小根堆为8,15,10,21,34,16,12，删除关键字 8 之后需重建堆，在此过程中，关键字之间的比较次数是（）。
A 1
B 2
C 3
D 4
3.一组记录排序码为(5 11 7 2 3 17),则利用堆排序方法建立的初始堆为
A(11 5 7 2 3 17)
B(11 5 7 2 17 3)
C(17 11 7 2 3 5)
D(17 11 7 5 3 2)
E(17 7 11 3 5 2)
F(17 7 11 3 2 5)
4.最小堆[0,3,2,5,7,4,6,8],在删除堆顶元素0之后，其结果是（）
A[3，2，5，7，4，6，8]
B[2，3，5，7，4，6，8]
C[2，3，4，5，7，8，6]
D[2，3，4，5，6，7，8]
选择题答案：
1.A
2.C
3.C
4.C

堆的实现：

  堆的创建：

 

  建堆时间复杂度的证明： 

堆的代码实现：
Heap.h

#pragma once
#include
#include
#include
#include
#include
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;
void HeapPrint(HP* php);
void AdjustUp(HPDataType* a, int child);
void AdjustDown(HPDataType* a, int n, int parent);
void HeapInit(HP* php);
void Swap(HPDataType* p1, HPDataType* p2);
void HeapDestory(HP* php);
//插入x继续保持堆形态
void HeapPush(HP* php, HPDataType x);
//删除堆顶的元素
void HeapPop(HP* php);
//返回堆顶的元素
HPDataType HeapTop(HP* php);
bool HeapEmpty(HP* php);
int HeapSize(HP* php);

Heap.c

#include"Heap.h"
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = php->capacity = 0;
}
void HeapDestory(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}
//向上调整算法
//堆的向上调整次数为完全二叉树的层数，即向上调整算法(堆中插入x)的时间复杂度为O(logN)
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//不要用while(parent>=0)作继续条件 当child=0时 parent仍为0 程序陷入死循环
	while (child > 0)
	{
		//小于改大于变大堆
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}

}
//插入x继续保持堆形态
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(HPDataType* a, int n, int parent)
{
	int minChild = parent * 2 + 1;
	while (minChild < n)
	{
		//找出小的那个孩子
		if (minChild + 1 < n && a[minChild + 1] < a[minChild])
		{
			minChild++;
		}
		if (a[minChild] < a[parent])
		{
			Swap(&a[minChild], &a[parent]);
			parent = minChild;
			minChild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//删除堆顶的元素——找次大或者次小
//时间复杂度为O(logN)
void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdjustDown(php->a, php->size, 0);
}
//返回堆顶的元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->a[0];
}
int HeapSize(HP* php)
{
	assert(php);
	return php->size;
}
void HeapPrint(HP* php)
{
	for (int i = 0; i < php->size; i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

堆的初始化：

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

堆的销毁：

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

堆的判空：

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

向上调整算法：

//向上调整算法
//堆的向上调整次数为完全二叉树的层数，即向上调整算法(堆中插入x)的时间复杂度为O(logN)
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//不要用while(parent>=0)作继续条件 当child=0时 parent仍为0 程序陷入死循环
	while (child > 0)
	{
		//小于改大于变大堆
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

堆的插入：

 先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

//插入x继续保持堆形态
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(HPDataType* a, int n, int parent)
{
	int minChild = parent * 2 + 1;
	while (minChild < n)
	{
		//找出小的那个孩子
		if (minChild + 1 < n && a[minChild + 1] < a[minChild])
		{
			minChild++;
		}
		if (a[minChild] < a[parent])
		{
			Swap(&a[minChild], &a[parent]);
			parent = minChild;
			minChild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

堆的删除：

//删除堆顶的元素——找次大或者次小
//时间复杂度为O(logN)
void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdjustDown(php->a, php->size, 0);
}

返回堆顶元素：

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->a[0];
}

堆的大小：

int HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

堆的打印：

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

堆的应用：

堆排序建堆： 

 

 

 堆排序代码实现： 

 

void AdjustDown(int* a, int n, int parent)
{
	int maxChild = parent * 2 + 1;
	while (maxChild < n)
	{
		//找出小的那个孩子
		if (maxChild + 1 < n && a[maxChild + 1] > a[maxChild])
		{
			maxChild++;
		}
		if (a[maxChild] > a[parent])
		{
			Swap(&a[maxChild], &a[parent]);
			parent = maxChild;
			maxChild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int n)
{
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	int i = 1;
	while (i < n)
	{
		Swap(&a[0], &a[n - i]);
		AdjustDown(a, n - i, 0);
		i++;
	}
}
#include
int main()
{
	int a[] = { 15,1,19,25,8,34,65,4,27,7 };
	HeapSort(a, sizeof(a) / sizeof(a[0]));
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

Top-K问题：

Top-K问题：即求数据中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。比如专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

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

//Top-K问题
void AdjustDown(int* a, int n, int parent)
{
	int minChild = parent * 2 + 1;
	while (minChild < n)
	{
		//找出小的那个孩子
		if (minChild + 1 < n && a[minChild + 1] < a[minChild])
		{
			minChild++;
		}
		if (a[minChild] < a[parent])
		{
			Swap(&a[minChild], &a[parent]);
			parent = minChild;
			minChild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void CreateDataFile(filename, N)
{
	FILE* pf = fopen(filename, "w");
	if (pf == NULL)
	{
		perror("fopen fail");
		return;
	}
	for (int i = 0; i < N; i++)
	{
		fprintf(pf, "%d ", rand());
	}
	fclose(pf);
}
void PrintTopK(const char* filename, int k)
{
	assert(filename);
	FILE* pf = fopen(filename, "r");
	if (pf == NULL)
	{
		perror("fopen fail");
		return;
	}
	int* minHeap = (int*)malloc(sizeof(int) * k);
	if (minHeap == NULL)
	{
		perror("malloc fail");
		return;
	}
	//如何读取前K个数据
	for (int i = 0; i < k; i++)
	{
		fscanf(pf, "%d", &minHeap[i]);
	}
	//建k个数小堆
	for (int j = (k - 1 - 1) / 2; j >= 0; j--)
	{
		AdjustDown(minHeap, k, j);
	}
	//继续读取后N-K个
	int val = 0;
	while (fscanf(pf, "%d", &val) != EOF)
	{
		if (val > minHeap[0])
		{
			minHeap[0] = val;
			AdjustDown(minHeap, k, 0);
		}
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", minHeap[i]);
	}
	free(minHeap);
	fclose(pf);
}
int main()
{
	srand((unsigned int)time(NULL));
	const char* filename = "Data.txt";
	int N = 10000;
	int K = 10;
	CreateDataFile(filename, N);
	PrintTopK(filename, K);
	return 0;
}