最小优先级队列 — 使用最小堆实现
最小优先级支持的操作：
1.INSERT(S,x)：将元素x插入队列S
2.MINIMUM(S)：返回S中最小的元素
3.EXTRACT_MIN(S)：去掉并返回S中最小的元素
4.DECREASE_KEY(S,x,key)：将下标为x的元素值降低为key
使用最小堆实现最小优先级队列。最小堆是一个完全二叉树，从编号1开始：
注意几个操作：向下调整（建堆、调整堆），向上调整（建堆后，插入元素、更改元素）、heap_size的应用和变化
//最小优先级队列
#include<stdio.h>
#include<stdlib.h>
int heap_size = 0;
int parent(int i){
return i/2;
}
int left_child(int i){
return 2*i;
}
int right_child(int i){
return 2*i+1;
}
void swap(int * a, int * b){
int c = *a;
*a = *b;
*b = c;
}
void heap_adjust(int *arr, int i){
int min = i;
int left = left_child(i);
int right = right_child(i);
if(left<=heap_size && arr[left] < arr[min]){
min = left;
}
if(right<=heap_size && arr[right] < arr[min]){
min = right;
}
if(min != i){
swap(&arr[i],&arr[min]);
heap_adjust(arr,min);
}
}
void heap_create(int * arr, int num){
if(NULL == arr){
return;
}
int i = 0;
heap_size = num;
for(i=num/2; i>=1; i--){
heap_adjust(arr,i);
}
}
void heap_sort(int * arr){
while(heap_size > 1){
swap(&arr[1],&arr[heap_size]);
heap_size --;
heap_adjust(arr,1);
}
}
//将元素x插入队列
void insert(int * arr, int x){
heap_size++;
arr[heap_size] = x;
int i=0;
for(i=heap_size/2; i>=1; i--){
heap_adjust(arr,i);
}
}
//返回队列中最小的元素
int minimum(int * arr){
return arr[1];
}
//去掉并返回队列中最小的元素
int extract_min(int *arr){
int min = arr[1];
arr[1] = arr[heap_size];
heap_size--;
heap_adjust(arr,1);
return min;
}
//将下标为x的元素值降低为key
void decrease_key(int * arr, int x, int key){
if(x >=1 && x<=heap_size){
arr[x] = key;
while(parent(x) >= 1 && arr[parent(x)] > arr[x]){
swap(&arr[parent(x)],&arr[x]);
x = parent(x);
}
}
}
//借助上函数实现插入元素x到队列
void insert2(int * arr, int x){
heap_size++;
arr[heap_size] = x;
decrease_key(arr,heap_size,x);
}
int main(){
int i,n;
int arr[100];
scanf("%d",&n);
for(i=1; i<=n; i++){
scanf("%d",&arr[i]);
}
heap_create(arr,n);
//heap_sort(arr);
//printf("%d\n",minimum(arr));
//printf("%d\n",extract_min(arr));
//insert(arr,1);
//decrease_key(arr,3,1);
insert2(arr,19);
for(i=1; i<=heap_size; i++){
printf("%d ",arr[i]);
}
system("pause");
return 0;
}