堆排序算法

已于 2023-07-06 11:08:52 修改
阅读量703 收藏 4
点赞数
分类专栏： 前端算法 文章标签： 排序算法 算法 数据结构
于 2022-03-09 15:22:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43294560/article/details/123376625
版权

文章目录

前置知识

  • 完全二叉树：深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h 层所有的结点都连续集中在最左边（即从最左边开始排列），从上到下，从左到右，节点序号和节点个数一一对应

在这里插入图片描述

  • 满二叉树：除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树

    • 故满二叉树一定是完全二叉树，但完全二叉树不一定是满二叉树
      在这里插入图片描述

完全二叉树的特性

  • 完全二叉树可以用数组进行存储
    • 如果我们把根节点存放在位置 i=1 的位置，则它的左子节点位置为 2i = 2 ，右子节点位置为 2i+1 = 3 。
    • 如果我们选取 B 节点 i=2 ，则它父节点为 i/2 = 1 ，左子节点 2i=4 ，右子节点 2i+1=5 。
  • 所有的节点都满足这三种关系
    • 位置为 i 的节点，它的父节点位置为 i/2
    • 它的左子节点 2i
    • 它的右子节点 2i+1
  • 下面的完全二叉树用数组表示为，[1,9,2,8,3,7,4,6,5]

在这里插入图片描述

堆

  • 堆是一个完全二叉树，分为大顶堆和小顶堆

  • 大顶堆：堆上的任意节点值都必须大于等于其左右子节点值

    • 故大顶堆的堆顶一定是最大的数
      在这里插入图片描述

  • 小顶堆：堆上的任意节点值都必须小于等于其左右子节点值

    • 故小顶堆的堆顶一定是最小的数
      在这里插入图片描述

建堆

  • 如上所知，堆是个完全二叉树，那么堆其实可以用一个数组表示，给定一个节点的下标 i （i从1开始） ，那么它的父节点一定为 A[i/2] ，左子节点为 A[2i] ，右子节点为 A[2i+1]

插入式建堆：这里以大顶堆为例

  • 将节点插入到队尾
  • 自下往上堆化： 将插入节点与其父节点比较，如果插入节点大于父节点（大顶堆）或插入节点小于父节点（小顶堆），则插入节点与父节点调整位置
  • 一直重复上一步，直到不需要交换或交换到根节点，此时插入完成。
  • 时间复杂度为O(nlogn)
    在这里插入图片描述
class MaxHeap {
  constructor() {
    // 初始化时将位置 0 留空，方便计算子节点和父节点的索引关系
    this.heap = [null];
  }

  insert(value) {
    this.heap.push(value);
    let currentIndex = this.heap.length - 1;

    while (currentIndex > 1 && this.heap[Math.floor(currentIndex / 2)] < this.heap[currentIndex]) {
      [this.heap[currentIndex], this.heap[Math.floor(currentIndex / 2)]] = [this.heap[Math.floor(currentIndex / 2)], this.heap[currentIndex]];
      currentIndex = Math.floor(currentIndex / 2);
    }
  }
}

方式二：

let arr = [];

function heapInsert(num) {
  arr.push(num);
  let insertIndex = arr.length - 1;
  while (num > arr[Math.floor((insertIndex - 1) / 2)]) {
    //和(i-1)/2父节点交换位置
    [arr[insertIndex], arr[Math.floor((insertIndex - 1) / 2)]] = [
      arr[Math.floor((insertIndex - 1) / 2)],
      arr[insertIndex],
    ];
    insertIndex = Math.floor((insertIndex - 1) / 2);
  }
}

heapInsert(6);
heapInsert(5);
heapInsert(4);
heapInsert(1);
heapInsert(3);
heapInsert(2);
heapInsert(8);

console.log(arr) //8 5 6 1 3 2 4

原地建堆（堆化）：这里以小顶堆为例

  • 自下而上式堆化 ：将节点与其父节点比较，如果节点大于父节点（大顶堆）或节点小于父节点（小顶堆），则节点与父节点调整位置
    • 从第一个元素开始，每遍历一个元素，就和它的父元素进行比较交换，类似插入式建堆的做法
      在这里插入图片描述
//原地建堆
function buildHeap(items, heapSize) {
    while(heapSize < items.length-1) {
        heapSize ++
        heapify(items, heapSize)
    }
}

function heapify(items, i) {
    // 自下而上式堆化
    当前元素索引取 Math.ceil(i/2)-1是因为，1和2的父元素索引都是0;
    while (i/2 > 0 && items[i] <items[Math.ceil(i/2)-1]) {  
        swap(items, i, Math.ceil(i/2)-1); // 交换 
        i = Math.ceil(i/2)-1; 
    }
}  

function swap(items, i, j) {
    let temp = items[i]
    items[i] = items[j]
    items[j] = temp
}

// 测试
var items2 = [5,2,3,4,1]
buildHeap(items2, 0)
console.log(items2) // 1 2 3 5 4
  • 自上往下式堆化 ：从最后一个非叶子结点开始与其左右子节点比较，如果存在左右子节点大于该节点（大顶堆）或小于该节点（小顶堆），则将子节点的最大值（大顶堆）或最小值（小顶堆）与之交换
    • 每交换一次，还要继续比较交换后节点与其子左右节点的大小，因为不能保证上一部交换的节点是以当前节点为根的树中最大或最小的
    • 需要从最后一个非叶子节点开始，而非最后一个节点，因为完全二叉树的原因，最后一个非叶子结点就包含了最后两个或一个节点，从而能保证最后一个非叶子结点交换后是有序的（即是以当前节点为根的树，根为最大或最小），然后从最后一个非叶子结点的序号-1的节点开始遍历交换直到序号为0，因为完全二叉树的结构，从最后一个非叶子结点开始，令其序号不断-1，就能从整个树的左右子树的左右两边最底层开始不断往上提升，最终比较整个树的根节点和其两个子节点
    • 最后一个非叶子节点公式：（n-1）/2
    • 时间复杂度为O(n)，比插入式建堆复杂度要低
// 原地建堆
// items: 原始序列
function buildHeap(items) {
    let heapSize = items.length
    // 从最后一个非叶子节点开始，然后遍历到序号为0的节点为止，使得完全二叉树能从左右两个子树的最底层开始往上整合，直到根节点
    // 因为最后一排的节点不需要堆化
    for (let i = Math.floor(heapSize/2); i >= 1; --i) {    
        heapify(items, heapSize, i);  
    }
}
//可以根据最后面的heapify，根据索引进行节点比较优化
function heapify(items, heapSize, i) {
    // 当前节点比较交换后，还要继续比较交换后节点和其子左右节点大小，以保证当前节点的子树都满足大顶堆或小顶堆的结构
    while (true) {
        var maxIndex = i;
        if(2*i <= heapSize && items[i] > items[i*2] ) {
            maxIndex = i*2;
        }
        if(2*i+1 <= heapSize && items[maxIndex] > items[i*2+1] ) {
            maxIndex = i*2+1;
        }
        if (maxIndex === i) break;
        swap(items, i, maxIndex); // 交换 
        i = maxIndex; 
    }
}  
function swap(items, i, j) {
    let temp = items[i]
    items[i] = items[j]
    items[j] = temp
}

// 测试
var items = [,5, 2, 3, 4, 1]
buildHeap(items, items.length - 1)
console.log(items)
// [empty, 1, 2, 3, 4, 5]

二叉堆新增节点（小顶堆为例）

  • 将新元素插入到数组末尾
  • 新增节点和上面的插入建堆原理一致，不断向上与父节点比较
  • 时间复杂度为O(logN),和树的高度有关
    在这里插入图片描述
    在这里插入图片描述

二叉堆提取或删除节点（小顶堆为例）

  • 提取后重新放置的节点，和最小的子节点相比是因为最小子节点若交换到父节点，较小的节点一定比较大的节点小，不用再考虑较小节点是否还需要交换位置，否则若交换较大的节点，较大的节点还需要和较小的节点交换位置再进行排序
  • 时间复杂度为O(logN)，和树的高度有关

在这里插入图片描述
在这里插入图片描述
大顶堆删除节点

class MaxHeap {
  constructor() {
    // 初始化时将位置 0 留空，方便计算子节点和父节点的索引关系
    this.heap = [null];
  }

  insert(value) {
    this.heap.push(value);
    let currentIndex = this.heap.length - 1;

    while (currentIndex > 1 && this.heap[Math.floor(currentIndex / 2)] < this.heap[currentIndex]) {
      [this.heap[currentIndex], this.heap[Math.floor(currentIndex / 2)]] = [this.heap[Math.floor(currentIndex / 2)], this.heap[currentIndex]];
      currentIndex = Math.floor(currentIndex / 2);
    }
  }

  remove() {
    if (this.heap.length === 1) return null;

    let maxValue = this.heap[1];

    this.heap[1] = this.heap.pop();
    let currentIndex = 1;

    while (true) {
      let leftChildIndex = currentIndex * 2;
      let rightChildIndex = currentIndex * 2 + 1;
      let swapIndex = null;

      if (leftChildIndex < this.heap.length && this.heap[leftChildIndex] > this.heap[currentIndex]) {
        swapIndex = leftChildIndex;
      }

      if (
        rightChildIndex < this.heap.length &&
        this.heap[rightChildIndex] > this.heap[currentIndex] &&
        this.heap[rightChildIndex] > this.heap[leftChildIndex]
      ) {
        swapIndex = rightChildIndex;
      }

      if (!swapIndex) break;

      [this.heap[currentIndex], this.heap[swapIndex]] = [this.heap[swapIndex], this.heap[currentIndex]];
      currentIndex = swapIndex;
    }

    return maxValue;
  }
}

//大顶堆删除提取第一个节点
//这里实现的是能在任何一个位置开始堆化（前提是除了待改动的节点，已经堆化了）
function heapify(arr, index) {
  let heapSize = arr.length;
  //左子节点
  let left = index * 2 + 1;
  //当还存在子节点时，left可以理解为子节点的第一个
  while (left < heapSize) {
    //获取两个子节点最大的那个索引，left + 1 < heapSize表示如果越界了，表面left是最后一个子节点，取left
    let largest =
      left + 1 < heapSize && arr[left] < arr[left + 1] ? left + 1 : left;
    //待比较节点和子节点最大值比较
    largest = arr[index] >= arr[largest] ? index : largest;
    //子节点为最大值，退出
    if (largest == index) {
      break;
    }
    //交换最大值，最大值往上
    [arr[index], arr[largest]] = [arr[largest], arr[index]];
    index = largest;
    left = index * 2 + 1;
  }
}

let arr = [8, 5, 6, 1, 3, 2, 4];
let max = arr[0];
arr[0] = arr.pop();
heapify(arr, 0);

console.log(arr); //[ 6, 5, 4, 1, 3, 2 ]

堆排序

  • 如上通过大顶堆和小顶堆知道，当前堆的根节点一定是整个树的最大或最小的值
  • 将根结点位置和最后一个节点位置交换，即对应数组中，将根结点和数组尾元素交换位置，然后每次将数组长度-1，让数组剩余元素再进行堆化，反复执行该操作，最终达成整个数组有序
  • 可知，整个建堆过程和堆排序，都可以看做一个选择排序，整体时间复杂度是 O(nlogn)
class MaxHeap {
  constructor() {
    // 初始化时将位置 0 留空，方便计算子节点和父节点的索引关系
    this.heap = [null];
  }

  insert(value) {
    this.heap.push(value);
    let currentIndex = this.heap.length - 1;

    while (currentIndex > 1 && this.heap[Math.floor(currentIndex / 2)] < this.heap[currentIndex]) {
      [this.heap[currentIndex], this.heap[Math.floor(currentIndex / 2)]] = [this.heap[Math.floor(currentIndex / 2)], this.heap[currentIndex]];
      currentIndex = Math.floor(currentIndex / 2);
    }
  }

  remove() {
    if (this.heap.length === 1) return null;

    let maxValue = this.heap[1];

    this.heap[1] = this.heap.pop();
    let currentIndex = 1;

    while (true) {
      let leftChildIndex = currentIndex * 2;
      let rightChildIndex = currentIndex * 2 + 1;
      let swapIndex = null;

      if (leftChildIndex < this.heap.length && this.heap[leftChildIndex] > this.heap[currentIndex]) {
        swapIndex = leftChildIndex;
      }

      if (
        rightChildIndex < this.heap.length &&
        this.heap[rightChildIndex] > this.heap[currentIndex] &&
        this.heap[rightChildIndex] > this.heap[leftChildIndex]
      ) {
        swapIndex = rightChildIndex;
      }

      if (!swapIndex) break;

      [this.heap[currentIndex], this.heap[swapIndex]] = [this.heap[swapIndex], this.heap[currentIndex]];
      currentIndex = swapIndex;
    }

    return maxValue;
  }
}

// 堆排序
function heapSort(arr) {
  const maxHeap = new MaxHeap();

  for (const value of arr) {
    maxHeap.insert(value);
  }

  for (let i = arr.length - 1; i >= 0; i--) {
    arr[i] = maxHeap.remove();
  }
}

const arr = [4, 2, 6, 3, 7, 9, 0];
heapSort(arr);
console.log(arr); // 输出：[0, 2, 3, 4, 6, 7, 9]

let arr = [8, 5, 6, 1, 3, 2, 4];
//开辟新数组
function heapSort(arr) {
  let order = [];
  while (arr.length) {
    order.push(arr[0]);
    if (arr.length == 1) {
      break;
    }
    arr[0] = arr.pop();

    heapify(arr, 0);
  }

  return order;
}

console.log(heapSort(arr)); //[8, 6, 5, 4, 3, 2, 1];

//原数组，空间复杂度为O(1)
function heapSort(arr，heapSize) {
  [arr[0],arr[heapSize-1]]=[arr[heapSize-1],arr[0]];
  heapSize--;
  while(heapSzie>0){
    //这里的heapify应该根据heapSize的长度建堆，上面的heapSize未实现
  	heapify(arr, 0, heapSize);
  	[arr[0],arr[heapSize-1]]=[arr[heapSize-1],arr[0]];
  	heapSize--;
  }
}
heapSort(arr,arr.length);
console.log(heapSort(arr)); //[8, 6, 5, 4, 3, 2, 1];

改变堆中某个节点的值后，依旧成堆

  • 大顶堆
    • 如果改变后的节点比原来的节点大，则向上和父节点交换比较（heapInsert过程）
    • 如果改变后的节点比原来的节点小，则向下和子节点比较（heapify过程）
    • 时间复杂度为O(logN)
神奇大叔
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
堆排序算法详解
Gandoph的博客
10-14 3万+
一、堆排序算法原理和动态图解        将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。将它移走(其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次最大值。如此反复执行，就能得到一个有序序列了。这个过程其实就是先构建一个最大/最小二叉堆，然后不停的取出最大/最小元素（头结点），插入到新的队...
堆排序算法（图解详细流程）
热门推荐
阿顾的博客
08-04 23万+
堆排序的时间复杂度O(N*logN),额外空间复杂度O(1)，是一个不稳定性的排序 目录 一 准备知识 1.1 大根堆和小根堆 二 堆排序基本步骤 2.1 构造堆 2.2固定最大值再构造堆 三 总结 四代码 一 准备知识 堆的结构可以分为大根堆和小根堆，是一个完全二叉树，而堆排序是根据堆的这种数据结构设计的一种排序，下面先来看看什么是大根堆和小根堆 1.1 大根...
解读堆排序算法及用C++实现基于最大堆的堆排序示例
12-25
1、堆排序定义 n个关键字序列Kl，K2，…，Kn称为堆，当且仅当该序列满足如下性质(简称为堆性质)： (1) ki≤K2i且ki≤K2i+1 或(2)Ki≥K2i且ki≥K2i+1(1≤i≤ ) 若将此序列所存储的向量R[1..n]看做是...堆排序算法 2、
排序算法之堆排序算法：用C++语言实现堆排序算法
05-22
标题"排序算法之堆排序算法：用C++语言实现堆排序算法"，意味着我们将讨论如何用C++编程语言来实现堆排序的过程。C++是面向对象的编程语言，具有丰富的库支持和高效的执行性能，是实现算法的理想选择。 描述"排序...
应用Java和Python分别实现堆排序算法
最新发布
06-20
堆排序：应用Java和Python分别实现堆排序算法； 堆排序：应用Java和Python分别实现堆排序算法； 堆排序：应用Java和Python分别实现堆排序算法； 堆排序：应用Java和Python分别实现堆排序算法； 堆排序：应用Java和...
洗牌乱序算法
weixin_43294560的博客
01-09 3384
洗牌算法(Fisher-Yates),简单的思路如下： 定义一个数组，以数组的最后一个元素为基准点。 在数组开始位置到基准点之间随机取一个位置，将所取位置上的元素和基准点上的元素互换。 基准点左移一位。 重复2，3步骤，直到基准点为数组的开始位置。 Math.random: 产生一个[0，1)之间的数 underscore在原生的Math.random()方法上，重新包装了random函数，实现在给定范围内生成随机整数，如果只传递一个参数，那么将返回0和这个参数之间的整数 // 随机
无向图 遍历
weixin_43294560的博客
07-19 1525
【代码】无向图 遍历。
LRU 缓存结构
weixin_43294560的博客
07-27 1265
【代码】LRU 缓存结构。
归并排序算法
weixin_43294560的博客
12-01 565
采用分治法的一个非常典型的应用。 将已有序的子序列合并,得到完全有序的序列；即先使每个子序列有序,再使子序列段间有序。 1、归并操作，指的是将两个顺序序列合并成一个顺序序列的方法。 如：数组 {6，202，100，301，38，8，1} 初始状态：6,202,100,301,38,8,1 第一次归并后：{6,202},{100,301},{8,38},{1}； 两个子序列进行比较,两个指针分别指向每个子序列第一位,小的放在前面,然后对应指针+1 当某个指针超过当前序列的长度后,因为都是有序
时间复杂度和空间复杂度
weixin_43294560的博客
11-24 516
时间复杂度 1、简化方法: O(常数):O(1) O(an+b):O(n) O(n^m+n^n+...): 假设m最大,则为O(n^m) 2、常见时间复杂度例子 O(1): function foo(){ let n = 1 let b = n * 100 if(b === 100){ console.log("开始吃糖") } console.log("我吃了1颗糖") console.log(
通过对象轮换实现 LRU 缓存结构
weixin_43294560的博客
12-15 453
通过对象轮换实现 LRU 缓存结构。
图的数据结构
weixin_43294560的博客
08-24 417
图的数据结构。
位图数组 布隆过滤器
weixin_43294560的博客
02-22 354
一个int类型的整数用4字节,也就是32个bit位来表示，将整数类型的数组转换成位图数组，那么存储长度将变为原来的32倍。场景：要存储100亿个黑名单url，并且给定一个url要判断是否在黑名单内。
尾递归优化
weixin_43294560的博客
06-30 341
栈帧（Stack Frame）是一个用于保存函数调用时所需的所有信息的数据结构。在函数调用过程中，每次调用会为其生成一个新的栈帧，通常存储在调用堆栈（Call Stack）中。每个栈帧包含了有关函数调用的信息，例如局部变量、参数和返回地址等。在递归调用之前已经执行了所有其他操作。
堆排序算法详解与实现
"这篇资料主要介绍了堆排序算法的原理和实现过程。堆排序是一种基于比较的排序算法，它利用了二叉堆的数据结构特性。在堆排序中，首先需要构建一个最大堆，然后通过交换堆顶元素（最大值）与最后一个元素并重新调整...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值