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

最新推荐文章于 2025-06-23 10:35:21 发布

Draba_Chen

最新推荐文章于 2025-06-23 10:35:21 发布

阅读量380

点赞数 4

CC 4.0 BY-SA版权

文章标签：堆 C

本文链接：https://blog.youkuaiyun.com/Commander_WingT/article/details/138037763

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 pu

最低0.47元/天解锁文章

200万优质内容无限畅学

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

Draba_Chen

关注关注

4
点赞
踩
8

收藏

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

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

14、 Node-Based Data Structures: Exploring Linked Lists

weixin_34268462的博客

06-01

This blog post delves into the world of node-based data structures, starting with linked lists and progressing to more advanced structures like binary search trees and heaps. It provides a comprehensive overview of their implementation in Python, key opera

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

AI天才研究院

07-29

1286

作者：禅与计算机程序设计艺术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

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

Byte Buffers and Non-Heap Memory

Stroller

06-08

1450

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

111

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

747

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

316

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

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

Negative12的博客

03-15

381

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

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

llovewuzhengzi的博客

08-26

497

文章目录参考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

Fibonacci Heap

w112348的博客

01-22

267

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

1247

docker-compose一键部署常用软件

49、Priority Queues: Principles, Implementations, and Applications

热门推荐

Edison's 小宇宙

02-25

2万+

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

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

qq1659747718的博客

02-25

1498

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

Hello Kafka（八）——Confluent Kafka简介

天山老妖

02-24

9471

一、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

基于System Verilog的同步FIFO实现(一)

qq_40268672的博客

02-22

3345

FIFO，全称First In First Out，它是数字电路设计中一个重要的基本单元，它分为同步FIFO和异步FIFO，所谓同步FIFO，是指读写都是在同一个时钟的驱动下进行的，而异步FIFO读写操作的时钟是分离的，本文主要讲述同步FIFO的实现。如图，是同步FIFO的一个示意图，它由clk,rst,wr_en,rd_en,full,empty,rdata,wdata等信号构成，其中，full,empty用于指示fifo的状态(空或满)，wr_en,rd_en分别为写使能和读使能信号，在FIFO的设

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.