堆排序和优先级队列

  1 // max_heap and priority queue
  2 // the index must be [1,size],not [0,size-1]
  3 #include<iostream>
  4 using namespace std;
  5 int arr[20] = {1,4,2,3,9,7,8,14,10,16};
  6 #define PARENT(i) (i/2)
  7 #define LEFT(i) (i*2)
  8 #define RIGHT(i) (i*2+1)
  9 #define ERROR (-1)
 10 // dump an array
 11 void dump(int arr[],int cnt)
 12 {
 13     for(int i=0;i<cnt;i++){
 14         cout<<arr[i]<<" ";
 15     }
 16     cout<<endl;
 17 }
 18
 19 // ensure the max heap time=O(lg(n))
 20 void max_heapify(int arr[],const int size,const int index)
 21 {
 22     int l=LEFT(index),r=RIGHT(index),largest = index;
 23     if(l<=size && arr[l-1] > arr[index-1])largest=l;
 24     if(r<=size && arr[r-1] > arr[largest-1])largest=r;
 25     if(largest != index)
 26     {
 27         int tmp = arr[largest-1];
 28         arr[largest-1] = arr[index-1];
 29         arr[index-1] = tmp;
 30         max_heapify(arr,size,largest);
 31     }
 32 }
 33
 34 // build max_heap,time=O(n)
 35 // if index>size/2,arr[index] must be a leaf
 36 void build_max_heap(int arr[],const int size)
 37 {
 38     for(int i=size/2;i>0;i--)
 39     {
 40         max_heapify(arr,size,i);
 41     }
 42 }
 43
 44 // heap_sort,time=O(nlg(n))
 45 void heap_sort(int arr[],int size)
 46 {
 47     int tmp;
 48     for(int i=size;i>1;i--)
 49     {
 50         tmp = arr[0];
 51         arr[0] = arr[i-1];
 52         arr[i-1] = tmp;
 53         max_heapify(arr,--size,1);
 54     }
 55 }
 56
 57 // return max key of arr
 58 int top(int arr[],const int size)
 59 {
 60     return arr[0];
 61 }
 62
 63 // return max key of arr and delete it
 64 int pop(int arr[],int &size)
 65 {
 66     if(size < 1)return ERROR;
 67     int max = arr[0];
 68     arr[0] = arr[--size];
 69     max_heapify(arr,size,1);
 70     return max;
 71 }
 72
 73 // increase the key of i
 74 void heap_increase_key(int arr[],int i,int key)
 75 {
 76     if(key < arr[i-1])return;
 77     arr[i-1] = key;
 78     while(i>1 && arr[i-1]>arr[PARENT(i)-1])
 79     {
 80         int tmp = arr[i-1];
 81         arr[i-1] = arr[PARENT(i)-1];
 82         arr[PARENT(i)-1] = tmp;
 83         i = PARENT(i);
 84     }
 85 }
 86
 87 // insert into priority queue
 88 void insert(int arr[],int &size,int key)
 89 {
 90     size++;
 91     arr[size] = key-1;
 92     heap_increase_key(arr,size,key);
 93 }
 94 int main()
 95 {
 96     int n = 10;
 97     build_max_heap(arr,n);
 98     dump(arr,n);
 99     //heap_sort(arr,n);
100     //dump(arr,n);
101     pop(arr,n);
102     dump(arr,n);
103     insert(arr,n,13);
104     dump(arr,n);
105     return 0;
106 }

值得注意的是,堆排序中使用(i/2)表示父节点,(2*i)表示左节点,(2*i+1)表示右节点,所以这里面的 i 是从1开始计数的,而我们常见的数组是从0开始计数的,所以在调用[]取值操作时要记得下标-1

时间: 2024-12-28 13:23:58

堆排序和优先级队列的相关文章

优先级队列及小顶堆排序

优先级队列及小顶堆排序实现 /** @file          HeapSort.h *  @copyright     personal *  @brief         优先级队列及堆排序 *  @version       V1.0.0 *  @author        fangyuan *  @date          2015/12/31 *  @note          测试版本 */ #include "iostream" using namespace std

优先级队列与堆排序

转自:http://www.cnblogs.com/yangecnu/p/Introduce-Priority-Queue-And-Heap-Sort.html 在很多应用中,我们通常需要按照优先级情况对待处理对象进行处理,比如首先处理优先级最高的对象,然后处理次高的对象.最简单的一个例子就是,在手机上玩游戏的时候,如果有来电,那么系统应该优先处理打进来的电话. 在这种情况下,我们的数据结构应该提供两个最基本的操作,一个是返回最高优先级对象,一个是添加新的对象.这种数据结构就是优先级队列(Pri

浅谈算法和数据结构: 五 优先级队列与堆排序

转载自:http://www.cnblogs.com/yangecnu/p/Introduce-Priority-Queue-And-Heap-Sort.html 浅谈算法和数据结构: 五 优先级队列与堆排序 在很多应用中,我们通常需要按照优先级情况对待处理对象进行处理,比如首先处理优先级最高的对象,然后处理次高的对象.最简单的一个例子就是,在手机上玩游戏的时候,如果有来电,那么系统应该优先处理打进来的电话. 在这种情况下,我们的数据结构应该提供两个最基本的操作,一个是返回最高优先级对象,一个是

【数据结构】用模版实现大小堆、实现优先级队列,以及堆排序

一.用模版实现大小堆 如果不用模版的话,写大小堆,就需要分别实现两次,但是应用模版的话问题就简单多了,我们只需要实现两个仿函数,Greater和Less就行了,仿函数就是用类实现一个()的重载就实现了仿函数.这个看下代码就能理解了.再设计参数的时候,需要把模版设计成模版的模版参数,因为要实现大小堆嘛!当我们实现好一个大堆或者小队的逻辑后只需要用模版接收的Greater或Less类定义一个变量,就能实现通用功能了. template<typename T> struct Less {     b

JAVA优先级队列测试

package code.test; import java.util.Comparator; import java.util.Iterator; import java.util.PriorityQueue; import java.util.Queue; /** * 实验表明,在java中: * 1.优先级队列打印或者迭代,得到的输出顺序为堆结构数组的顺序,大致有序但不完全保证顺序 * 2.由于堆排序是不稳定排序,在优先级相同的情况下,元素不会保持原来的顺序输出 * Created by

第十章笔记&#183;优先级队列

需求与动机 什么是优先级队列 优先队列是计算机科学中的一类抽象数据类型.优先队列中的每个元素都有各自的优先级,优先级最高的元素最先得到服务:优先级相同的元素按照其在优先队列中的顺序得到服务.优先队列往往用堆来实现. --wikipedia 应用需求 在医院门诊,如果只有一个医生,多位病人.按照通常流程来说,采用先到先服务的顺序(FIFO).但是如果病人中有人患有心脏病,那么显然这个病人需要得到优先治疗. 在计算机系统中,绝大多数支持多任务,这种多任务调度也类似于医院门诊.CPU相当于医生,计算任

1.5 实现优先级队列

body, td { font-family: 微软雅黑; font-size: 10pt; } Edit 1.5 实现优先级队列 问题: 实现一个队列,能够按照给定的优先级排序,并且每次pop操作时都可以返回优先级最高的那个元素. 解决方案 1.import heapq2.class PriorityQueue:3. def __init__(self):4. self._queue=[]5. self._index=06. def push(self,item,priority):7. he

STL源码笔记(15)—堆和优先级队列(二)

STL源码笔记(15)-堆和优先级队列 优先级队列的源码实现基于heap的操作,底层容器默认是vector. 优先级队列简介 优先级队列跟队列类似,一端插入一端删除,不同的是,优先级队列的元素入队后会根据其优先级进行调整,默认情况下优先级高的将优先出队,在SGI STL中,优先级队列的功能保证由heap实现:stl_heap.h中,heap的分析见:STL堆源码分析 优先级队列构造函数 默认情况下,优先级队列使用vector作为底层容器,使用less作为比较函数,其在源码中的定义声明如下: te

STL源码笔记(14)—堆和优先级队列(一)

STL源码笔记(14)-堆和优先级队列 priority_queue是拥有权值观念的queue,跟queue类似,其只能在一端push,一端pop,不同的是,每次push元素之后再容器内部元素将按照一定次序排列,使得pop得到的元素始终是当前权值的极大值. 很显然,满足这个条件就需要某些机制了,缺省情况下使用max-heap大顶堆来实现,联想堆排序的实现,使用大顶完成序列从小到大的排序,过程大概是: 把堆的根元素(堆中极大值)交换到最后 堆的长度减1 这样每次取出堆中的极大值完成排序,刚好与优先