堆排序

利用数组和二叉树的相互转化，可以利用树结构的特点，进行排序 测试了速度。因为要经常交换。所以速度和希尔排序比慢了2倍 package a; import sun.security.util.Length; import java.util.Arrays; public class HeapSortDemo { public static void main(String[] args) { int var = 8000000; int[] arr = new int[var]; for (int i = 0; i < arr.length; i++) { arr[i] = (int)(Math.random()*800000000); } long sta = System.currentTimeMillis(); // int[] arr = {4, 6, 8,5, 9,-10,100,87,93,1986756,-1000}; heapSort(arr); long end = System.currentTimeMillis(); System.out.println(end-sta); // System.out.println(Arrays.toString(arr)); } private static void heapSort(int[] arr) { System

先上代码 #include <stdio.h> #include <stdlib.h> void printf_array(int a[], int length) { int i = 0; printf("array element:\n"); for (i = 0; i < length; i++) { printf("%d\t",a[i]); } printf("\n"); } void perDown(int a[], int parent, int length) { int temp = a[parent]; int child = 2 * parent + 1; while (child < length) { if(child + 1 < length && a[child+1] > a[child]) {//获取较大的儿子节点 child++; } if(a[child] > temp) { a[parent] = a[child]; parent = child; child = parent * 2 + 1; } else {//跳出循环 //a[parent] = temp;//为什么放在这里不好使呢？ //怀疑编译器进行了内部优化导致此问题，放在这里和放在while体外，原则上是一样的意思 break; } } a[parent] = temp;

排序是将一串数据按照其某个或者某些关键字的大小进行递增或递减排列的操作我，通常指的排序是升序，排序方式是原地排序 下面介绍下堆排序 堆排序 原理： 堆排序也是选择出无序区间的最大值/最小值，将其放在无序区间的后面 但是是通过遍历获取最大值/最小值，是通过建堆的方式来获取无序区间中的最大值/最小值 将堆顶元素和最后一个元素交换，然后对无序区间进行向下调整 重复交换直至排序结束 排升序需要建大堆 排降序需要建小堆 插入排序是一个不稳定的排序 实现方式 1.排升序，建大堆 public static void heapSort(int[] array) { //将数组建成大堆 heapify(array); for(int i = 0; i < array.length - 1; i++) { //交换前 //无序区间[0, array.length - i); //有序区间[array.length - i, array.length); swap(array, 0, array.length - 1 - i); //交换后 //无序区间[0, array.length - i - 1) //有序区间[array.length - i - 1, array.length) //无序区间的长度 array.length - i - 1 siftDown(array, array

1. heapq堆排序算法 堆(heap)是一个树形数据结构，其中子节点与父节点有一种有序关系。二叉堆(binary heap)可以使用一个有组织的列表或数组表示，其中元素N的子元素位于2*N+1和2*N+2(索引从0开始)。这种布局允许原地重新组织堆，从而不必再添加或删除元素时重新分配大量内存。 最大堆(max-heap)确保父节点大于或等于其两个子节点。最小堆(min-heap)要求父节点小于或等于其子节点。Python的heapq模块实现了一个最小堆。 1.1 创建堆 创建堆有两种基本方式：heappush()和heapify()。 import heapq import math from io import StringIO data = [19, 9, 4, 10, 11] def show_tree(tree, total_width=36, fill=' '): """Pretty-print a tree.""" output = StringIO() last_row = -1 for i, n in enumerate(tree): if i: row = int(math.floor(math.log(i + 1, 2))) else: row = 0 if row != last_row: output.write('\n') columns = 2 **

算法原理 堆排序定义： n 个 序列 Al， A2，…， An 称为 堆， 有 下面 两种 不同 类型 的 堆。 小 根 堆： 所有 子 结点 都 大于 其父 节点， 即 Ai ≤ A2i 且 Ai ≤ A2i+ 1。 大 根 堆： 所有 子 结点 都 小于 其父 节点， 即 Ai ≥ A2i 且 Ai ≥ A2i+ 1。 （数组是从0开始计算的，为了平衡考虑，使用 A2i + 1 和 A2i + 2） 若将 此 序列 所 存储 的 向量 A[ 1... n] 看 为一 棵 完全 二 叉 树 的 存储 结构， 则 堆 实质上 是 满足 如下 性质 的 完全 二 叉 树： 树 中 任一 非 叶 结点 的 关键字 均不 大于（ 或不 小于） 其 左、 右 子 节点（ 若 存在） 的 关键字。 因此 堆 排序（ HeapSort） 是 树 形 选择 排序。 在 排序 过程中， 将 R[ l... n] 看成 一 棵 完全 二 叉 树 的 顺序 存储 结构， 利用 完全 二 叉 树 中 双亲 结点 和 孩子 结点 之间 的 内在 关系， 在当 前 无序 区 中 选择 关键字 最大（ 或 最小） 的 记录。 用 大 根 堆 排序 的 基本 思想： （1） 先 将 初始 A[ 1... n] 建成 一 个大 根 堆， 此 堆 为 初始 的 无序 区。 （2） 再将 关键字 最大 的 记录 A[

转自 https://www.cnblogs.com/shen-hua/p/5424059.html a) 原理：每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。也就是：每一趟在 n-i+1(i=1 ， 2 ， …n-1) 个记录中选取关键字最小的记录作为有序序列中第 i 个记录。基于此思想的算法主要有 简单选择排序 、树型选择排序和 堆排序 。（这里只介绍常用的简单选择排序） b) 简单选择排序的基本思想：给定数组：int[] arr={ 里面 n 个数据 } ；第 1 趟排序，在待排序数据arr[1]~arr[n] 中选出最小的数据，将它与arrr[1] 交换；第 2 趟，在待排序数据arr[2]~arr[n] 中选出最小的数据，将它与 r[2] 交换；以此类推，第 i 趟在待排序数据arr[i]~arr[n] 中选出最小的数据，将它与 r[i] 交换，直到全部排序完成。 c) 举例：数组 int[] arr={5,2,8,4,9,1}; ------------------------------------------------------- 第一趟排序： 原始数据： 5 2 8 4 9 1 最小数据 1 ，把 1 放在首位，也就是 1 和 5 互换位置， 排序结果： 1 2 8 4 9 5 --------------------

Java中的经典算法之选择排序（SelectionSort） a) 原理：每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。也就是：每一趟在 n-i+1(i=1 ， 2 ， …n-1) 个记录中选取关键字最小的记录作为有序序列中第 i 个记录。基于此思想的算法主要有 简单选择排序 、树型选择排序和 堆排序 。 （这里只介绍常用的简单选择排序） b) 简单选择排序的基本思想：给定数组：int[] arr={ 里面 n 个数据 } ； 第 1 趟 排序，在待排序数据arr[1]~arr[n] 中选出最小的 数据，将它与arrr[1] 交换 ；第 2 趟，在待排序 数据arr[2]~arr[n] 中选出最小的 数据，将它与 r[2] 交换 ；以此类推，第 i 趟在待排序 数据arr[i]~arr[n] 中选出最小的 数据，将它与 r[i] 交换 ，直到全部排序完成。 c) 举例：数组 int[] arr={5,2,8,4,9,1}; ------------------------------------------------------- 第一趟排序： 原始数据： 5 2 8 4 9 1 最小数据 1 ，把 1 放在首位，也就是 1 和 5 互换位置， 排序结果： 1 2 8 4 9 5 -----------------------------

在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。 一般来说外排序分为两个步骤：预处理和合并排序。首先，根据可用内存的大小，将外存上含有n个纪录的文件分成若干长度为t的子文件（或段）；其次，利用内部排序的方法，对每个子文件的t个纪录进行内部排序。这些经过排序的子文件（段）通常称为顺串(run)，顺串生成后即将其写入外存。这样在外存上就得到了m个顺串（m=[n/t]）。最后，对这些顺串进行归并，使顺串的长度逐渐增大，直到所有的待排序的几率成为一个顺串为止。 内排序可以分为以下几类： (1)、插入排序：直接插入排序、折半插入排序、希尔排序。 (2)、选择排序：简单选择排序、堆排序。 (3)、交换排序：冒泡排序、快速排序。 外排序可以分为一下几类（既使用内部存储也使用外部存储，内存不够时建议使用）： (4)、归并排序 (5)、基数排序 稳定性：就是能保证排序前两个相等的数据其在序列中的先后位置顺序与排序后它们两个先后位置顺序相同。再简单具体一点，如果A i == A j，Ai 原来在 Aj 位置前，排序后 Ai 仍然是在 Aj 位置前。 不稳定：简单选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法 稳定：冒泡排序、直接插入排序、折半插入排序，归并排序和基数排序都是稳定的排序算法。 平均时间复杂度 O(n^2):直接插入排序，简单选择排序

堆排序属于不稳定排序，时间复杂度为O(nlogn)，是利用堆这种数据结构设计的排序算法，是一种选择排序 堆是一个近似完全二叉树的结构，每个节点值都大于或等于左右节点为大顶堆，小于等于为小顶堆 升序排序大顶堆，降序排序小顶堆 思想和方法：将原始数据构 n 造成大顶堆，此时最大值为根节点，然后与末尾的原始数据交换，最后即为最大值，然后剩下的 n - 1 个数据继续构建大顶堆，重复上面的步骤，最后一个数直接置于第一位，至此升序排序完成 import java.util.Arrays; public class HeapSort { public static void main(String[] args) { int arr[] = {4, 6, 8, 5, 9}; heapSort(arr); } public static void heapSort(int[] arr) { int temp; for (int i = arr.length / 2 - 1; i >= 0; i--) { adjustHeap(arr, i, arr.length); } for (int j = arr.length - 1; j > 0; j--) { temp = arr[j]; arr[j] = arr[0]; arr[0] = temp; adjustHeap(arr, 0, j); }

选择排序 选择排序比较好理解，好像是在一堆大小不一的球中进行选择（以从小到大，先选最小球为例）： 　　1. 选择一个基准球 　　2. 将基准球和余下的球进行一一比较，如果比基准球小，则进行交换 　　3. 第一轮过后获得最小的球 　　4. 在挑一个基准球，执行相同的动作得到次小的球 　　5. 继续执行4，直到排序好 时间复杂度：O(n^2). 需要进行的比较次数为第一轮 n-1，n-2....1, 总的比较次数为 n*(n-1)/2 直接上代码： def selectedSort(myList): #获取list的长度 length = len(myList) #一共进行多少轮比较 for i in range(0,length-1): #默认设置最小值得index为当前值 smallest = i #用当先最小index的值分别与后面的值进行比较,以便获取最小index for j in range(i+1,length): #如果找到比当前值小的index,则进行两值交换 if myList[j]<myList[smallest]: tmp = myList[j] myList[j] = myList[smallest] myList[smallest]=tmp #打印每一轮比较好的列表 print("Round ",i,": ",myList) myList = [1,4,5