堆排序问题

Posted 2020-11-22 gongzhichang

堆排序

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

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

基本概念:

　　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);
    }
}