【算法知识】详解堆排序算法

点击蓝色字关注我们!

什么是堆

「堆」首先是一个完全二叉树,「堆」分为「大顶堆」「小顶堆」
「大顶堆」 :
每个节点的值大于或等于其左右孩子节点的值,称为大顶堆。
「小顶堆」同理就是每个节点的值小于或等于其左右孩子节点的值。
「注意」:
每个节点的左右孩子节点的大小关系并没有限定。

大顶堆举例

如图:

大顶堆举例

首先其为一个完全二叉树,且其每个节点的值都大于或者等于其左右孩子节点的值。
完全二叉树从上到下,从左到右依次编号,就可以将其进行顺序存储,我们从根节点开始,从0开始编号,存入数组如下:

大顶堆存入数组举例

堆特点

由大顶堆定义知道,如果我们从上到下,从左到右,根节点开始从0编号进行顺序存储的话,并将数组记为arr;
我们可以得到如下式子:
arr[i] >= arr[ 2i + 1]  && arr[ i ] >= arr[ 2i + 2];
其中 2i + 1为第 i 个节点的左孩子节点的编号。2i + 2为第 i 个节点的右孩子节点的编号;
同理得小顶堆的特点:
arr[i] <= arr[ 2i + 1]  && arr[ i ] <= arr[ 2i + 2];

堆排序基本思想

本文以大顶堆为例,进行讲解。
算法步骤如下:
1、首先将待排序序列构建成一个大顶堆(存入数组中),那么这时,整个序列的最大值就是堆顶的根节点;
2、将堆顶元素与最后一个元素交换,那么末尾元素就存入了最大值;
3、将剩余的 n - 1个元素重新构建成一个大顶堆,重复上面的操作;
反复执行,就能得到一个有序序列了。

举例

给定一个待排序序列数组 arr = [ 0 , 2,  4,  1 , 5 ];
先构建成一个完全二叉树如下;

初始状态

构建堆

「我们从最后一个非叶子节点开始,从左至右,从下到上,开始调整」
最后一个非叶子节点的索引即 arr.length / 2向下取整 - 1 ,对于此例就是 5 / 2向下取整 - 1 = 2 - 1 = 1;
即值为2的节点;

构建堆1

我们用左右孩子节点的最大值与该节点进行比较;
此时我们发现它的左右孩子节点的最大值为5,大于2,进行交换;

构建堆2

然后处理下一个非叶子节点,即刚才的索引减去1;1 - 1 = 0;
即:

构建堆3

左右孩子节点为5和4,5最大,且大于该节点的值,发生交换;

构建堆4

这时我们发现了一个问题:
「值为0的节点的左右节点又比该节点大了,又不满足大顶堆的定义了」

继续进行调整:

构建堆5

对非叶子节点调整完毕,构建大顶堆完成。

交换

将堆顶元素与末尾元素进行交换,使得末尾元素最大。

堆顶元素与末尾元素交换

当交换完毕后最大的元素已经到达数组末尾;

第一次交换后

对数组中其他元素进行排序即可。

剩下的四个元素进行调整

进行交换:

第二大元素归位

剩下的元素调整并交换后:

第三大元素归位

剩下的元素调整并交换后:

第三大元素归位
第四大元素归位置

此时也意味着排序完成了。

代码

先说下调整的代码;
我们需要三个参数,待排序的数组,数组的长度,还有一个就是调整的哪一个非叶子节点;

 /**
     * author:微信公众号:code随笔
     * @param arr 待排序的数组
     * @param i   表示等待调整的哪个非叶子节点的索引
     * @param length 待调整长度
     */
    public static void adjustHeap(int arr[],int i,int length){
        //非叶子节点的值
        int notLeafNodeVal = arr[i];
        //k的初始值为当前非叶子节点的左孩子节点的索引
        //k = 2 * k + 1表示再往左子节点找
        for(int k = i * 2 + 1;k<length;k=2 *k + 1){
            //如果k + 1还在待调整的长度内,且右子树的值大于等于左子树的值
            //将k++,此时为当前节点的右孩子节点的索引
            if(k+1<length && arr[k] < arr[k+1]){
                k++;
            }
            //如果孩子节点大于当前非叶子节点
            if(arr[k] > notLeafNodeVal){
                arr[i] = arr[k];//将当前节点赋值为孩子节点的值
                i = k;//将i赋值为孩子节点的值,再看其孩子节点是否有比它大的
            }else{
                break;//能够break的保证是,我们是从左至右,从下到上进行调整的
                //只要上面的不大于,下面的必不大于
            }
        }
        //循环结束后,将i索引处的节点赋值为之前存的那个非叶子节点的值
        arr[i] = notLeafNodeVal;
    }

再说下堆排序代码,看好注释;

//堆排序方法
    public static void heapSort(int arr[]){
        //进行第一次调整
        for(int i=arr.length/2 - 1;i>=0;i--){
            adjustHeap(arr,i,arr.length);
        }

        for(int j=arr.length - 1;j>0;j--){
            //进行交换
            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            //调整长度为j的那些
            //这里为什么填0呢
            //因为我们第一次调整的时候从左到右,从下到上调整的;
            //交换时只是变动了堆顶元素和末尾元素
            //末尾元素我们不用去管,因为已经是之前长度最大的了
            //只需要把当前堆顶元素找到合适的位置即可
            adjustHeap(arr,0,j);
        }
    }

完整代码

import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {

        int [] arr = new int[]{0 , 2,  4,  1 , 5};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));

    }
    //堆排序方法
    public static void heapSort(int arr[]){
        //进行第一次调整
        for(int i=arr.length/2 - 1;i>=0;i--){
            adjustHeap(arr,i,arr.length);
        }

        for(int j=arr.length - 1;j>0;j--){
            //进行交换
            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            //调整长度为j的那些
            //这里为什么填0呢
            //因为我们第一次调整的时候从左到右,从下到上调整的;
            //交换时只是变动了堆顶元素和末尾元素
            //末尾元素我们不用去管,因为已经是之前长度最大的了
            //只需要把当前堆顶元素找到合适的位置即可
            adjustHeap(arr,0,j);
        }
    }
    /**
     * author:微信公众号:code随笔
     * @param arr 待排序的数组
     * @param i   表示等待调整的哪个非叶子节点的索引
     * @param length 待调整长度
     */
    public static void adjustHeap(int arr[],int i,int length){
        //非叶子节点的值
        int notLeafNodeVal = arr[i];
        //k的初始值为当前非叶子节点的左孩子节点的索引
        //k = 2 * k + 1表示再往左子节点找
        for(int k = i * 2 + 1;k<length;k=2 *k + 1){
            //如果k + 1还在待调整的长度内,且右子树的值大于等于左子树的值
            //将k++,此时为当前节点的右孩子节点的索引
            if(k+1<length && arr[k] < arr[k+1]){
                k++;
            }
            //如果孩子节点大于当前非叶子节点
            if(arr[k] > notLeafNodeVal){
                arr[i] = arr[k];//将当前节点赋值为孩子节点的值
                i = k;//将i赋值为孩子节点的值,再看其孩子节点是否有比它大的
            }else{
                break;//能够break的保证是,我们是从左至右,从下到上进行调整的
                //只要上面的不大于,下面的必不大于
            }
        }
        //循环结束后,将i索引处的节点赋值为之前存的那个非叶子节点的值
        arr[i] = notLeafNodeVal;
    }
}

时间复杂度

在建初始堆时,其复杂度为;
交换操作需 n-1 次;
重建堆的过程中近似为
堆排序时间复杂度为

稳定性

堆排序是不稳定的:
比如:10,9,6,9;如图:

稳定性分析用图

当堆顶元素10和末尾元素交换后,两个9的相对位置发生改变。

已发布:

【算法知识】详解冒泡算法

【算法知识】详解选择排序算法

【算法知识】详解插入排序算法

【算法知识】详解快速排序算法

【算法知识】详解基数排序算法

往期精彩回顾




适合初学者入门人工智能的路线及资料下载机器学习及深度学习笔记等资料打印机器学习在线手册深度学习笔记专辑AI基础下载(pdf更新到25集)机器学习的数学基础专辑本站qq群1003271085,加入微信群请回复“加群”获取一折本站知识星球优惠券,复制链接直接打开:https://t.zsxq.com/yFQV7am喜欢文章,点个在看
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读