Code666 (代码贴、代码片段)

[Java] java堆排序算法 →→→→→进入此内容的聊天室

来自 , 2020-08-01, 写在 Java, 查看 108 次.
URL http://www.code666.cn/view/25ddc0f8
  1. /**
  2.  * 选择排序之堆排序：
  3.  *
  4.  * 1. 基本思想： 堆排序是一树形选择排序，在排序过程中，将R[1..N]看成是一颗完全二叉树的顺序存储结构，
  5.  * 利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。
  6.  *
  7.  * 2. 堆的定义: N个元素的序列K1,K2,K3,...,Kn.称为堆，当且仅当该序列满足特性： Ki≤K2i Ki ≤K2i+1(1≤ I≤[N/2])
  8.  * 堆实质上是满足如下性质的完全二叉树：树中任一非叶子结点的关键字均大于等于其孩子结点的关键字。例如序列10,15,56,25,30,70就是一个堆，
  9.  * 它对应的完全二叉树如上图所示。这种堆中根结点（称为堆顶）的关键字最小，我们把它称为小根堆。
  10.  * 反之，若完全二叉树中任一非叶子结点的关键字均大于等于其孩子的关键字，则称之为大根堆。
  11.  *
  12.  * 3.排序过程： 堆排序正是利用小根堆（或大根堆）来选取当前无序区中关键字小（或最大）的记录实现排序的。我们不妨利用大根堆来排序。每一趟排序的基本操作是：
  13.  * 将当前无序区调整为一个大根堆
  14.  * ，选取关键字最大的堆顶记录，将它和无序区中的最后一个记录交换。这样，正好和直接选择排序相反，有序区是在原记录区的尾部形成并逐步向前扩大到整个记录区。
  15.  */
  16. public class HeapSort {
  17.  
  18.         /**
  19.          * 排序算法的实现，对数组中指定的元素进行排序
  20.          *
  21.          * @param array
  22.          *            待排序的数组
  23.          * @param from
  24.          *            从哪里开始排序
  25.          * @param end
  26.          *            排到哪里
  27.          * @param c
  28.          *            比较器
  29.          */
  30.         public void sort(Integer[] array, int from, int end) {
  31.                 // 创建初始堆
  32.                 initialHeap(array, from, end);
  33.  
  34.                 /*
  35.                  * 对初始堆进行循环，且从最后一个节点开始，直接树只有两个节点止 每轮循环后丢弃最后一个叶子节点，再看作一个新的树
  36.                  */
  37.                 for (int i = end - from + 1; i >= 2; i--) {
  38.                         // 根节点与最后一个叶子节点交换位置，即数组中的第一个元素与最后一个元素互换
  39.                         swap(array, from, i - 1);
  40.                         // 交换后需要重新调整堆
  41.                         adjustNote(array, 1, i - 1);
  42.                 }
  43.  
  44.         }
  45.  
  46.         /**
  47.          * 初始化堆 比如原序列为：7,2,4,3,12,1,9,6,8,5,10,11 则初始堆为：1,2,4,3,5,7,9,6,8,12,10,11
  48.          *
  49.          * @param arr
  50.          *            排序数组
  51.          * @param from
  52.          *            从哪
  53.          * @param end
  54.          *            到哪
  55.          * @param c
  56.          *            比较器
  57.          */
  58.         private void initialHeap(Integer[] arr, int from, int end) {
  59.                 int lastBranchIndex = (end - from + 1) / 2;// 最后一个非叶子节点
  60.                 // 对所有的非叶子节点进行循环 ，且从最一个非叶子节点开始
  61.                 for (int i = lastBranchIndex; i >= 1; i--) {
  62.                         adjustNote(arr, i, end - from + 1);
  63.                 }
  64.         }
  65.  
  66.         /**
  67.          * 调整节点顺序，从父、左右子节点三个节点中选择一个最大节点与父节点转换
  68.          *
  69.          * @param arr
  70.          *            待排序数组
  71.          * @param parentNodeIndex
  72.          *            要调整的节点，与它的子节点一起进行调整
  73.          * @param len
  74.          *            树的节点数
  75.          * @param c
  76.          *            比较器
  77.          */
  78.         private void adjustNote(Integer[] arr, int parentNodeIndex, int len) {
  79.                 int minNodeIndex = parentNodeIndex;
  80.                 // 如果有左子树，i * 2为左子节点索引
  81.                 if (parentNodeIndex * 2 <= len) {
  82.                         // 如果父节点小于左子树时
  83.                         if ((arr[parentNodeIndex - 1]
  84.                                         .compareTo(arr[parentNodeIndex * 2 - 1])) < 0) {
  85.                                 minNodeIndex = parentNodeIndex * 2;// 记录最大索引为左子节点索引
  86.                         }
  87.  
  88.                         // 只有在有或子树的前提下才可能有右子树，再进一步断判是否有右子树
  89.                         if (parentNodeIndex * 2 + 1 <= len) {
  90.                                 // 如果右子树比最大节点更大
  91.                                 if ((arr[minNodeIndex - 1]
  92.                                                 .compareTo(arr[(parentNodeIndex * 2 + 1) - 1])) < 0) {
  93.                                         minNodeIndex = parentNodeIndex * 2 + 1;// 记录最大索引为右子节点索引
  94.                                 }
  95.                         }
  96.                 }
  97.  
  98.                 // 如果在父节点、左、右子节点三都中，最大节点不是父节点时需交换，把最大的与父节点交换，创建大顶堆
  99.                 if (minNodeIndex != parentNodeIndex) {
  100.                         swap(arr, parentNodeIndex - 1, minNodeIndex - 1);
  101.                         // 交换后可能需要重建堆，原父节点可能需要继续下沉
  102.                         if (minNodeIndex * 2 <= len) {// 是否有子节点，注，只需判断是否有左子树即可知道
  103.                                 adjustNote(arr, minNodeIndex, len);
  104.                         }
  105.                 }
  106.         }
  107.  
  108.         /**
  109.          * 交换数组中的两个元素的位置
  110.          *
  111.          * @param array
  112.          *            待交换的数组
  113.          * @param i
  114.          *            第一个元素
  115.          * @param j
  116.          *            第二个元素
  117.          */
  118.         public void swap(Integer[] array, int i, int j) {
  119.                 if (i != j) {// 只有不是同一位置时才需交换
  120.                         Integer tmp = array[i];
  121.                         array[i] = array[j];
  122.                         array[j] = tmp;
  123.                 }
  124.         }
  125.  
  126.         /**
  127.          * 测试
  128.          *
  129.          * @param args
  130.          */
  131.         public static void main(String[] args) {
  132.                 Integer[] intgArr = { 5, 9, 1, 4, 2, 6, 3, 8, 0, 7, 0, -7, -1, 34 };
  133.                 HeapSort heapsort = new HeapSort();
  134.                 heapsort.sort(intgArr, 0, intgArr.length - 1);
  135.                 for (Integer intObj : intgArr) {
  136.                         System.out.print(intObj + " ");
  137.                 }
  138.         }
  139.  
  140. }
  141.  

回复 "java堆排序算法"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666