堆排序

堆排序及其优化 java https://www.cnblogs.com/CherishFX/p/4643940.html 堆排序，是利用堆结构进行排序，一般是利用最大堆，即根节点比左右两个子树的节点都大。 堆排序是一种树形选择排序方法，它的特点是：在排序的过程中，将array[0，…，n-1]看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和孩子节点之间的内在关系，在当前无序区中选择关键字最大（最小）的元素。 1、什么是堆？ 堆是有如下特点的二叉树： 1）它是完全二叉树。即除了树的最后一层节点不需要是满的，其他的每层从左到右完全是满的。 2）它常常是数组实现的。 3）堆中的每个节点都必须满足堆的条件。 每个节点的关键字都不大于其子节点的关键字，这种堆称为小根堆。 每个节点的关键字都不小于其子节点的关键字，这种堆称为大堆根。本文采用此结构演示 综上所述，堆是一棵顺序存储的按照特定规则的完全二叉树。 数组的节点的索引为index，则： 1）它的父节点的下标为：（index-1）/2 2）它的左子节点的下标为：2 index + 1 3）它的右子节点的下标为：2 index + 2 2、堆与二叉搜索树的不同： 堆和二叉搜索树相比是弱序的。在二叉搜索树中，所有节点的关键字大于其左子树的关键字，小于其右子树的关键字。但是在堆中，每个节点都不小于其子节点，即从

基本思想 排序思想 用最大堆排序的基本思想： 先将初始文件R[1..n]建成一个最大堆，此堆为初始的无序堆。 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得 到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key。 由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。 然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由 此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系 R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。 算法实现 最大堆排序算法，Java实现，代码如下所示： public abstract class Sorter { public abstract void sort ( int [] array); } public class HeapSorter extends Sorter { public void sort ( int [] array) { heapSort(array); } private void heapSort ( int [] array) { int temp; // 用于交换的暂存单元

堆排序是利用 完全二叉树 的结构思想，对 线性数组 进行排序的。 最大堆进行升序排序的基本思想： ① 初始化堆：将数列a[0...n-1]构造成最大堆。 ② 交换数据：将a[0]和a[n-1]交换，使a[n-1]是a[0...n-1]中的最大值；然后将a[0...n-2]重新调整为最大堆。 接着，将a[0]和a[n-2]交换，使a[n-2]是a[0...n-2]中的最大值；然后将a[0...n-3]重新调整为最大值。 依次类推，直到整个数列都是有序的。 在第一个元素的索引为 0 的情形中： 性质一：索引为i的左孩子的索引是 (2*i+1); 性质二：索引为i的左孩子的索引是 (2*i+2); 性质三：索引为i的父结点的索引是 floor((i-1)/2); 堆分为大顶堆和小顶堆， 满足Key[i]>=Key[2i+1]&&key>=key[2i+2]称为大顶堆， 满足 Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]称为小顶堆 import java.util.Arrays; /** * 堆与堆排序 * @author mine_song 2017.04.05 */ public class HeapSort { public static void main(String[] args) { int arr[] = { 4, 5, 2, 1, 8, 10,

堆排序 堆排序思想 Java代码 总结 堆排序思想 思想:(堆排序的思想比较简单，但是涉及到的知识点比较多，所以实现起来还是不容易的，以从小到大排序为例) 1.将待排序数组初始化为大顶堆 2.将大顶堆根元素和最后一个节点交换 3.将除最后一个元素外的其他元素继续调整为大顶堆 4.重复2、3操作直到没有元素可以调整为止 因为每一次都将当前最大元素根元素与最后一个元素交换调整到最后，所以此时数组已经按照从小到大的顺序排列好了 Java代码 package cn.com.mp.sort; public class HeapSortDemo { public static void main(String[] args) { // int[] array={56,2,8,5,9,46,53,7,1}; int [] array = { 12 , 56 , 8 , 6 , 50 , 45 , 2 , 13 , 89 , 21 }; int len = array .length; sort( array , len); /* 遍历排序后的数组，输出结果 */ for ( int i = 0 ; i < len; i++) { System.out.print( array [i] + " " ); } } /* 堆排序 */ public static void sort( int []

核心点：堆调整 如何形成最小堆/最大堆，那就先需要了解最小堆/最大堆的概念。 最大堆（大根堆）要求根节点的关键字既大于或等于左子树的关键字值，又大于或等于右子树的关键字值，且要求是完全二叉树。 调整过程： 保存当前节点值，当前节点为父节点； 通过父节点找到子节点； 如果子节点不存在，退出；否则，判断左右孩子中的大值节点，记录该节点； 如果父节点大于等于该大值节点，退出；否则，将大值节点与其父节点值交换，并将该子节点设为父节点，找到该节点的子节点；跳至3继续执行。 import java.util.Arrays; public class HeapSort { public static void main (String[] args) { int [] s = new int [] { 5 , 1 , 6 , 7 , 3 , 2 , 4 , 9 , 10 , 8 }; HeapSort hs = new HeapSort(); hs.sort(s); } public void sort ( int [] s) { for ( int i = s.length / 2 - 1 ; i >= 0 ; i--) { adjustHeap(s, i, s.length); // 初始建立最大堆 } System.out.println(Arrays.toString(s)); for

一.简介 上一篇讲了 快速排序 ，这一篇来讲讲堆排序。堆可以借助借助完全二叉树来理解，数值排列按照广度优先算法输出的顺序给出。堆排序分按大堆排序和小堆排序。堆排序就是一趟排序完，最大的值在最前面；而按小堆排序就是一趟排序完，最小的值在最前面。 排序过程为使记录序列按关键字非递减有序排序，则在堆排序的算法中，先建一个“大顶堆”，即先选得一个关键字为最大的记录并与序列中最后一个记录交换，然后对序列的前n-1记录进行筛选，重新将它调整为一个“大顶堆”，如此反复直至排序结束。 排序过程: 由于事先选用的数据结构为数组，所以给下数组的排序过程 假设数组数值为 5,2,6,3,7,9,10,4,8 那么它在第一次大堆排序之后的结果为 10,8,9,4,7,5,6,2,3 二.代码实现 public class HeapSort { public static void main(String[] args) { int a[] = { 5 , 2 , 6 , 3 , 7 , 9 , 10 , 4 , 8 }; heapSort (a); print (a); } /** * 打印数组 * * @param a */ private static void print( int [] a) { for ( int i = 0 ; i < a. length ; i++) { System.

堆 是具有以下性质的完全二叉树： 每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆； 每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。 堆排序的基本思想是： 将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。一般升序采用大顶堆，降序采用小顶堆。 核心代码： 　 public static void heapSort ( int [] arr) { //初始化调整堆 for ( int i = arr.length / 2 ; i >= 0 ; i--) { adjustHeap(arr,i,arr.length); } for ( int i = arr.length- 1 ; i > 0 ; i--) { swap(arr, 0 ,i); adjustHeap(arr, 0 ,i); } } /** * 调整堆 * @param arr * @param parent * @param length 未排序的序列长度 */ private static void adjustHeap ( int [] arr, int parent, int length) { int temp = arr

堆排序 定义 堆是一种 特殊的树形数据结构 ，其每个节点都有一个值，通常提到的堆都是指一颗完全二叉树，根结点的值小于（或大于）两个子节点的值，同时，根节点的两个子树也分别是一个堆。 实现思路 1、将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。 2、将它与堆数组的 末尾 元素交换，此时末尾元素就是 最大值 ； 3、然后将剩余的 n-1 个序列重新构造成一个堆，这样就会得到 n 个元素中次大的值。 4、将它与堆数组的 次末尾 元素交换，此时次末尾元素就是 次最大值 ； 5、如此反复执行，便能得到一个有序序列了。 代码实现 import java.util.Arrays; public class HeapSort { /** * 堆调整 * @param a 待排序的序列 * @param i 待调整的节点 * @param len 待调整序列长度 */ public static void adjustHeap(int[] a, int i, int len) { //初始需要被调整的节点 int temp=a[i]; for (int j = 2 * i; j < len; j *= 2) { //找出孩子节点中值大的节点 if (j < len && a[j] < a[j + 1]) ++j; //如果孩子节点比根节点小则结束循环 if (temp >=

选择排序和堆排序 选择排序 堆排序 选择排序 选择排序就是在一个元素集合中 选择一个最大的数据元素 如果 它不是最后一个元素 ，则将它 与这组元素的最后一个交换 ； 接着 在剩余的集合元素中重复步骤 ，直到 集合剩余1个元素 public static void SelectSort(int arr[]){ int i,j; for(i = arr.length;i > 0;i--){ // i 表示数组的最后一个元素的位置， //当把最大的元素放在该位置后，则 i--，往前走一步，即在剩下的元素中重复步骤 int max = 0; // 表示最大元素 for(j = 0;j < i;j++){ 从第一个开始遍历选择出最大的元素 if(arr[j]>arr[max]){ max = j; } } // Swap(arr[max],arr[i-1]); //交换最大的元素，使其放在最后面 int temp = arr[max]; arr[max] = arr[i-1]; arr[i-1] = temp; } } 两边同时开始，往中间找； 找到最小的放在左边，找到最大的放在右边 public static void SelectSort(int arr[]){ int left = 0,right = arr.length-1; while(left<right){ /

（1）小顶堆 假设有 n 个元素的序列， k0-kn, 如果将这组数据排成一棵完全二叉树，则此树的特点是：树中所有节点的值都小于其左右节点的值，此树的根必然是最小的； （2）大顶堆 假设有 n 个元素的序列， k0-kn, 如果将这组数据排成一棵完全二叉树，则此树的特点是：树中所有节点的值都大于其左右节点的值，此树的根必然是最大的； 堆排序算法思想： 大顶堆的根节点一定是这组数据中最大的数，如果需要对一组数进行排序，则需要先将这组数据建成大（小）顶堆，然后接可以选择出这组数据中最大（小）的数。 第一趟先将 0 — n-1 处的所有数据建成大顶堆，就可以选择出这组数据中最大的数； 第二趟将 0-n-2 处的所有数据建成大顶堆，就可以选择出这组数据中最大的数； 。。。。。。。 第 k 趟将 0-n-k 处的所有数据建成大顶堆，就可以选择出这组数据中最大的数； 堆排序的步骤分为两步： （1）建堆； 从最后一个非叶子节点开始，比较该节点和其孩子节点中加大的那个节点的值， 如果较大的那个子节点的值大于父节点，则交换父节点和该子节点的值； 向前逐步调整直到根节点，保证每个节点的值都大于等于其左右子节点的值，一次建 堆完成 （2）把堆的根节点和当前数组的最后一个节点交换； 对于包含 n 个元素的数组而言，需要 n-1 次建堆，每次建堆的作用就是选出该堆的最大（小）值； public class