堆排序问题

堆排序

堆排序是在二叉树的概念上创建起来的一种排序方式,利用的是二叉树中的彻底二叉树;完美二叉树两种树形结构来完成堆排序

关于彻底二叉树的概念能够去查阅一些,这里不做详细说明,完美二叉树依据从上至下,从左至右的方式能够转换成一种数组存储结构,每个节点都是对应数组索引。

基本概念:

　　0.堆排序分为大顶堆,小顶堆,每个堆都是从大到小和从小到大(堆顶 > 左右 | 堆顶 < 左右)

　　1.按照0索引开始从上至下,N个节点的彻底二叉树,最后一个非叶子节点N / 2 - 1,非叶子节点的范围 = [0,N / 2 -1]

　　2.非叶子节(N)点和本身的左(L)右(R)节点的关系:L = N * 2 + 1   R = N * 2 + 2

　　3.堆排序方式:咱们从下至上查找,每次完成一个非叶子节点的堆排序,使根节点的值最大,交换根节点和最后一个节点的值

对于从最后一个非叶子节点像上进行推导:

/**
 * 咱们从最下最左的非叶子节点开始构建堆,叶子节点自己就是堆了。
 * 咱们须要构建最后一个非叶子节点的堆
 * */

public void heap(int[] arr){
    int a = arr.length/2-1; //找到最后一个非叶子节点索引
    int l = a * 2 + 1; //左子节点索引
    int r = a * 2 + 2; //右子节点索引
    int i = 0;
    if(arr[a] < arr[l] || arr[a] < arr[r]){ //咱们断定只有当它确实比其中一个小的时候咱们才进来判断
        if(arr[l] > r){
            i = arr[a];
            arr[a] = arr[l];
            arr[l] = i;
        }else if(arr[l] < arr[r]){
            i = arr[a];
            arr[a] = arr[r];
            arr[r] = i;
        }
    }
}

/**
 * 倒数第二个非叶子节点
 * */

public void heap_1(int[] arr){
    int a = arr.length/2-2; //找到倒数第二个非叶子节点索引
    int l = a * 2 + 1; //左子节点索引
    int r = a * 2 + 2; //右子节点索引
    int i = 0;
    if(arr[a] < arr[l] || arr[a] < arr[r]){ //咱们断定只有当它确实比其中一个小的时候咱们才进来判断
        if(arr[l] > r){
            i = arr[a];
            arr[a] = arr[l];
            arr[l] = i;
        }else if(arr[l] < arr[r]){
            i = arr[a];
            arr[a] = arr[r];
            arr[r] = i;
        }
    }
}

问题:当咱们改变第二个非叶子节点时,若是该节点和以前的非叶子节点有依赖关系怎么处理?
　　 若是有依赖关系说明非左即右,咱们只须要对这个非叶子节点堆发生了交换的节点进行判断是否该节点是非叶子节点,由于彻底二叉树的特性,若是是非叶子节点,那么必然是有左节点的。

　　/**
 * 对上一个代码进行完善，heap_2就是一次完整的构建大顶堆的过程
 * 解决问题:若是产生依赖关系如何处理 / 控制全部非叶子节点的遍历 / 该代码能够做为构建堆顶的使用,可是heap_2的优化不足
 * */
    public void heap_2(){
        int i = 0;
        for(int a=arr.length/2-1;a>=0;a--){ //控制非叶子节点的遍历
            int c = a;
            while(c * 2 + 1 < arr.length){  //c就是咱们本次进行堆顶节点,若是发生了交换,咱们会对交换的节点和堆顶节点进行替换
                int l = c * 2 + 1;
                int r = c * 2 + 2;
            if(arr[c] < arr[l] || arr[c] < arr[r]){
                if(arr[l] > arr[r]){
                    i = arr[c];
                    arr[c] = arr[l];
                    arr[l] = i;
                    c = l;                 //若是是l和c进行了交换
                }else if(l < r){
                    i = arr[c];
                    arr[c] = arr[r];
                    arr[r] = i;
                    c = r;　　　　　　　　//若是是r和c进行了交换
                    }
                 }
            }
        }
    }

/**
 * 优化代码
 * */

public void heap_3(){
    int i = 0;
    for(int a=arr.length/2-1;a>=0;a--){
        int c = a;
        int b  = a;
        while((c = c * 2 + 1) < arr.length){
            if(arr[c] < arr[c+1]){
               c++;
            }
            if(arr[b] < arr[c]){
                i = arr[b];
                arr[b] = arr[c];
                arr[c] = i;
                b = c;
            }
        }
    }
}

当咱们从下至上把大/小顶堆构建完成后，须要的就是不停的把堆顶和末尾进行交换,并在中间穿插对依赖的堆重构大/小堆

/**
 * 一下为对堆排序的完整版本
 * */
public void heap_4(int[] arr,int c,int length){
            int i = arr[c];
            for(int b=c*2+1;b<length;b=c*2+1){
                b = b+1<length?arr[b] < arr[b+1]? b+1 : b : b;
                if(arr[b] > i){
                   arr[c] = arr[b];
                   c = b;
                }
            }
            arr[c] = i;
        }
public void heap_5(){
    int temp = 0;
    //大顶堆的整理
    for(int a=arr.length/2-1;a>=0;a--){
        heap_4(arr,a,arr.length);
    }
    //进行交换
    for(int b=arr.length;b>0;b--){
        temp = arr[0];
        arr[0] = arr[b-1];
        arr[b-1] = temp;
　　//从上至下进行整理,由于已是大顶堆,如今只须要进行对改变的依赖节点进行大顶堆处理
        heap_4(arr,0,b-1);
    }
}