神奇的树

树：任意两个结点间有且只有一条路径的无向图。
二叉树：每个结点最多有2个子结点。
满二叉树：二叉树中的每个内部二叉树都有2个子结点，这样的二叉树叫做满二叉树。（一棵深度为h且有2^h-1个结点的二叉树。）
完全二叉树：一颗二叉树除了最右边位置上有一个或几个叶结点缺少外，其他是丰满的，那么这样的二叉树就是完全二叉树。（满二叉树是一棵完美的完全二叉树。）

    1
  2   3
4  5 6  7

将完全二叉树从上到下，从左到右进行编号，如果一个父结点的编号为k，那么它左子结点就是2*k(如果根结点序号是0的话,就是2*k+1)，右结点就是2*k+1(如果根结点序号是0的话,就是2*k+2).如果已知子结点编号是x，那么父结点编号就是x/2(商向下取整),如果一棵完全二叉树有N个结点，它的高度为log2^N,简写为logN。

1.堆

最大堆：所有的父结点都比子结点大。
最小堆：所有的父结点都比子结点小。

最小堆新增加数据后向下调整:
void siftdown(int i){
    int t, flag = 0;
    //当结点至少有左子结点，并且有需要继续调整的时候，循环就执行
    while( i * 2 <= n && flag == 0){
        //首先判断它和左子结点的关系，并用t记录值较小的结点编号
        if(h[i] > h[i * 2]){
            t = i * 2;
        }else{
            t = i;
        }
        if( i * 2 + 1 <= n){
            if(h[t] > h[i *2 + 1]){
                t = i * 2 + 1;
            }
        }
        if( t != i){
            swap(t,i);
            i = t;
        }else{
            flag = 1;
        }
    }
    return ;
}

向上调整:
void siftup(int i){
    int flag = 0;
    if(i == 1) return; //如果是堆顶，就返回
    while(i != 1 && flag == 0){
        if(h[i/2] > h[i]){
            // 父结点比子结点大
             swap(i,i/2);
        }else{
            flag = 1;
        }
        i = i / 2;
    }
    return ;
}

新建堆：从空地堆开始，依次往堆中插入每一个元素。插入第i个元素用的时间是O(logi),整体时间复杂度是O(NlogN)
n = 0;
for(i = 1; i <= m;i++){
    n++;
    h[n] = a[i]; //h[n]是最小堆
    siftup(n);
}

方法2：
for(i = n/2; i >= 1; i--){
    siftdown(i);
}

2.堆排序

堆排序的时间复杂度是O(NlogN)。
从小到大排序：建立最小堆，然后每次删除顶部元素并将顶部元素输出或者放入一个新的数组中，直到堆为空为止。

//删除最大的元素(最大堆) 删除最小的元素(最小堆)
int deletemax(){
    int t;
    t = h[1];
    h[1] = h[n]; //将堆的最后一个点赋值到堆顶
    n--;
    siftdown(1);
    return t;
}

建堆以及堆排序的完整代码如下：

#include <stdio.h>
int h[101];
int n; //堆的大小

//交换函数
void swap(int x, int y){
    int t;
    t = h[x];
    h[x] = h[y];
    h[y] = t;
    return ;
}

//向下调整函数
void siftdown(int i){
    int t, flag = 0;
    while(2 * i <= n && flag == 0){
        if(h[i] > h[2 * i]){
            t = 2 * i;      
        }else{
            t = i;
        }
        if(2 * i + 1 <= n){
            if(h[t] > h[2*i+1]){
                t = 2*i + 1;
            }
        }
        if(t != i){
            swap(h[t],h[i]);
            i = t;
        }else{
            flag = 1;
        }
    }
    return ;
}

//建堆函数
void create(){
    int i;
    for(i = n/2; i >=1; i--){
        siftdown(i);
    }
    return ;
}

//删除最大元素
int deletemax(){
    int t;
    t = h[1];
    h[1] = h[n];
    n--;
    siftdown(1);
    return t;
}

int main(){
    int i, num;
    scanf("%d", &num);

    for(i = 1; i <= num; i++){
        scanf("%d", &h[i]);
    }
    n = num;

    //建堆
    create();

    //删除顶部元素，连续删除n次，就是从小到大把数输出来
    for(i = 1; i <= num; i++){
        printf("%d ",deletemax());
    }
    getchar();
    return 0;
}

3.最大堆排序

void heapsort(){
    while(n > 1){
        swap(1,n);
        n--;
        siftdown(1);
    }
    return ;
}

4.并查集

本质是维护一个森林。刚开始时，森林的每个点都是孤立的，即每个点就是一棵只有一个结点的树，之后通过一些条件，逐渐将这些树合并成一个大树。

#include<stdio.h>
int f[1000] = {0}, n, m, k, sum = 0;
//初始化
void init(){
    int i;
    for(i = 1; i <= n; i++){
        f[i] = i;
    }
    return ;
}

//找同伴的递归函数
int getf(int v){
    if(f[v] == v){
        return v;
    }else{
        f[v] = getf(f[v]);
        return f[v];
    }
}

void merge(int v, int u){
    int t1,t2;
    t1 = get(v);
    t2 = get(u);
    if(t1 != t2){
        f[t2] = t1;
    }
    return ;
}

int main(){
    int i,x,y;
    scanf("%d %d", &n, &m);

    //初始化
    init();
    for(i = 1; i<= m;i++){
        scanf("%d %d",&x, &y);
        merge(x,y);
    }

    //扫描有多少个集合
    for(i = 1; i<= n; i++){
        if(f[i] == i){
            sum++;
        }
    }
    printf("%d\n",sum);
    getchar();
    return 0;
}