数据结构之堆相关操作

**1、堆的概念：**堆是一种特殊的完全二叉树，下面所示的就是一个最大堆，它的每一个父节点都大于其子节点，还有最小堆，它的每一个父节点都小于它的所有子节点。

堆的特性：
a)、堆中某个节点的值总是不大于或不小于其父节点的值；
b)、堆总是一棵完全二叉树。

2、数据结构中堆与内存堆区的区别：

1)数据结构中的堆*：**是一种特殊的完全二叉树，堆是一种经过排序的树形数据结构，每个结点都有一个值，存取非常随意。

2)内存分配中的栈和堆：
a)堆栈空间分配

栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。

b)堆栈缓存方式

栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放。

堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。

3、堆的基本操作的实现（C语言）：

typedef int Datatype;
typedef struct {
int _capactiy;
int _size;
Datatype* _array;

} heap;


// 以下是最小堆的实现


void CreatHeap(heap* hp, int array[], int size){
// 初始化
hp->_array = (Datatype*)malloc(sizeof(Datatype));
hp->_size = 0;
hp->_capactiy = size;

// 把数组放到堆中

for (int i = 0; i < size; i++){
	hp->_array[i] = array[i];
}

// 向下调整
int parent = 0;
int child = parent * 2 + 1;
while (child < size){
	if (hp->_array[child] < hp->_array[parent]){
		swap(&hp->_array[child], &hp->_array[parent]);
		
		parent = child;
		child = parent * 2 + 1;

	}
	else{
		return;

	}
}




}
void DestoryHeap(heap* hp){
assert(hp);

free(hp->_array);
hp->_array = NULL;    // 需要手动赋空，否则会导致hp->_array成为野指针
hp->_capactiy = 0;
hp->_size = 0;
}

void swap(int *a, int *b){
int temp = *a;
*a = *b;
*b = temp;
}
void InsertHeap(heap* hp, int k){
assert(hp);

hp->_array[hp->_size++] = k;

 int child = (hp->_size) - 1;   // 最后一个结点
 int parent = (child - 1 << 1);     // 最后一个非叶子结点
 // 判断是否需要交换

 while (child){
	 if ((child + 1) < hp->_size){//判断是否有右子树，并且取出其中较小的
			 child = child + 1;
	 }
	
	 if (hp->_array[child] < hp->_array[parent]){
		 swap(&hp->_array[child], &hp->_array[parent]);
		 // 交接完之后向上调整
		 child = parent;
		 parent = (child - 1 << 1);
	 }

	 else{
		 return;
	 }

 }

}
Datatype TopHeap(heap* hp){
assert(hp);
return hp->_array[0];

}

int SizeHeap(heap* hp){
assert(hp);
return hp->_size;
}


int  IsEmptyHeap(heap* hp){
assert(hp);
return hp->_size;   // 根据size的返回值判断堆是否为空

}


void EreaseHeap(heap* hp,int size){
assert(hp);


int last = hp->_size - 1;   // 最后一个结点
swap(&hp->_array[0] ,&hp->_array[last]);
hp->_size--;

// 删除完成之后进行向下调整

// 向下调整
int parent = 0;
int child = parent * 2 + 1;
while (child < size){
	if (hp->_array[child] < hp->_array[parent]){
		swap(&hp->_array[child], &hp->_array[parent]);

		parent = child;
		child = parent * 2 + 1;

	}
	else{
		return;

	}
}


}

堆排序的实现：

利用堆得删除操作来实现序列的排序，升序用大堆，降序用小堆
1、建堆
找最后一个非叶子结点，不断的调整，直到最后一个父节点

	调整过程： 
		拿当前父节点与左右孩子比较大小，然后交换

2、排序
拿堆顶元素与最后一个元素进行交换，交换后最后一个元素不参与调整
将对顶元素作为调整起点做向下调整
重复以上步骤

// 堆调整，以大堆为例：

void HeapAdjust(int* array, int size, int last){

int parent = size;
// 默认为左孩子
int child = parent * 2 + 1;

while (child <= last){

	// 开始比较
	if (child + 1 < last && array[child] < array[child + 1]){
		child++;
	}

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

}
}


// 堆排序：以升序为例
void Heap_sort(int* array,int size){


// 建堆
for (int i = size / 2 - 1; i >= 0; i--){
	HeapAdjust(array, size, i);
}


// 排序

for (int i = size - 1; i >= 0; i--){
	swap(&array[0], &array[i]);
	HeapAdjust(array, i, 0);
}
}