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. legend3---lamp.sh常用操作

    legend3---lamp.sh常用操作 一.总结 一句话总结: 1.github上下载代码 2.修改项目数据库配置,修改文件权限等操作:chown -R apache:apache /data/w ...

  2. .prop() vs .attr()

    .prop() vs .attr() Update 1 November 2012 My original answer applies specifically to jQuery 1.6. My ...

  3. oracle 编译无效对象

    在数据库中,会存在一些无效的对象,导致这种现象的发生原因很多,其中最常见的就是数据库升级(例如修改了表的结构),迁移而引起. 编译无效对象的方式: 1 使用alter **** compile 语句进 ...

  4. 常用SQL50句

    Student(S#,Sname,Sage,Ssex) 学生表 Course(C#,Cname,T#) 课程表 SC(S#,C#,score) 成绩表 Teacher(T#,Tname) 教师表 问题 ...

  5. Div 居中对齐(水平、垂直)

    一:水平居中对齐 ***********************************************************************************  示例图 代码 ...

  6. （十一）使用Jconsole监控线程

    一.案例 监控线程情况,包括阻塞.死循环等 1.1 代码如下,下述代码共有三个线程,Main.mythread01.mythread02线程,其中mythread01线程为死循环.mythread02 ...

  7. windows大全

    1.win7系统如何显示隐藏的文件                参考连接:https://jingyan.baidu.com/article/da1091fbc6c7d2027849d628.htm ...

  8. 【c# 学习笔记】封装

    封装 指的是把类内部的数据隐藏起来,不让对象实例直接对其操作.c#中提供了属性机制来对类内部的状态进行操作. 在c#中,封装可以通过Public.Private.Protected和Internal等 ...

  9. 使用pycharm调试django 打断点调试后台代码

    第一步 第二步 第三步 第四步 Script path:C:\pythonProject\Code\mysite\manage.py Parameters: runserver 远程访问的话 远程调试 ...

  10. hadoop基本文件配置

    [学习笔记] 5)hadoop基本文件配置:hadoop配置文件位于:/etc/hadoop下(etc即:“etcetera”(附加物))core-site.xml:<configuration ...