数据结构--堆(二叉树学习前必看)

长路漫漫, 唯剑作伴.

概述

要学习二叉树, 先来看看二叉树的分类, 二叉树的分类可根据存储方式来:

从存储方式来看, 二叉树更加适合链式结构, 能更加节省空间, 避免空间浪费.
但顺序结构也适合一些特殊的二叉树 .如:完全二叉树.
由完全二叉树衍生出来的堆, 也是一个十分重要的数据结构
注意: 这里的堆与计算机内存的堆完全是两码事.这里指的是存储结构.
在学习堆之前, 应该知晓 完全二叉树的一些基本知识:

堆的概念

堆的操作相对顺序表比较复杂, 先来看堆的结构实现

typedef struct Heap
{
	HPDataType* _array;
	int _capacity;
	int _size;
}Heap;

时间复杂度

建堆O(n) +排序O(nlogn) = O(nlogn)

堆排序的时间复杂度，主要在初始化堆过程和每次选取最大数后重新建堆的过程；

1. 初始化建堆过程时间：O(n)

推算过程：

首先要理解怎么计算这个堆化过程所消耗的时间，可以直接画图去理解；

假设高度为k，则从倒数第二层右边的节点开始，这一层的节点都要执行子节点比较然后交换（如果顺序是对的就不用交换）；倒数第三层呢，则会选择其子节点进行比较和交换，如果没交换就可以不用再执行下去了。如果交换了，那么又要选择一支子树进行比较和交换；

那么总的时间计算为：s = 2^( i - 1 ) * ( k - i )；其中 i 表示第几层，2^( i - 1) 表示该层上有多少个元素，( k - i) 表示子树上 k = log(n) + 1，带入 S = 2^k -k -1，得到：S = 2n - logn -2

所以时间复杂度为：O(n)

2. 更改堆元素后重建堆时间：O(nlogn)

推算过程：

循环 n -1 次，每次都是从根节点往下循环查找，所以每一次时间是 logn，总时间：logn(n-1) = nlogn - logn ；

综上所述：堆排序的时间复杂度为：O(nlogn)

堆的主要函数

void HeapInit(Heap* hp, HPDataType* array, int size);
void HeapInsert(Heap* hp, HPDataType data);
void HeapErase(Heap* hp);
int HeapSize(Heap* hp);
int HeapEmpty(Heap* hp);
HPDataType HeapTop(Heap* hp);
void HeapDestroy(Heap* hp);

void HeapSort(int* array, int size);

难点:

代码实现及注释

void swap(HPDataType* child, HPDataType* parent)
{
	HPDataType tmp;
	tmp = *child;
	*child = *parent;
	*parent = tmp;
}

// parent为要调整的节点
void AdjustDown(HPDataType* array, int size, int parent)
{
	// 默认让child标记parent的左孩子, 
	// 因为: 完全二叉树某个节点如果只有一个孩子, 该孩子一定是其双亲的左孩子
	int child = parent * 2 + 1;
	while (child < size)
	{
		// 找双亲孩子中较小的孩子 交换
		if (child + 1 < size && array[child] > array[child + 1])
		{
			child++;
		}

		if (array[child] < array[parent])
		{
			swap(&array[child], &array[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			return;
		}
	}
}

// 所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中
void HeapInit(Heap* hp, HPDataType* array, int size)
{
	assert(hp);
	hp->_array = (HPDataType*)malloc(sizeof(HPDataType) * size);
	if (NULL == hp->_array)
	{
		assert(0);
		return;
	}
	hp->_capacity = size;
	for (int i = 0; i < size; ++i)
	{
		hp->_array[i] = array[i];
	}
	hp->_size = size;

	// 堆的特性: 堆中某个节点的值总是不大于或不小于其父节点的值还不满足
	// 进行调整
	// 向下调整---创建堆的关键一步
	// 向下调整算法有一个前提：左右子树必须是一个堆，才能调整

	// 找完全二叉树中倒数第一个非叶子节点, 从此向上把每一个节点下的都调整成堆
	// 一直到跟节点
	int root = (size - 2) >> 1; // 最后一个节点下标为size - 1; 其双亲节点为 (k - 1) /2
	for (; root >= 0; --root)
	{
		AdjustDown(hp->_array, size, root);
	}	
}

void AdjustUP(HPDataType* array, int size, int child)
{
	int parent = (child - 1) / 2;
	while (child)
	{
		if (array[parent] > array[child])
		{
			swap(&array[parent], &array[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			return;
		}
	}
}

void CheakCapacity(Heap* hp)
{
	assert(hp);
	if (hp->_size == hp->_capacity)
	{
		int newCapacity = 2 * hp->_capacity;
		HPDataType* pTemp = (HPDataType*)malloc(sizeof(HPDataType) * newCapacity);
		if (NULL == pTemp)
		{
			assert(0);
			return;
		}
		hp->_capacity = newCapacity;
		for (int i = 0; i < hp->_size; ++i)
		{
			pTemp[i] = hp->_array[i];
		}
		free(hp->_array);
		hp->_array = pTemp;
	}
}

void HeapInsert(Heap* hp, HPDataType data)
{
	assert(hp);
	CheakCapacity(hp);
	hp->_array[hp->_size] = data;
	hp->_size++;
	AdjustUP(hp->_array, hp->_size, hp->_size - 1);
}

// 应该删除堆顶的, 因为堆顶不是最大的就是最小的
// 堆顶与最后一个交换, size--, 再来一次向下调整算法
void HeapErase(Heap* hp)
{
	assert(hp);
	if (HeapEmpty(hp))
	{
		return;
	}
	swap(&hp->_array[0], &hp->_array[hp->_size - 1]);
	hp->_size -= 1;
	AdjustDown(hp->_array, hp->_size, 0);
}

int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->_size;
}

int HeapEmpty(Heap* hp)
{
	assert(hp);
	return 0 == hp->_size;
}

HPDataType HeapTop(Heap* hp)
{
	assert(hp);
	return hp->_array[0];
}

void HeapDestroy(Heap* hp)
{
	assert(hp);
	if (hp->_array)
	{
		free(hp->_array);
		hp->_array = NULL;
		hp->_size = hp->_capacity = 0;
	}
}

void HeapAdjust(int* array, int size, int parent)
{
	int child = parent * 2 + 1;
	
	while (child < size)
	{
		if (child + 1 < size && array[child] < array[child + 1])
		{
			child += 1;
		}
		if (array[child] > array[parent])
		{
			swap(&array[child], &array[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			return;
		}
	}
}

void HeapSort(int* array, int size)
{
	// 1.建立堆, 如果是升序建大堆, 降序建小堆

	int root = ((size - 2) >> 1);
	for (; root >= 0; --root)
	{
		HeapAdjust(array, size, root);
	}

	// 2. 排序, 用堆删除的思想

	int end = size - 1;
	while (end)
	{
		swap(&array[0], &array[end]);
		HeapAdjust(array, end, 0);
		end--;
	}
}

堆的引用