堆排序

目录 1、二叉堆 2、堆排序 3、代码 4、应用场景 1、二叉堆 二叉堆是一种特殊的堆，二叉堆是完全二元树（二叉树）或者是近似完全二元树（二叉树）。二叉堆有两种： 最大堆 和 最小堆 。最大堆： 父结点 的键值总是大于或等于任何一个子 节点 的键值 ；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。 二叉堆一般用 数组 来表示 。如果根节点在数组中的位置是1，第 n 个位置的子节点分别在2 n 和 2 n +1。因此，第1个位置的子节点在2和3，第2个位置的子节点在4和5。以此类推。这种基于1的数组存储方式便于寻找父节点和子节点。 下图中a[1]的子结点就是a[2]和a[3]. 2、堆排序 堆排序就是利用了二叉堆中的 最大堆 。即每个父结点（数组中下标k），都要大于等于它的子结点（数组中下标2k和2k+1）。 堆排序的步骤：1、对于一个无序数组a，先将它构建成 最大堆。 这时候二叉堆的 根节点 就是数组中 最大的那个元素 。 2、然后我们把最大的根节点拿出来放在该数组中末尾。 3、将剩下的元素再构建成 最大堆 ，得到第二大元素，放在第一大元素的前面。 4、不断循环。。。。。。。。。。。。。。。。类似冒泡排序的思想，每次先把最大的元素拿出来放在末尾。 3、代码 public class Heap { public static void sort(double[] a){ /

堆排序 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种 选择排序 ，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。首先简单了解下堆结构。 堆 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。 如下图： 堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。 如下图： 堆 同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子 按层编号 该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是： 大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2] 小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2] ok，了解了这些定义。接下来，我们来看看堆排序的基本思想及基本步骤： 堆排序基本思想及步骤 堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了 步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。 1

public static void myheapSort(int[] array){ for (int i = array.length; i >1; i--) { for (int j = (i-1)/2; j >-1; j--) { myAdjustHeap(array,j,i); } int temp=array[0]; array[0]=array[i-1]; array[i-1]=temp; } } public static void myAdjustHeap(int[] array,int i,int length){ int maxIndex=i; int leftIndex=2*i+1; int regitIndex=leftIndex+1; if(leftIndex>=length){ return; } if(array[maxIndex]<array[leftIndex]){ maxIndex=leftIndex; } if(regitIndex<length && array[maxIndex]<array[regitIndex]){ maxIndex=regitIndex; } if(maxIndex!=i){ int temp=array[i]; array[i]=array[maxIndex]; array[maxIndex]=temp; } }

堆排序使用的是完全二叉树。 即满足r(n)的左孩子是r(2*n+1),右孩子是r(2*n+2)。 堆排序它首先将所有的元素添加到堆上，然后不断移除最大的元素并用最后一个叶子结点替换根节点之后再调整堆到大顶堆或者小顶堆的一种排序方法。底层是使用ArrayList进行存储元素的。 大顶堆的概念：即根节点是最大的(相对于左右孩子结点)元素 例如下面的图 小顶堆的概念：即根节点存储的是最小的(相对于左右孩子结点)元素 例如下面的图 大顶堆的排序示意图如下 示例数组 int[] arr = {3,2,1,4,5} 首先使将数组存储到自己的构造的堆中。 将根节点移除 并将末节点放到根节点的位置 并且重新开始调整堆 调整的过程 如此循环 代码实现 构造堆类 class Heap < E extends Comparable < E > > { private ArrayList < E > list = new ArrayList < > ( ) ; public Heap ( ) { } //从数组添加 public Heap ( E [ ] object ) { for ( int i = 0 ; i < object . length ; i ++ ) { add ( object [ i ] ) ; } } public void add ( E newObject ) { list .

记录一下go实现多重排序的方法和实现堆排序的方式 实现sort接口即可用sort.Sort()方法对对象进行排序,而多重排序呢，我想传入不同排序规则，然后让该对象依次执行不同规则 // 排序规则 type lessFunc func ( p1 , p2 * CurriculumElem ) bool // MultiSorter 多重排序处理器 type MultiSorter struct { changes [ ] * CurriculumElem less [ ] lessFunc } // Sort 排序 func ( ms * MultiSorter ) Sort ( changes [ ] * CurriculumElem ) { ms . changes = changes sort . Sort ( ms ) } // OrderedBy 排序规则 func OrderedBy ( less ... lessFunc ) * MultiSorter { return & MultiSorter { less : less , } } // Len 长度 func ( ms * MultiSorter ) Len ( ) int { return len ( ms . changes ) } // Swap 交换 func ( ms * MultiSorter )

　　在数据结构中， 堆 其实就是一棵 完全二叉树 。我们知道内存中也有一块叫做堆的存储区域，但是这与数据结构中的堆是完全不同的概念。在数据结构中，堆分为 大根堆 和 小根堆 ，大根堆就是根结点的关键字大于等于任一个子节点的关键字，而它的左右子树又分别都是大根堆；小根堆与大根堆恰好相反。在C++的STL中优先队列priority_queue结构就是实现的堆结构。下来自己动手现实一个堆结构，包括heap_init,heap_insert,heap_top等操作。 1、堆的实现 　　因为堆是一棵完全二叉树，所以我们可以用顺序表来实现，而且堆也只能用顺序表。我们用vector。 　　 (1) 堆的初始化 　　 对堆的初始化基本思想：首先初始数组是一个杂乱无章的序列，但是如果堆中只有一个元素heap[0]，那么heap[0]本身是一个堆，然后加入heap[1]调整堆；继续加入heap[2].....直到完成所有元素的调整。 void sift_up(vector<int> &heap,int index){ while((index+1)/2-1 >= 0){ if(heap[(index+1)/2-1] < heap[index]){ swap(&heap[(index+1)/2-1],&heap[index]); index = (index+1)/2-1; }else break; }

20160721 KMP算法学习 主要参照阮老师的博客: 字符串匹配的KMP算法 没有明白的是 部分匹配值表是如何得出的。观看了左程云老师在牛客的视频，大意如下： 搜索字符串为str[]， 搜索字符串中每个字符对应的部分匹配值 存在p[] 中 p[0]=p[1]=0;(默认，由定义可知) p[n]的计算与p[0]-p[n-1]有关。 计算p[n]的过程如下： 此时拍p[0]-p[n-1]均已知。 str[p[n-1]]与str[n-1]相等否？ 相等。则p[n]=p[n-1]+1; 不等。则查看 str{ p[ str[p[n-1]] }与str[n-1]是否相等？ 相等，则p[n]= p[ str[p[n-1]] +1; 不等，则查看 str{ p{ str{ p[ str[p[n-1]] } } } 与str[n-1]是否相等 如此循环下去，直至 str[0]与str[n-1]的对比。 明日手工画图一副说明。 利用JAVA实现，代码如下： 20160723 堆排序 《算法导论》+麻省理工公开课 堆排序的核心在于创建一个最大堆，利用“维护最大推”的方法。 步骤： (注意，这里n从1开始，而不是0) 1.将数组A[1..n]建成最大推，此时最大元素在堆的根节点A[1]，此时n=A.length 2.将A[1]与A[N]交换，则最大元素到了它要去的地方了。此时

问题描述 随机产生一个长度为10的数组a，其中a[i]∈[0,100)，使用堆排序进行从小到大的排序。 输入描述 本题无输入 输出描述 输出两行数据，其中第一行为未经排序的随机数组，第二行为排序后的数组 参考代码 # include <stdio.h> # include <stdlib.h> # include <time.h> void swap ( int a [ ] , int p , int r ) { int temp ; temp = a [ p ] ; a [ p ] = a [ r ] ; a [ r ] = temp ; } void maxheap ( int a [ ] , int start , int end ) { //堆化，形成大顶堆，将父节点与子节点进行比较，将大的浮上来，小的沉下去 int left = 2 * start + 1 , right = 2 * start + 2 , max = left ; if ( left > end ) return ; else if ( right > end ) max = left ; else if ( a [ right ] > a [ left ] ) max = right ; if ( a [ start ] >= a [ max ] ) return ; else { swap ( a

目录 堆的概念 要点 算法分析   堆排序算法的总体情况   时间复杂度   算法稳定性 完整参考代码   JAVA版本 参考资料 相关阅读   说明 堆的概念 在介绍堆排序之前，首先需要说明一下，堆是个什么玩意儿。 堆 是一棵 顺序存储 的 完全二叉树 。 其中每个结点的关键字都 不大于 其孩子结点的关键字，这样的堆称为 小根堆 。 其中每个结点的关键字都 不小于 其孩子结点的关键字，这样的堆称为 大根堆 。 举例来说，对于n个元素的序列{R0, R1, ... , Rn}当且仅当满足下列关系之一时，称之为堆： (1) Ri <= R2i+1 且 Ri <= R2i+2 ( 小根堆) (2) Ri >= R2i+1 且 Ri >= R2i+2 ( 大根堆) 其中i=1,2,…,n/2向下取整; 如上图所示，序列R{3, 8, 15, 31, 25}是一个典型的小根堆。 堆中有两个父结点，元素3和元素8。 元素3在数组中以R[0]表示，它的左孩子结点是R[1]，右孩子结点是R[2]。 元素8在数组中以R[1]表示，它的左孩子结点是R[3]，右孩子结点是R[4]，它的父结点是R[0]。可以看出，它们 满足以下规律 ： 设当前元素在数组中以 R[i] 表示，那么， (1) 它的 左孩子结点 是： R[2*i+1] ; (2) 它的 右孩子结点 是： R[2*i+2] ; (3) 它的

import java.util.Arrays; public class Test { private static void swap(int[] arr, int a, int b) { int tmp = arr[a]; arr[a] = arr[b]; arr[b] = tmp; } private static int parent(int i) { return (i - 1) >> 1; } private static int left(int i) { return (i << 1) + 1; } private static int right(int i) { return (i << 1) + 2; } private static void insert(int[] arr, int i) { int data = arr[i]; int parent; while (i != 0) { parent = parent(i); if (arr[parent] < data) { arr[i] = arr[parent]; i = parent; } else { break; } } arr[i] = data; } private static void heapify(int[] arr, int length) { int i = 0, left,