【自制演示代码】Basic Operations on a Binary Min-Heap

最新推荐文章于 2025-03-25 19:15:00 发布

Draba_Chen

最新推荐文章于 2025-03-25 19:15:00 发布

阅读量351

点赞数 4

文章标签：堆 C

本文链接：https://blog.csdn.net/Commander_WingT/article/details/138037763

版权

本文介绍了二叉最小堆的基本属性，如结构和堆序，以及在C语言中实现的插入、删除最小值等操作。代码展示了如何使用堆对输入序列进行排序，同时提供了注意事项和函数定义。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Properties of a Binary Min-Heap

1. Structure Property

A binary min-heap has to be a complete binary tree.

2. Heap Order Property

The value of any node in a binary min-heap has to be no greater than its two children's values(if exists).

Operations Included in the Code

In the following code, you will see the operations below:

- BuildHeap

- PercolateDown

- PercolateUp

- Insert

- DeleteMin

- PrintHeap

Also, you will see the simple typedef of:

- Heap

Notes and Declarations

The code will sort the input sequence with a heap.

The language used is C.

The purpose of posting this code online is to make a quick note of my studying progress.

For students at school, DO NOT copy this code into your homework or projects. Otherwise, I will not be responsible for any punishments because of

最低0.47元/天解锁文章

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

Draba_Chen

关注关注

4
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

数据结构与算法基础知识 Data structure is the foundation of algorithm design and efficient problem solving

AI天才研究院

07-29

1243

作者：禅与计算机程序设计艺术Data structure is the foundation of algorithm design and efficient problem solving in computer science. Almost all programming languages provide various built-in data structures like arrays, lists, stacks, queues, trees, graphs etc. Each data

Spring Boot学习总结（8）——SpringBoot Common application properties（application.properties）详解

科技D人生

05-05

3818

各种属性可以在您的application.properties/application.yml文件或命令行开关指定。下面提供了常见的Spring启动属性和引用它们的基础类的列表。 # =================================================================== # COMMON SPRING BOOT PROPERTIES # # T

参与评论您还未登录，请先登录后发表或查看评论

Byte Buffers and Non-Heap Memory

Stroller

06-08

1420

kdgregory.com Blog Food Programming Travel Byte Buffers and Non-Heap Memory Most Java programs spend their time working with objects on the JVM heap, using getter and setter metho

Binomial Heap(English Version)

weixin_30389003的博客

08-29

100

Just like leftist or skew heaps, a binomial heap is also a mergeable heap data structure. But unlike those 'lopsided' heaps that are composed of only single binary tree, a binomial heap consists o...

2.Binary Heap[数据结构]

医学影像学习笔记

11-30

722

A Binary Heap is a Binary Tree with following properties. 1) It’s a complete tree (All levels are completely filled except possibly the last level and the last level has all keys as left as possible).

on-java-8 知识总结（低频部分）

weixin_42100211的博客

08-16

287

on java 8一书中相对没那么重要的低频内容

二叉堆介绍 Introduction to Heap (C implementation)

Negative12的博客

03-15

329

Introuduction to Heap 本文介绍了二叉堆的基本概念以及相关操作，完全为无基础准备，内含丰富的图文解释和代码实现。若有任何问题请随时联系。

Fibonacci Heap

w112348的博客

01-22

202

Prerequisite: Binomial Heap Binomial tree of degree k Definition: two k-1 binomial tree merge into a k binomial tree Property: the root has k children the tree has 2k2^k2k elements the tree has height k the children of binomial tree are binomial trees of

docker-compose(mysql5.6、mysql8、neo4j3.5、redis、Elasticsearch、Kibana、Nginx、Jre)

等等等等等再等

03-21

1143

docker-compose一键部署常用软件

CTF-PWN-kernel-堆（UAF heap_overflow freelist劫持 offbynull arbitary_heap_free unlink page_level ）

llovewuzhengzi的博客

08-26

402

文章目录参考Use After Free绑核cred_jar 可合并expcred_jar 不可合并利用 tty_struct 劫持程序控制流提权expHeap Overflow排布溢出修改 credexp堆溢出 + 堆喷射覆写 seq_operations 控制内核执行流expArbitrary Address Allocation（freelist 劫持）modprobe_path提权利用expOff By Null调试漏洞利用poll初始化喷poll_list和user_key_payload喷seq

ScaleHLS-opt 参数详解：高层次综合优化工具指南

最新发布

kanhao100的博客

03-25

758

在当今异构计算时代，将高级算法高效地映射到硬件加速器（如FPGA和ASIC）上变得至关重要。ScaleHLS是一个基于MLIR（Multi-Level Intermediate Representation，多级中间表示）的开源高层次综合（HLS）框架，旨在提供更强大、更灵活的硬件加速优化能力。作为ScaleHLS的核心工具，`scalehls-opt`提供了丰富的优化选项，帮助设计者从高级描述生成高质量的硬件实现。

数仓开发面试题-Spark

话数Science

10-28

383

和Parquet类似，ORC文件也是以二进制方式存储的，所以是不可以直接读取，ORC文件也是自解析的，它包含许多的元数据，这些元数据都是同构ProtoBuffer进行序列化的。通过这三种文件存储格式的测试对比，ORC文件存储格式无论是在空间存储、导数据速度还是查询速度上表现的都较好一些，并且ORC可以一定程度上支持ACID操作，社区的发展目前也是Hive中比较提倡使用的一种列式存储格式，另外，本次测试主要针对的是Hive引擎，所以不排除存在Hive与ORC的敏感度比PARQUET要高的可能性。

Chrome的启动参数

Criss@陈磊

02-23

5263

List of Chromium Command Line Switches Condition Explanation --[1]⊗ Classic, non-material, mode for the |kTopChromeMD| switch.↪ --0⊗ Value of the --profiler-timing flag that will disable timin...

Unity 【Content Size Fitter】- 聊天气泡自动适配Text文本框大小

当代野生程序猿

02-25

6205

通常在展示人物对话的时候文本的长度是不定的，因此会需要动态的调整对话内容文本框的背景图片的大小，这里以如下这种气泡框的对话为例：实现该需求涉及到的内容包括Content Size Fitter组件的使用、2D Sprite工具包的使用。 Content Size Fitter组件用于Text文本框，如图所示，我们将Horzontal Fit设为Preferred Size，当我们调整Text文本框中的内容时，其大小会自动进行调整。注意Rect Transform中Pivot轴心点的设置

新唐NUC972 Linux（一）：USB烧写linux出厂镜像

小破孩的博客

02-20

3559

USB烧写出厂镜像文章目录USB烧写出厂镜像前言一、硬件连接二、安装驱动三、烧写linux程序四、运行程序前言今天开始进军linux，学了那么久单片机，也摸得七七八八，至少点个灯还是会的。本人之所以买酷客的linux开发板主要是便宜，资料也算齐全，虽然没有原子那么好，不过也够了，找那么多借口，其实就是qiong。今天先从USB烧录官方提供的linux相关程序到芯片开始吧。一、硬件连接 1、连接电源线 2、RS232转USB，需要安装CH340驱动，用于在电脑串口超级终端中查看调试信息。 3、U

WeChall CTF Writeup（一）

weixin_43211186的博客

02-25

1679

以下题目标题组成： [Score] [Title] [Author] 文章目录0x01 1 Training: Get Sourced by Gizmore0x02 1 Training: Stegano I by Gizmore0x03 1 Training: Crypto - Caesar I by Gizmore0x04 1 Training: WWW-Robots by Gizmore0x05 1 Training: ASCII by Gizmore 0x01 1 Training: Get Sou

C语言每日一练——第126天：佩奇借书问题

热门推荐

Edison's 小宇宙

02-25

2万+

史上最强借书方案问题讲解（代码详解+思路分析+动图演示+特性总结）

CS5261与CS5265功能应用|CS5261替代RTD2171|CS5265替代RTD2172

qq1659747718的博客

02-25

1437

CS5261可以完全替代兼容停产RTD2171,CS5265可以完全替代兼容RTD2172，芯片单价低，整体方案设计简单，整体BOM成本较RTD2171、RTD2172低。

Hello Kafka（八）——Confluent Kafka简介

天山老妖

02-24

9295

一、Confluent Kafka简介 1、Confluent Kafka简介 2014年，Kafka的创始人Jay Kreps、NahaNarkhede和饶军离开LinkedIn创立Confluent公司，专注于提供基于Kafka的企业级流处理解决方案，并发布了Confluent Kafka。Confluent Kafka分为开源版和企业版，企业版收费。 2、Confluent Kafka特性 Confluent Kafka开源版特性如下：（1）Confluent Kafka Connecto

buddy算法

03-08

### Buddy Algorithm Implementation and Explanation In computer science, the buddy memory allocation method is a technique used by various operating systems to allocate memory blocks of size \(2^n\) (where n is an integer). This approach ensures that fragmentation remains low while providing efficient memory management. #### Key Concepts Memory allocated using this system must be in powers of two. When allocating or freeing space, buddies are paired together based on their sizes until no more pairs can be made within available segments[^1]. #### Implementation Details To implement the buddy algorithm effectively: - A binary tree structure represents all possible block divisions. - Each node corresponds to one potential division point between two equal-sized areas. - The root starts as the entire addressable range; children represent halves recursively divided down through leaves representing individual units at minimum granularity supported by hardware architecture. Here’s how such logic might look implemented programmatically with Python code demonstrating core functionality without specific optimizations typically found in production environments: ```python class Block: def __init__(self, start, end): self.start = start self.end = end self.buddy = None self.is_free = True def find_buddy(block, heap_size): current_level_bits = int.bit_length(heap_size) - 1 diff = abs((block.end - block.start + 1) // 2) if block.start % (diff * 2) == 0: return Block(block.start + diff, min(block.end, block.start + (diff * 2) - 1)) else: return Block(max(0, block.start - diff), block.start - 1) def split_block(parent_block): mid_point = parent_block.start + ((parent_block.end - parent_block.start) // 2) first_child = Block(parent_block.start, mid_point) second_child = Block(mid_point + 1, parent_block.end) first_child.buddy = second_child second_child.buddy = first_child return [first_child, second_child] heap_memory = [] allocated_blocks = {} free_list = [] # Initialize free list with single large chunk covering full 'virtual' heap area initial_heap_chunk = Block(0, pow(2, 20)) # Example for 1MB total virtual heap size free_list.append(initial_heap_chunk) def malloc(size): required_power_of_two = 1 << (size - 1).bit_length() suitable_block_index = next( ( i for i, b in enumerate(free_list) if not b.is_free or (b.end - b.start + 1 >= required_power_of_two) ), None, ) if suitable_block_index is None: raise MemoryError("Out of memory") selected_block = free_list.pop(suitable_block_index) remaining_space_after_allocation = selected_block.end - selected_block.start + 1 - required_power_of_two new_allocated_block = Block(selected_block.start, selected_block.start + required_power_of_two - 1) new_allocated_block.is_free = False if remaining_space_after_allocation > 0: leftover_piece = Block(new_allocated_block.end + 1, selected_block.end) leftover_piece.is_free = True free_list.append(leftover_piece) allocated_blocks[id(new_allocated_block)] = new_allocated_block return id(new_allocated_block) def free(ptr_id): target_block = allocated_blocks.get(ptr_id) if target_block is None or not target_block.is_free: raise ValueError('Invalid pointer') del allocated_blocks[ptr_id] target_block.is_free = True merge_with_buddies(target_block) def merge_with_buddies(current_block): global free_list while current_block.buddy and current_block.buddy.is_free: merged_start = min(current_block.start, current_block.buddy.start) merged_end = max(current_block.end, current_block.buddy.end) combined_block = Block(merged_start, merged_end) free_list.remove(current_block) free_list.remove(current_block.buddy) current_block = combined_block free_list.append(combined_block) break # Only attempt merging once per call due to changing state during iteration over `free_list` ``` This example demonstrates basic operations like splitting larger chunks into smaller ones when needed (`split_block` function) and joining adjacent freed regions back together whenever feasible (`merge_with_buddies`). It also includes simplified versions of common functions seen in real-world implementations—such as those responsible for requesting (`malloc`) and releasing (`free`) portions from/to managed storage pools.