Java HeapSort

/**

 * <html>

 * <body>

 *  <P> Copyright 1994-2018 JasonInternational </p>

 *  <p> All rights reserved.</p>

 *  <p> Created on 2018年4月10日 </p>

 *  <p> Created by Jason</p>

 *  </body>

 * </html>

 */

package cn.ucaner.algorithm.sorts;

/**

 * Heapsort is a comparison-based sorting algorithm to create a sorted array (or

 * list), and is part of the selection sort family. Although somewhat slower in

 * practice on most machines than a well-implemented quicksort, it has the

 * advantage of a more favorable worst-case O(n log n) runtime.

 * <p>

 * Family: Selection.<br>

 * Space: In-place.<br>

 * Stable: False.<br>

 * <p>

 * Average case = O(n*log n)<br>

 * Worst case = O(n*log n)<br>

 * Best case = O(n*log n)<br>

 * <p>

 * @see <a href="https://en.wikipedia.org/wiki/Heap_sort">Heap Sort (Wikipedia)</a>

 * <br>

 * @author Justin Wetherell <phishman3579@gmail.com>

 */

public class HeapSort<T extends Comparable<T>> {

    private HeapSort() { }

    public static <T extends Comparable<T>> T[] sort(T[] unsorted) {

        createHeap(unsorted);

        sortHeap(unsorted);

        return unsorted;

    }

    private static <T extends Comparable<T>> void sortHeap(T[] unsorted) {

        int length = unsorted.length;

        for (int index = length - 1; index > 0; index--) {

            swap(0, index, unsorted); // swap root with the last heap element

            int i = 0; // index of the element being moved down the tree

            while (true) {

                int left = (i * 2) + 1;

                if (left >= index) // node has no left child

                    break;

                int right = left + 1;

                if (right >= index) { // node has a left child, but no right child

                    if (unsorted[left].compareTo(unsorted[i]) > 0)

                        swap(left, i, unsorted); // if left child is greater than node

                    break;

                }

                T ithElement = unsorted[i];

                T leftElement = unsorted[left];

                T rightElement = unsorted[right];

                if (ithElement.compareTo(leftElement) < 0) { // (left > i)

                    if (unsorted[left].compareTo(rightElement) > 0) { // (left > right)

                        swap(left, i, unsorted);

                        i = left;

                        continue;

                    }

                    // (left > i)

                    swap(right, i, unsorted);

                    i = right;

                    continue;

                }

                // (i > left)

                if (rightElement.compareTo(ithElement) > 0) {

                    swap(right, i, unsorted);

                    i = right;

                    continue;

                }

                // (n > left) & (n > right)

                break;

            }

        }

    }

    private static <T extends Comparable<T>> void createHeap(T[] unsorted) {

        // Creates a max heap

        int size = 0;

        int length = unsorted.length;

        for (int i = 0; i < length; i++) {

            T e = unsorted[i];

            size = add(size, e, unsorted);

        }

    }

    private static <T extends Comparable<T>> int add(int size, T element, T[] unsorted) {

        int length = size;

        int i = length;

        unsorted[length++] = element;

        T e = unsorted[i];

        int parentIndex = ((i - 1) / 2);

        T parent = unsorted[parentIndex];

        while (e.compareTo(parent) > 0) {

            swap(parentIndex, i, unsorted);

            i = parentIndex;

            e = unsorted[i];

            parentIndex = ((i - 1) / 2);

            parent = unsorted[parentIndex];

        }

        return length;

    }

    private static <T extends Comparable<T>> void swap(int parentIndex, int childIndex, T[] unsorted) {

        T parent = unsorted[parentIndex];

        unsorted[parentIndex] = unsorted[childIndex];

        unsorted[childIndex] = parent;

    }

}

　　

Java HeapSort的更多相关文章

  1. Spark案例分析

    一.需求:计算网页访问量前三名 import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf, SparkContext} /* ...

  2. Java演算法之堆排序（HeapSort）

    import java.util.Arrays; publicclass HeapSort { inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,9 ...

  3. Heapsort 堆排序算法详解（Java实现)

    Heapsort (堆排序)是最经典的排序算法之一,在google或者百度中搜一下可以搜到很多非常详细的解析.同样好的排序算法还有quicksort(快速排序)和merge sort(归并排序),选择 ...

  4. [转载]堆排序（HeapSort） Java实现

    堆排序的思想是利用数据结构--堆.具体的实现细节: 1. 构建一个最大堆.对于给定的包含有n个元素的数组A[n],构建一个最大堆(最大堆的特性是,某个节点的值最多和其父节点的值一样大.这样,堆中的最大 ...

  5. heapsort(Java)(最小堆)

    public static void main(String[] args) { Scanner input = new Scanner(System.in); int n = input.nextI ...

  6. 堆排序Heapsort的Java和C代码

    Heapsort排序思路 将整个数组看作一个二叉树heap, 下标0为堆顶层, 下标1, 2为次顶层, 然后每层就是"3,4,5,6", "7, 8, 9, 10, 11 ...

  7. 8个排序算法——java

    public static void radixsort(int[] a){ int max=a[0]; for(int i=1;i<a.length;i++){ if (max<a[i] ...

  8. java排序学习笔记

    前面写了js的排序实现,总得玩玩java的哈. 同样,冒泡.选择.快速(这三个之前实现过也写过文章).堆排序,然后做比较. 主要遇到的难点: - -||想轻松点写个封装计时的逻辑,不想每调用一个排序就 ...

  9. Java各种排序算法详解

    排序大的分类可以分为两种:内排序和外排序.在排序过程中,全部记录存放在内存,则称为内排序,如果排序过程中需要使用外存,则称为外排序.下面讲的排序都是属于内排序. 内排序有可以分为以下几类: (1).插 ...

随机推荐

  1. python 设计模式之访问者模式

    写在前面 设计模式是经过总结.优化的,对我们经常会碰到的一些编程问题的可重用解决方案.一个设计模式并不像一个类或一个库那样能够直接作用于我们的代码.反之,设计模式更为高级,它是一种必须在特定情形下实现 ...

  2. Nginx设置黑名单

    date: 2019-07-04  14:35:56 author: headsen chen notice: 个人原创 1,在分域名下面设置: [root@pro-nginx:/usr/local/ ...

  3. MSVCRTD.lib(crtexew.obj) : error LNK2019: 无法解析的外部符号 _WinMain@16

    1.问题描述做开源项目时,碰到VS2010报错如下:MSVCRTD.lib(crtexew.obj) : error LNK2019: 无法解析的外部符号 _WinMain@16,该符号在函数 ___ ...

  4. 整理Mac系统 node-sass 安装失败的原因及解决办法

    转载与:https://segmentfault.com/a/1190000010984731 声明:本文非原创,如有侵权请留言或发邮件告知,作者会立即停止侵权并删除本文.发布此文章主要是希望跟作者遇 ...

  5. 阶段5 3.微服务项目【学成在线】_day16 Spring Security Oauth2_08-SpringSecurityOauth2研究-解决swagger-ui无法访问

    3.3.4.4 解决swagger-ui无法访问 当课程管理加了授权之后再访问swagger-ui则报错: 这里默认配置的了所有的请求都必须认证 把图片认证的路径加进去的话 那么访问课程图片的列表 就 ...

  6. Apache工作模式切换

    一.apache运行模式切换 apache比较常用的工作模式有worker以及prefork两种方式 1.编译安装: 如果在编译时候不指定,系统默认的是prefork模式.如果需要换成worker模式 ...

  7. 123457123456#0#-----com.twoapp.drawGame09--前拼后广--儿童画画游戏jiemei

    com.twoapp.drawGame09--前拼后广--儿童画画游戏jiemei

  8. 123457123457---com.threeObj03.MaJiangertong--- 记忆翻牌益智游戏

    com.threeObj03.MaJiangertong--- 记忆翻牌益智游戏

  9. PAT 甲级 1032 Sharing (25 分)(结构体模拟链表,结构体的赋值是深拷贝)

    1032 Sharing (25 分)   To store English words, one method is to use linked lists and store a word let ...

  10. ClientDataSet中修改，删除，添加数据和Delta属性

    ClientDataSet中使用Post提交变更的数据时,实际上并没有更新到后端数据库中,而是提交到了由DataSnap管理的数据缓冲区中.当使用了ClientDataSet.ApplyUpDates ...