数据结构与算法之堆: 实现最大堆类的两种方式及实现堆排序 (Ts, Py, Go版)

已于 2024-11-08 12:59:32 修改
阅读量154 收藏
点赞数
分类专栏： Data Structure and Algorithms 文章标签： 算法 leetcode
于 2023-10-03 22:35:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tyro_java/article/details/133530983
版权

Typescript 版算法实现


1 ）方案一：参考最小堆类实现最大堆类及实现排序 
class MaxHeap {
    heap: number[] = [];
    // 交换节点位置
    swap(i, j) {
        [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
    }
    // 获得父节点
    getParentIndex(i) {
        return (i - 1) >> 1;
    }
    // 获取左子节点
    getLeftIndex(i) {
        return (i << 1) + 1; // 极客写法
    }
    // 获取右子节点
    getRightIndex(i) {
        return (i << 1) + 2;
    }
    // 向上移动
    shiftUp(index) {
        // 如果到了堆顶元素，index是0，则不要再上移了
        if(!index) return;
        const parentIndex = this.getParentIndex(index)
        if(this.heap[parentIndex] < this.heap[index]) {
            this.swap(parentIndex, index)
            this.shiftUp(parentIndex)
        }
    }
    // 下移
    shiftDown(index) {
        // 边界1：如果到了堆尾元素，则不要再下移了
        if(index >= this.heap.length - 1) return;
        const size = this.size();
        const leftIndex = this.getLeftIndex(index);
        const rightIndex = this.getRightIndex(index);
        if (leftIndex < size && this.heap[leftIndex] > this.heap[index]) {
            this.swap(leftIndex, index);
            this.shiftDown(leftIndex);
        }
        if (rightIndex < size && this.heap[rightIndex] > this.heap[index]) {
            this.swap(rightIndex, index);
            this.shiftDown(rightIndex);
        }
    }
    // 插入
    insert(value) {
        this.heap.push(value);
        this.shiftUp(this.heap.length - 1);
    }
    // 删除堆顶
    pop() {
        // pop()方法删除数组最后一个元素并返回，赋值给堆顶
        if (this.heap.length <= 1) return;
        this.heap[0] = this.heap.pop();
        // 对堆顶重新排序
        this.shiftDown(0);
    }
    // 获取堆顶
    peak() {
        return this.heap[0];
    }
    // 获取堆的大小
    size() {
        return this.heap.length;
    }
    sort(arr) {
    	// 1. 先构建一个最小堆
    	arr.forEach((n) => {
    		this.insert(n);
    	});
    	// 2. 开始依次排序，注意这个边界, pop不能是1，否则会造成死循环
    	const result = [];
    	while(this.heap.length > 1) {
    		result.push(this.peak());
    		this.pop();
    	}
    	// 3. 处理最后一个
    	result.push(this.peak());
    	this.heap = result;
    	return result;
    }
}

const mh = new MaxHeap();
mh.sort([1, 10, 9, 5, 3, 11, 3, 9, 11, 13, 1, -1, 98]);
console.log(mh.heap); // [98, 13, 11, 11, 10, 9, 9, 5, 3, 3, 1, 1, -1]
  • 实现最小堆类参考：https://blog.csdn.net/Tyro_java/article/details/133468244
  • 这里排序需要注意的是：先构建的最小堆，并不是排好序的，只是最小值在堆顶，O(logn)
  • 循环中每次把最小值取出来, 注意pop下移操作时的边界问题，O(nlogn)

2 ）方案二：另一种方式实现最大堆类及实现排序

class MaxHeap {
  heap: number[] = []
  // 交换两个元素
  static swap (arr, i, j) {
    if (i === j) return;
    [arr[i], arr[j]] = [arr[j], arr[i]];
  }
  // 构建最大堆的过程，递归
  static maxHeapify (Arr, i, size) {
    // 左节点（索引）
    const l = (i << 1) + 1
    // 右节点
    const r = (i << 1) + 2
    let largest = i;
    // 父节点i和左节点l做比较取最大
    if (l <= size && Arr[l] < Arr[largest]) largest = l;
    // 右节点和最大值比较
    if (r <= size && Arr[r] < Arr[largest]) largest = r;
    if (largest !== i) {
      MaxHeap.swap(Arr, i, largest);
      MaxHeap.maxHeapify(Arr, largest, size);
    }
  }
  sort () {
    const iArr = this.heap;
    const n = iArr.length;
    if (n <= 1) return iArr;
    // 这里，从最后一个父节点开始构建最大堆, 因为最后一个父节点到第一个父节点就是一次完整的构建最大堆的过程，完成后堆顶就是最大值
    for (let i = Math.floor(n / 2); i >= 0; i--) {
      MaxHeap.maxHeapify(iArr, i, n); // 这里最后一个参数 n 是完整的堆
    }
    // 减而治之
    for (let j = 0; j < n; j++) {
      MaxHeap.swap(iArr, 0, n - 1 - j); // 堆顶与最后一项互换, 堆顶被破坏, 堆顶变成最后一项
      MaxHeap.maxHeapify(iArr, 0, n - 1 - j - 1); // 这里逐渐缩小堆的规模，注意后面的减1，因为最后一个元素是排好序的最大值
    }
    return iArr
  }
}

const mh = new MaxHeap();
mh.heap = [1, 10, 9, 5, 3, 11, 3, 9, 11, 13, 1, -1, 98]
mh.sort();
console.log(mh.heap); // [98, 13, 11, 11, 10, 9, 9, 5, 3, 3, 1, 1, -1]
  • 这个排序的精髓是：在这个排序里先构建一次最大堆，获取排好序的最大值后，逐渐减而治之

Python3 版算法实现


1 ) 方案1

class MaxHeap:
    def __init__(self):
        self.heap = []

    # 交换节点位置
    def swap(self, i, j):
        self.heap[i], self.heap[j] = self.heap[j], self.heap[i]

    # 获得父节点
    def get_parent_index(self, i):
        return (i - 1) >> 1

    # 获取左子节点
    def get_left_index(self, i):
        return (i << 1) + 1

    # 获取右子节点
    def get_right_index(self, i):
        return (i << 1) + 2

    # 向上移动
    def shift_up(self, index):
        if index == 0:
            return
        parent_index = self.get_parent_index(index)
        if self.heap[parent_index] < self.heap[index]:
            self.swap(parent_index, index)
            self.shift_up(parent_index)

    # 下移
    def shift_down(self, index):
        if index >= len(self.heap) - 1:
            return
        size = self.size()
        left_index = self.get_left_index(index)
        right_index = self.get_right_index(index)
        if left_index < size and self.heap[left_index] > self.heap[index]:
            self.swap(left_index, index)
            self.shift_down(left_index)
        if right_index < size and self.heap[right_index] > self.heap[index]:
            self.swap(right_index, index)
            self.shift_down(right_index)

    # 插入
    def insert(self, value):
        self.heap.append(value)
        self.shift_up(len(self.heap) - 1)

    # 删除堆顶
    def pop(self):
        if len(self.heap) <= 1:
            return
        self.heap[0] = self.heap.pop()
        self.shift_down(0)

    # 获取堆顶
    def peak(self):
        return self.heap[0] if self.heap else None

    # 获取堆的大小
    def size(self):
        return len(self.heap)

    # 排序
    def sort(self, arr):
        for n in arr:
            self.insert(n)
        result = []
        while self.size() > 1:
            result.append(self.peak())
            self.pop()
        result.append(self.peak())
        self.heap = result
        return result

def main():
    mh = MaxHeap()
    sorted_array = mh.sort([1, 10, 9, 5, 3, 11, 3, 9, 11, 13, 1, -1, 98])
    print(sorted_array)  # 应该输出 [98, 13, 11, 11, 10, 9, 9, 5, 3, 3, 1, 1, -1]

if __name__ == "__main__":
    main()

2 ）方案2

class MaxHeap:
    def __init__(self):
        self.heap = []

    # 交换两个元素
    @staticmethod
    def swap(arr, i, j):
        if i == j:
            return
        arr[i], arr[j] = arr[j], arr[i]

    # 构建最大堆的过程，递归
    @staticmethod
    def max_heapify(arr, i, size):
        l = (i << 1) + 1
        r = (i << 1) + 2
        largest = i
        if l <= size and arr[l] > arr[largest]:
            largest = l
        if r <= size and arr[r] > arr[largest]:
            largest = r
        if largest != i:
            MaxHeap.swap(arr, i, largest)
            MaxHeap.max_heapify(arr, largest, size)

    # 排序
    def sort(self):
        i_arr = self.heap
        n = len(i_arr)
        if n <= 1:
            return i_arr
        for i in range(n // 2, -1, -1):
            MaxHeap.max_heapify(i_arr, i, n - 1)
        for j in range(n):
            MaxHeap.swap(i_arr, 0, n - 1 - j)
            MaxHeap.max_heapify(i_arr, 0, n - 2 - j)
        return i_arr

def main():
    mh = MaxHeap()
    mh.heap = [1, 10, 9, 5, 3, 11, 3, 9, 11, 13, 1, -1, 98]
    sorted_array = mh.sort()
    print(sorted_array)  # 应该输出 [98, 13, 11, 11, 10, 9, 9, 5, 3, 3, 1, 1, -1]

if __name__ == "__main__":
    main()

Golang 版算法实现


1 ) 实现1

package main

import (
	"fmt"
)

type MaxHeap struct {
	heap []int
}

// 交换节点位置
func (h *MaxHeap) swap(i, j int) {
	h.heap[i], h.heap[j] = h.heap[j], h.heap[i]
}

// 获得父节点
func (h *MaxHeap) getParentIndex(i int) int {
	return (i - 1) >> 1
}

// 获取左子节点
func (h *MaxHeap) getLeftIndex(i int) int {
	return (i << 1) + 1
}

// 获取右子节点
func (h *MaxHeap) getRightIndex(i int) int {
	return (i << 1) + 2
}

// 向上移动
func (h *MaxHeap) shiftUp(index int) {
	if index == 0 {
		return
	}
	parentIndex := h.getParentIndex(index)
	if h.heap[parentIndex] < h.heap[index] {
		h.swap(parentIndex, index)
		h.shiftUp(parentIndex)
	}
}

// 下移
func (h *MaxHeap) shiftDown(index int) {
	if index >= len(h.heap)-1 {
		return
	}
	size := h.size()
	leftIndex := h.getLeftIndex(index)
	rightIndex := h.getRightIndex(index)
	if leftIndex < size && h.heap[leftIndex] > h.heap[index] {
		h.swap(leftIndex, index)
		h.shiftDown(leftIndex)
	}
	if rightIndex < size && h.heap[rightIndex] > h.heap[index] {
		h.swap(rightIndex, index)
		h.shiftDown(rightIndex)
	}
}

// 插入
func (h *MaxHeap) insert(value int) {
	h.heap = append(h.heap, value)
	h.shiftUp(len(h.heap) - 1)
}

// 删除堆顶
func (h *MaxHeap) pop() {
	if len(h.heap) <= 1 {
		return
	}
	h.heap[0] = h.heap[len(h.heap)-1]
	h.heap = h.heap[:len(h.heap)-1]
	h.shiftDown(0)
}

// 获取堆顶
func (h *MaxHeap) peak() *int {
	if len(h.heap) == 0 {
		return nil
	}
	return &h.heap[0]
}

// 获取堆的大小
func (h *MaxHeap) size() int {
	return len(h.heap)
}

// 排序
func (h *MaxHeap) sort(arr []int) []int {
	for _, n := range arr {
		h.insert(n)
	}
	result := make([]int, 0, len(arr))
	for h.size() > 1 {
		result = append(result, *h.peak())
		h.pop()
	}
	result = append(result, *h.peak())
	h.heap = result
	return result
}

func main() {
	mh := &MaxHeap{}
	sortedArray := mh.sort([]int{1, 10, 9, 5, 3, 11, 3, 9, 11, 13, 1, -1, 98})
	fmt.Println(sortedArray) // 应该输出 [98, 13, 11, 11, 10, 9, 9, 5, 3, 3, 1, 1, -1]
}

2 ）实现2

package main

import (
	"fmt"
)

type MaxHeap struct {
	heap []int
}

// 交换两个元素
func (h *MaxHeap) swap(arr []int, i, j int) {
	if i == j {
		return
	}
	arr[i], arr[j] = arr[j], arr[i]
}

// 构建最大堆的过程，递归
func (h *MaxHeap) maxHeapify(arr []int, i, size int) {
	l := (i << 1) + 1
	r := (i << 1) + 2
	largest := i
	if l <= size && arr[l] > arr[largest] {
		largest = l
	}
	if r <= size && arr[r] > arr[largest] {
		largest = r
	}
	if largest != i {
		h.swap(arr, i, largest)
		h.maxHeapify(arr, largest, size)
	}
}

// 排序
func (h *MaxHeap) sort() []int {
	iArr := h.heap
	n := len(iArr)
	if n <= 1 {
		return iArr
	}
	for i := n / 2; i >= 0; i-- {
		h.maxHeapify(iArr, i, n-1)
	}
	for j := 0; j < n; j++ {
		h.swap(iArr, 0, n-1-j)
		h.maxHeapify(iArr, 0, n-2-j)
	}
	return iArr
}

func main() {
	mh := &MaxHeap{
		heap: []int{1, 10, 9, 5, 3, 11, 3, 9, 11, 13, 1, -1, 98},
	}
	sortedArray := mh.sort()
	fmt.Println(sortedArray) // 应该输出 [98, 13, 11, 11, 10, 9, 9, 5, 3, 3, 1, 1, -1]
}
Wang's Blog
关注
专栏目录
数据结构与算法之排序: 堆排序 (Ts, Py, Go版)
Wang的专栏
10-27 262
数据结构与算法之排序: 堆排序
数据结构与算法之堆: LeetCode 451. 根据字符出现频率排序 (Ts, Py, Go版)
最新发布
Wang的专栏
10-04 353
1 ）普通方法实现, 基于原生sort和Map结构。2 ）使用堆排序
利用typescript实现堆排序
cswxb的博客
11-09 224
本文主要讲解堆排序的原理以及代码实现，要理解堆排序，首先需要了解二叉树，下面我们逐步展开树。
数据结构与算法之堆: LeetCode 215. 数组中的第K个最大元素 (Ts, Py, Go版)
Wang的专栏
10-01 268
1 ）基于js中原生sort api。2 ）基于堆的数据结构和堆排序的方法。3 ）基于冒泡排序。 4 ) 基于快速排序。
数据结构与算法之堆: LeetCode 347. 前K个高频元素 (Ts, Py, Go版)
Wang的专栏
10-02 200
【代码】数据结构与算法之堆: Leetcode 347. 前K个高频元素 (Typescript版)
算法与数据结构面试宝典——堆及其常用操作详解
白话机器学习
09-22 102
堆 heap」是一种满足特定条件的完全二叉树，主要可分为下图所示的两种类型。≥≤堆作为完全二叉树的一个特例，具有以下特性。
算法与数据结构面试宝典——堆应用，Top-K 问题
白话机器学习
09-22 59
!!question给定一个长度为n无序数组nums，请返回数组中前k大的元素。对于该问题，我们先介绍两种思路比较直接的解法，再介绍效率更高的堆解法。
肝了一个月，全网最全的数据结构与算法知识总结
南迪叶先森
11-05 9954
脑图：https://www.processon.com/mindmap/6179408f0e3e7416bdeb81d1 开发环境 Mac C语言环境配置 软件：Visual Studio Code Coder Runner 插件 一、数据结构的概述 1、定义 我们如何把现实中大量而复杂的问题以特定的数据类型和特定的存储结构保存到主存储器（内存）当中，以及在此基础上为实现某个功能（比如查找某个元素，删除某个元素，对所有元素进行排序）而执行的相应操作，这个相应的操作也叫算法 狭义： ​ 数据
MATLAB算法实战应用案例精讲-【数据分析】时序异常检测（补充篇）（附Java、R语言和python代码实现）
qq_36130719的博客
01-10 2663
时间序列是指将同一统计指标的数值按其发生的时间先后顺序排列而成的数列。正如人们常说，人生的出场顺序很重要，时间序列中隐藏着一些过去与未来的关系。时间序列分析试图通过研究过去来预测未来。时间序列分析在工程、金融、科技等众多领域有着广泛的应用。在大数据时代，时间序列分析已经成为 AI 技术的一个分支，通过将时间序列分析与分类模型相结合，更好的应用于数据检测、预测等场景。重构误差阈值设定的方法Doyle于1962年提出的P-Tile (即P分位数法)可以说是最古老的一种阈值选取方法。
数据结构--python 第八章 排序
Jasminexjf的博客
04-18 789
随着信息科技的普及与全球国际化的影响，企业拥有的数据量成倍数地增长。无论是庞大的商业应用软件，还是个人的文字处理软件，每项工作的核心都与数据库有莫大的关系，而数据库中最常见且重要的功能就是排序和查找。 排序(sorting)是指将一组数组按照特定的规则调换位置，使得数据具有某种顺序关系（递增或递减）。例如数据库内可针对某一字段进行排序，而此字段被称为键(key)，字段里的值就被称为键值(key ...
处理Excel的Python算法_4.1_：数组导入和整理模块——Panda（快速入门）
数据分析笔记
01-11 631
索引官方文档QuickStartPandas概览快速入门基础用法数据结构简介与其他工具比较 官方文档 中文官网：https://www.pypandas.cn QuickStart Pandas概览 快速入门 基础用法 数据结构简介 与其他工具比较
20220108_datawhale33期_leetcode刷题_5链表
余柳成荫的博客
01-13 329
五 链表 Images Source: https://realpython.com/ 目录五 链表来源1 链表基础1.1 基础知识1.2 相关题目1.2.1 [707 . 设计链表](https://leetcode-cn.com/problems/design-linked-list/)1.2.2 [206 . 反转链表](https://leetcode-cn.com/problems/reverse-linked-list/)1.2.3 [92 . 反转链表 II](https://leetcode
UntrimmedNets: 弱监督动作识别与检测中的新框架
1基于UntrimmedNets的弱监督动作识别与检测王利民1熊元军2林大华2吕克·范古尔11瑞士苏黎世联邦理工学院计算机视觉实验室2香港中文大学资讯工程学系，香港摘要目前的动作识别方法严重依赖于修剪视频进行模型训练。...
利用python进行数据分析_从删库到跑路
YeChao3的博客
10-19 2537
目录 前言 一　numpy模块 １．numpy的数据结构：多维数组ndarray 数组转置和轴对换 矩阵内积 通用函数 利用数组进行数据处理(矢量化) 将条件逻辑表述为数组运算 数组和统计法方法  约简 排序sort 唯一化和其他集合逻辑 数组中的集合运算 用于数组的文件输入输出 线性代数 随机数生成 部分numpy.random函数 随即漫步 数组重塑 扁...
数据结构与算法笔记：字典序最大问题分析
Wang的专栏
07-18 3748
字典序最大问题 问题描述 给定一个1到n的排列(无序状态的)，依次插入到栈中，在每时每刻都可以多次从栈中弹出栈顶 问：应如何使得弹出栈顶的序列的字典序最大，并输出这个序列 问题分析 什么是字典序 比如两个序列：5,4,3,2,1和1,2,3,4,5 这两个中第一个的字典序最大 每个位置上的数字比其他序列上同一位置的数字要大 比如：第一位置中5比1大，第二位置中4比2大这样 即：字典序最大 = 从左向右看这个序列，每个数字都尽量大 题目给定一个1到n的排列，每个数字只出现一次 要使出栈的字典序最大
数据结构与算法笔记：农夫过河问题python3实现
Wang的专栏
08-07 2947
问题描述 农夫(Human)过河。一个农夫带着一只狼(Wolf)，一只羊(Sheep)和一些菜(Vegetable)过河。河边只有一条船，由于船太小，只能装下农夫和他的一样东西。在无人看管的情况下，狼要吃羊，羊要吃菜，请问农夫如何才能使三样东西平安过河? 要求： 输出一行，为最终的过河方式，方案格式为 过河人员、回来人员、过河人员、回来人员、…、过河人员。 过去和回来的人员之间，用空格隔开。 以四...
数据结构与算法笔记：计算思维之经典农夫过河问题C++实现
Wang的专栏
01-12 2886
农夫、羊、狼、菜的过河问题 问题描述 角色：农夫，羊，狼，菜 条件1：船很小，只能装下农夫和其他一个角色 条件2：无人看管，羊吃菜，狼吃羊 问：如何让其他三种角色被农夫平安带着过河? 相关分析 我们可以先用人脑尝试一下相关渡河策略 1 ) 先渡狼，人回来再渡菜，人回来再渡羊 2 ) 先渡菜，人回来再渡狼，人回来再渡羊 以上两种很好想到，而且我们可以知道羊这种角色是不能先渡河过去的，羊需要最后再渡 如果先渡了羊了，之后再渡任何其他角色，都要将羊带回来 可以参考小游戏：http://gameschool
数据结构与算法笔记：图搜索之DFS详解
Wang的专栏
02-08 2543
图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) !!!本文详解!!! 深度优先搜索DFS 深度优先遍历DFS, 这个策略其实是非常stupid or simple的，比BSF要简单的多 同样，我们可以通过一个故事来开始 在古希腊神话中, Ariadne是Crete的国王Minos的公主，她给忒修斯(Theseus)一个线团 使得忒修斯成功进入迷宫杀死牛头怪兽，但事后忒修斯抛弃了她 这是一个有道德意义的故事又或者存在不同的版本, 但不是我们的研究的对象
数据结构与算法笔记：计算思维之人鬼渡河问题
Wang的专栏
07-22 1860
人鬼渡河问题 1 ) 问题描述 目标:将东岸的3人3鬼通过一只小船安全转移到西岸，希望摆渡次数尽可能少 条件 船的容量有限，一次最多只能坐2人(或2鬼或1人1鬼) 无论是在河的东岸还是在河的西岸，一旦鬼数多于人数，则人将被鬼吃掉 怎样渡河的大权掌握在人的手中 说明:划船的时间忽略不计。船一靠岸即将船与岸视为一体，人和鬼即使还没有下 船也视为已上岸 任务:编写程序，求出一种渡河方案 备注：图片托管于github，请确保网络的可访问性 2 ) 分析 目标是找
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值