Java heap sorting algorithm code

From , 5 Years ago, written in Java, viewed 162 times.
URL https://pastebin.vip/view/a1cb608a
  1. package com.arithmetic;
  2.  
  3. //堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构,
  4. //并同时满足堆性质:即子结点的键值或索引总是小于(或者大于)它的父节点。
  5. public class Test_wzs013 {
  6.         private static int[] sort = new int[] { 10, 3, 5, 7, 9, 1, 4, 2, 6, 8 };
  7.  
  8.         public static void main(String[] args) {
  9.                 buildMaxHeapify(sort);
  10.                 heapSort(sort);
  11.                 print(sort);
  12.         }
  13.  
  14.         private static void buildMaxHeapify(int[] data) {
  15.                 // 没有子节点的才需要创建最大堆,从最后一个的父节点开始
  16.                 int startIndex = getParentIndex(data.length - 1);
  17.                 // 从尾端开始创建最大堆,每次都是正确的堆
  18.                 for (int i = startIndex; i >= 0; i--) {
  19.                         maxHeapify(data, data.length, i);
  20.                 }
  21.         }
  22.  
  23.         /**
  24.          * 创建最大堆
  25.          *
  26.          * @param data
  27.          * @param heapSize
  28.          *            需要创建最大堆的大小,一般在sort的时候用到,因为最多值放在末尾,末尾就不再归入最大堆了
  29.          * @param index
  30.          *            当前需要创建最大堆的位置
  31.          */
  32.         private static void maxHeapify(int[] data, int heapSize, int index) {
  33.                 // 当前点与左右子节点比较
  34.                 int left = getChildLeftIndex(index);
  35.                 int right = getChildRightIndex(index);
  36.  
  37.                 int largest = index;
  38.                 if (left < heapSize && data[index] < data[left]) {
  39.                         largest = left;
  40.                 }
  41.                 if (right < heapSize && data[largest] < data[right]) {
  42.                         largest = right;
  43.                 }
  44.                 // 得到最大值后可能需要交换,如果交换了,其子节点可能就不是最大堆了,需要重新调整
  45.                 if (largest != index) {
  46.                         int temp = data[index];
  47.                         data[index] = data[largest];
  48.                         data[largest] = temp;
  49.                         maxHeapify(data, heapSize, largest);
  50.                 }
  51.         }
  52.  
  53.         /**
  54.          * 排序,最大值放在末尾,data虽然是最大堆,在排序后就成了递增的
  55.          *
  56.          * @param data
  57.          */
  58.         private static void heapSort(int[] data) {
  59.                 // 末尾与头交换,交换后调整最大堆
  60.                 for (int i = data.length - 1; i > 0; i--) {
  61.                         int temp = data[0];
  62.                         data[0] = data[i];
  63.                         data[i] = temp;
  64.                         maxHeapify(data, i, 0);
  65.                 }
  66.         }
  67.  
  68.         /**
  69.          * 父节点位置
  70.          *
  71.          * @param current
  72.          * @return
  73.          */
  74.         private static int getParentIndex(int current) {
  75.                 return (current - 1) >> 1;
  76.         }
  77.  
  78.         /**
  79.          * 左子节点position 注意括号,加法优先级更高
  80.          *
  81.          * @param current
  82.          * @return
  83.          */
  84.         private static int getChildLeftIndex(int current) {
  85.                 return (current << 1) + 1;
  86.         }
  87.  
  88.         /**
  89.          * 右子节点position
  90.          *
  91.          * @param current
  92.          * @return
  93.          */
  94.         private static int getChildRightIndex(int current) {
  95.                 return (current << 1) + 2;
  96.         }
  97.  
  98.         private static void print(int[] data) {
  99.                 int pre = -2;
  100.                 for (int i = 0; i < data.length; i++) {
  101.                         if (pre < (int) getLog(i + 1)) {
  102.                                 pre = (int) getLog(i + 1);
  103.                                 System.out.println();
  104.                         }
  105.                         System.out.print(data[i] + " |");
  106.                 }
  107.         }
  108.  
  109.         /**
  110.          * 以2为底的对数
  111.          *
  112.          * @param param
  113.          * @return
  114.          */
  115.         private static double getLog(double param) {
  116.                 return Math.log(param) / Math.log(2);
  117.         }
  118. }
  119.  
  120. //java/5833

Reply to "Java heap sorting algorithm code"

Here you can reply to the paste above

captcha

https://burned.cc - Burn After Reading Website