第6章 堆排序，d叉堆，优先队列

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define leftChild(i) (2*(i)+1)
//交换
void swap(int *a, int i, int j)
{
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}
//堆下溯
void maxHeapify(int *a, int i, int n)
{
    int child, tmp;
    for (tmp = a[i]; leftChild(i)<n; i = child){
        child = leftChild(i);
        if (child != n -  && a[child] < a[child + ]) ++child;
        if (tmp < a[child]) a[i] = a[child];
        else break;
    }
    a[i] = tmp;
}
//建立最大堆
void buildMaxHeap(int *a, int n)
{
    for (int i = n / ; i >= ; --i)
        maxHeapify(a, i, n);
}
//堆排序
void heapSort(int *a, int n)
{
    for (int i = n / ; i >= ; --i)
        maxHeapify(a, i, n);
    for (int i = n - ; i > ; --i){
        swap(a, , i);
        maxHeapify(a, , i);
    }
}
typedef struct _stack{
    int *arr;
    int pos;
}stack;
//创建一个空的优先队列
stack create(int capacity)
{
    stack s;
    s.pos = -;
    s.arr = (int*)malloc(capacity*sizeof(int));
    memset(s.arr, , capacity*sizeof(int));
    return s;
}
//返回优先队列最大元素
int maxOfStack(stack &s)
{
    return s.arr[];
}
//返回最大元素并删除
int extractMax(stack &s)
{
    swap(s.arr,,s.pos);
    --s.pos;
    return s.arr[s.pos + ];
}
//增大指定元素到key
void increaseKey(stack &s, int i, int key)
{
    if (i > s.pos) return;
    if (key < s.arr[i]) return;
    s.arr[i] = key;
    while (i >  && s.arr[i] > s.arr[(i - ) / ]){
        swap(s.arr, i, (i - ) / );
        i = (i - ) / ;
    }
}
//插入元素
void insert(stack &s, int val)
{
    ++s.pos;
    s.arr[s.pos] = val;
    increaseKey(s, s.pos, val);
}

//思考题6.2，d叉堆
void increaseKeyD(int *a, int i, int key,int d)
{
    if (a[i] > key) return;
    a[i] = key;
    while (i >  && a[i] > a[(i - ) / d]){
        swap(a, i, (i - ) / d);
        i = (i - ) / d;
    }
}

//思考题6.3，young氏矩阵
void maxHeapYoung(int *a, int i, int j, int m, int n)
{
    int tmp, x, y;
    while (tmp = a[i*n + j]){
        x = i; y = j;
        if (x < m -  && y < n - ){
            if (a[x*n + y + ] > a[(x + )*n + y]) ++x;
            else ++y;
        }
        else if (x < m - ) ++x;
        else if (y < n - ) ++y;
        else break;
        if (tmp > a[x*n + y]) a[i*n + j] = a[x*n + y];
        else break;
        i = x; j = y;
        a[i*n + j] = tmp;
    }
}
int main()
{
    int a[] = { , , , ,-,-,, , , ,  };
    stack s = create();
    for (int i = ; i < ; ++i)
        insert(s, a[i]);
    for (int i = ; i <= s.pos; ++i)
        printf("%d\t", s.arr[i]);
    printf("\n");
    int b[] = { , , , , , , , ,  };
    maxHeapYoung(b, , , , );
    for (int i = ; i < ; ++i)
        printf("%d\t", b[i]);
    printf("\n");
}

堆：stack

队列：queue

优先队列：priority_queue

　　for all

size_type

value_type

container_type

A a;

A a(c);

关系运算　　==　　!=　　<　　<=　　>　　>=

a.empty();

a.size();

swap(a,b);

a.swap(b);

　　for stack

stack<int>,默认基于deque实现；可以指定为list/vector，stack<int,vector<int>>

s.pop();　　删除

s.push(item);　　入栈

s.emplace(args);　　入栈

s.top();　　返回

　　for queue

queue<int>,默认基于deque,可指定list/vector,queue<int,vector<int>>

q.front();

q.back();

q.push(item);

q.emplace(args);

q.pop();

　　for priority_queue

prioriry_queue<int>默认基于vector，less<int>,可指定deque,greater<int>,priority_queue<int,deque<int>,greater<int>>

pq.top();

pq.push(item);

pq.emplace(args);

pq.pop();