堆的建立&堆排序

2017 / 3 / 31
很久没写博客了 最近除了上课 睡觉 吃饭 其他时间几乎都待在图书馆里飙车 其实也谈不上什么飙车 就是一个跌破低谷的咸鱼在努力尝试着翻身
今天和朋友看了场电影 终于克服掉进电影院的阴影 可能害怕看到一对对情侣想到以前的我们 因为和你待在一起最久地方除了家就是电影院
曲终人散 人走茶凉 我就不要想起你 撒油啦啦
渍渍渍 在这车手如云的论坛上竟然写起了随笔 好尴尬 勿喷
接下来我们说正题 这次介绍数据结构中简单的二叉堆。

堆的建立

二叉堆是一种特殊的堆，二叉堆是完全二元树或者是近似完全二元树。
二叉堆有两种：最大堆和最小堆。
最大堆：父结点的键值总是大于或等于任何一个子节点的键值；
最小堆：父结点的键值总是小于或等于任何一个子节点的键值。
堆一般用数组存放：根节点为1节点，i节点的左子节点为2*i，右子节点为2*i+1。
插入：因为从根节点到叶节点是一个有序序列。将新插入的节点放到最后然后将其放到这个有序序列。
删除：删除某一个节点， 将最后一个节点填充到删除的节点处，然后将此节点看做成根节点构造一个堆。

多BB一句 这里让数组下标从1开始比从0开始方便些 比如1的左右儿子分别就是1*2和1*2+1

#include <iostream>
#include <malloc.h>
#define MAXSIZE 100
#define ElemType int
using namespace std;

typedef struct Heap{
int capacity;
int size;
ElemType elements[MAXSIZE + 1];
}Heap;

void CreatHeap(Heap *&H)
{
H = (Heap *) malloc (sizeof(Heap));
H->capacity = MAXSIZE;
H->size = 0;
}

bool IsFull(Heap *H)
{
if(H->size == H->capacity) return true;
return false;
}

void Insert(Heap *&H, ElemType x)
{
if(IsFull(H)){
cout<<"Heap is full"<<endl;
return;
}
for(int i = ++H->size; H->elements[i / 2] > x; i /= 2)
H->elements[i] = H->elements[i / 2];
H->elements[i] = x;
}

bool IsEmpty(Heap *H)
{
if(H->size) return false;
return true;
}

ElemType DeleteMin(Heap *&H)
{
if(IsEmpty(H)){
cout<<"The heap is empty"<<endl;
exit(-1);
}
int i, child, MinElement, LastElement;
MinElement = H->elements[1];
LastElement = H->elements[H->size--];
for(i = 1; 2 * i <= H->size; i = child){
child = 2 * i;
if(H->elements[child] > H->elements[child + 1])
++child;
if(LastElement > H->elements[child])
H->elements[i] = H->elements[child];
else break;
}
H->elements[i] = LastElement;
return MinElement;
}

int main()
{
int i, x;
Heap *h;
CreatHeap(h);
for(i = 1; i <= 10; i++){
cin>>x;
Insert(h, x);
}
cout<<"Heap is: ";
for(i = 1; i <= h->size; i++)
cout<<h->elements[i]<<' ';
cout<<endl;
cout<<"Now insert an element"<<endl;
cin>>x;
Insert(h, x);
for(i = 1; i <= h->size; i++)
cout<<h->elements[i]<<' ';
cout<<endl;
cout<<"Delete min element: "<<DeleteMin(h)<<endl;
for(i = 1; i <= h->size; i++)
cout<<h->elements[i]<<' ';
cout<<endl;
return 0;
}

堆排序

堆的排序：因为堆的根节点是最小堆值，所以每次取根节点，然后将其删除，剩余的节点重新构造成堆以此递归完成排序。
使用最小堆得到递增序列，最大堆得到递减序列。
二次操作时间相加还是O(N * logN)。故堆排序的时间复杂度为O(N * logN)。

#include <iostream>
#define MAXSIZE 100
using namespace std;

void swap(int *a, int *b)
{
int t;
t = *a; *a = *b; *b = t;
}

void HeapAdjust(int a[], int i, int n)
{
int child, tmp;
for(tmp = a[i]; 2 * i <= n; i = child){
child = 2 * i;
if(a[child] < a[child + 1])
++child;
if(child <= n &&a[child] > tmp)
a[i] = a[child];
else break;
}
a[i] = tmp;
}

void HeapSort(int a[], int n)
{
int i;
for(i = n / 2; i > 0; i--)      //Build heap
HeapAdjust(a, i, n);
for(i = n - 1; i > 0; i--){     //Sort
swap(&a[1], &a[i + 1]);     //这里切记是a[i + 1] 数组中下标是从1到n的 0号位置相当于废了Orz
HeapAdjust(a, 1, i);
}
}

int main()
{
int i, n, a[MAXSIZE];
cin>>n;
for(i = 1; i <= n; i++)
cin>>a[i];
cout<<"Before: ";
for(i = 1; i <= n; i++)
cout<<a[i]<<' ';

9c7f
cout<<endl;
HeapSort(a, n);
cout<<"After: ";
for(i = 1; i <= n; i++)
cout<<a[i]<<' ';
cout<<endl;
return 0;
}