堆排序

一：选择排序，O(n2) 选择排序是一种灵巧的算法，但其速度不是很快 代码示例： # 选择排序：O(nxn) # 找出数组中最小的元素 def findsmallest(arr): # 假设小值为arr[0] smallest = arr[0] # 存储最小元素的索引 smallest_index = 0 # O(n) for i in range(1, len(arr)): if arr[i] < smallest: smallest = arr[i] smallest_index = i return smallest_index # 对数组进行选择排序 def selectionSort(arr): newArr = [] # O(nxn) for i in range(len(arr)): smallest_index = findsmallest(arr) # 将该索引的元素添加到newArr newArr.append(arr.pop(smallest_index)) return newArr print(selectionSort([1, 8, 6, 9, 10])) # [1, 6, 8, 9, 10] 二：递归 问题：有个盒子里有盒子，而盒子里的盒子又有盒子。钥匙就在某个盒子中。怎么能找到钥匙。 代码示例： 第一种方法： 详细检查盒子内的东西

一 初识堆 堆 数据结构是一种数组，它可以视为一颗完全二叉树。如下图： 图中的树是数组，A={16, 14, 10, 8, 7, 9, 3, 7}，圈内表示数值，圈外红色的数字表示数组的下标。 array_size是数组的大小（此时是8），heap_size是构建堆的元素的多少。满足 heap_size<= array_size 给定某结点的下表i,其父结点下标为PARENT(i), 左儿子下标为LEFT(i), 右儿子下标为RIGHT(i)。满足 PARENT(i) = int((i-1)/2) ; LEFT(i) = 2*i+1; RIGHT(i)=2*i+2 最大堆满足：对于任何结点（除根节点）PARENT(i) > i 最小堆满足：对于任何结点（除根节点）PARENT(i) <i 叶子节点（下标）：int(i/2), int(i/2)+1......array_size 下面的介绍以 最大堆 为例 二 保持堆的性质 最大堆的性质为 PARENT(i) > i，因此对于特定的结点，应满足比左右儿子都大 、 在上图中下标为1的结点值为2，左孩子为4，右孩子为1，1结点比左孩子小，就让1结点和3结点数值换过来。若此时4结点大于4，就把1结点和4结点数值换过来。 参考程序： void MAX_HEAPIFY(int *A, int heap_size, int i) //i

1、 排序算法（快排、选择、冒泡、堆排序、 二叉排序树 、桶排序） 2、 DFS/BFS 剪枝 哈希表 3、树 ① 遍历 ② 二叉树 ③二叉排序树（查找、生成、删除） ④堆（二叉堆、左偏树、堆排序） ⑤Trie树 4、图（图论建模） ① 最小生成树 ② 最短路径 ③计算图的传递闭包 ④ 连通分量（其中要掌握并查集技术） 强连通分量tarjin ⑤ 拓扑排序 、关键路径 ⑥哈密尔顿环 ⑦ 欧拉回路 （USACO 3.3 题1 Fence） ⑧ Bell-man Ford、SPFA（能解决负权回路） （USACO 3.2 题6 Butter） ⑨二分图（匈牙利算法）(USACO 4.2 题2 stall) 5、动态规划（背包问题只是其中一种） ① 线性动规 ② 区间动规 ③ 树形动规 ④图形动规 6、 分治 （掌握了动规分治就好学了） 7、 贪心 8、 位运算 （可以用来进行优化） 来源： https://www.cnblogs.com/GldHkkowo/p/8710834.html

void topdown(map<int,int> &m,vector<int> &heap,int size,int r) { int tmp=heap[r]; int i; for(i=r;i*2+1<size;) { int j=i*2+1; if(j<size-1&&m[heap[j]]<m[heap[j+1]]) j++; if(m[tmp]<m[heap[j]]) { heap[i]=heap[j]; i=j; } else { break; } } heap[i]=tmp; } vector<int> topKFrequent(vector<int>& nums, int k) { map<int,int> m; int len=nums.size(); vector<int> heap; for(int i=0;i<len;i++) { m[nums[i]]++; if(m[nums[i]]==1) heap.push_back(nums[i]); } int s=heap.size(); for(int i=s/2-1;i>=0;i--) { topdown(m,heap,s,i); } for(int i=0;i<k;i++) { int tmp=heap[0]; heap[0]=heap[s-1-i]; heap[s-1-i]=tmp; topdown(m

堆排序 堆排序的主要思想 关于什么是堆，可以看看 二叉堆 。这里就不在啰嗦了。 关于堆，我们知道有个最主要的性质，对于 最大堆 ，堆顶的元素总是最大的，对于 最小堆 ，堆顶的元素总是最小的。所以如果我们将一个数组转化成一个堆，在反复执行删除堆顶元素的操作，那么每次删除的元素必然是有序的，也就实现了我们排序的效果。 因此，堆排序的步骤主要两点： 构建堆，将一个数组转化成一个堆，我们在MaxHeap.md中有总结，时间复杂度是O(n log 2 n) 遍历删除堆顶的元素，我们知道删除堆顶元的时间复杂对是O(log 2 n)，那么如果堆中有n个元素，则时间复杂度变成O(nlog 2 n)。由此得出堆排序的时间复杂度是O(nlog 2 n)。 综上所述，我们发现如果这样做，那么时间复杂度是没有问题的，但是空间上则需要使用一个附加的数组来存储每次删除的元素，使得存储需求增加一倍。那么这个问题怎么规避呢，我们知道删除堆顶元素后，为了维护堆的性质，我们的做法是将最后一个元素放到堆顶位置，在进行siftDown()操作。比如下图，我们删除97后，会将31放到堆顶 （这个时候31的位置就空下来了） ，然后调整堆。那么我们就可以利用这一点，将97放到空下来的位置。然后依次类推，我们在删除59，那么还是31的位置空下来，我们在将59放到空下来的位置，直到堆中剩下一个元素

我们可以把任意优先队列编程一种排序方法。将所有元素插入一个查找最小元素的优先队列，然后再重复调用删除最小元素的操作来将他们按顺序删除。用无序数组实现的优先队列这么做相当于一次选择排序。用基于堆的优先队列排序相当于我今天要说的—— 堆排序 。 堆排序可以分为 两个阶段 ：①堆的构造 ②下沉排序 堆的构造 ：①用swim（）可以在与NlogN成正比的时间内完成这项操作。只需从左至又遍历数组，②挨个把元素插入到堆中。 ②用sink（）只需少于2N次比较和小于N次交换。显然下沉操作更加高效。将每个节点下沉排序，即通过此算法可以使只有目前节点作为根节点的堆进行有序化，显然数组中N/2之后的节点都不存在新的子叶，故下沉函数从N/2以前从右至左挨个实现当前子堆的有序化，最终可实现整个堆的有序化。 下沉排序 ：将堆中最大元素放到最后，使堆的规模减小一，再循环次步骤，直至堆中不存在元素。 堆排序的代码实现： public static void sort(Comparable [] a) { int N=a.length; for(int k=N/2;k>=1;k--) { //构造堆，即实现堆的有序化 sink(a,k,n); } while(N>1) { exch(a,1,N--); //交换根节点和堆中最后一个元素的位置，即将目前堆中最大的元素放于对的最后 sink(a,1,N); /

有时利用特殊的数据结构可以极大的提高计算机的运算效率，堆排序利用了完全二叉树的便捷性，提高了排序的效率，时间复杂度为O(nlogn) 递归实现: public class HeapSort { public static void main ( String [ ] args ) { int [ ] arr = new int [ ] { 30 , 42 , 7 , 66 , 3 , 51 , 67 , 21 , 19 , 45 } ; sort ( arr ) ; } public static void sort ( int [ ] arr ) { buildHeap ( arr ) ; // 构建大顶堆 for ( int a : arr ) { System . out . print ( a + " " ) ; } // 打印 67 66 51 42 45 30 7 21 19 3 System . out . print ( "\n" ) ; int temp ; for ( int i = arr . length - 1 ; i > 0 ; i -- ) { // 依次交换堆顶(最大值)到最后一个结点 temp = arr [ 0 ] ; arr [ 0 ] = arr [ i ] ; arr [ i ] = temp ; rebuildHeap ( arr , 0

堆排序(heap sort) 具体解释 及 代码(C++) 本文地址: http://blog.csdn.net/caroline_wendy 堆排序包括两个步骤 : 第一步: 是建立 大顶堆 (从大到小排序)或 小顶堆 (从小到大排序), 从下往上建立 ; 如建堆时, s是从大到小; 第二步: 是依次 交换 堆顶和堆底, 并把 交换后的堆底输出 , 仅仅排列剩余的堆, 从上往下建立 ; 如构造时, s始终是1; 堆排序(Heap Sort) 的 时间复杂度 是 O(nlogn) , 最坏情况 下也是如此. 而 高速排序(Quick Sort) , 若初始记录序列有序, 高速排序将退化为 起泡排序(Bubble Sort) , 时间复杂度是 O(n^2) . 这是堆排序比高速排序的 长处 . 代码: /* * main.cpp * * Created on: 2014.6.12 * Author: Spike */ /*eclipse cdt, gcc 4.8.1*/ #include <iostream> #include <stack> #include <queue> using namespace std; void HeapAdjust (int data[], int length, int k) { int tmp = data[k]; int i=2*k+1;

树形选择排序 (tree selection sort) 具体解释 及 代码(C++) 本文地址: http://blog.csdn.net/caroline_wendy 算法逻辑: 依据节点的大小, 建立树, 输出树的根节点, 并把此重置为最大值, 再重构树. 由于树中保留了一些比較的逻辑, 所以降低了比較次数. 也称 锦标赛排序 , 时间复杂度为O(nlogn) , 由于每一个值(共n个)须要进行树的深度(logn)次比較. 參考<数据结构>(严蔚敏版) 第278-279页. 树形选择排序(tree selection sort) 是堆排序的一个过渡, 并非核心算法. 可是全然依照书上算法, 实现起来极其麻烦, 差点儿没有不论什么人实现过. 须要 记录建树的顺序 , 在重构时, 才干降低比較. 本着娱乐和分享的精神, 应人之邀, 简单的实现了一下. 代码: /* * TreeSelectionSort.cpp * * Created on: 2014.6.11 * Author: Spike */ /*eclipse cdt, gcc 4.8.1*/ #include <iostream> #include <vector> #include <stack> #include <queue> #include <utility> #include <climits> using

一开始感觉这个最难所以放到最后来写。 堆排序 In computer science, heapsort is a comparison-based sorting algorithm.Heapsort can be thought of as an improved selection sort: like selection sort, heapsort divides its input into a sorted and an unsorted region, and it iteratively shrinks the unsorted region by extracting the largest element from it and inserting it into thesorted region. Unlike selection sort, heapsort does not waste time with a linear-time scan of the unsorted region; rather, heap sort maintains the unsorted region in a heap data structure to more quickly find the largest element in each step.[1]