HeapSort

最新推荐文章于 2024-10-17 12:56:02 发布
最新推荐文章于 2024-10-17 12:56:02 发布
阅读量114 收藏
点赞数 1
分类专栏： 算法 文章标签： 堆排序 排序算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44834369/article/details/116794610
版权

堆排序Java实现

排序父类

  • 排序模板用于继承

    Sort.java

package MYSORT;

public class Sort {
    public static void sort(Comparable[] a, boolean printProcess)
    {}

    public static boolean less(Comparable v, Comparable w)
    { return v.compareTo(w) < 0; }

    public static void exchange(Comparable[] a, int i, int j)
    {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    public static void print(Comparable[] a)
    {
        String status = "Disordered";
        if (isSorted(a)) status="Ordered";
        for (int i = 0; i<a.length; i++)
            System.out.print(a[i]+"| ");
        System.out.print(status);
        System.out.println();
    }

    public static boolean isSorted(Comparable[] a)
    {
        for (int i = 0; i<a.length-1; i++)
            if (less(a[i+1], a[i]))
                return false;
            return true;
    }
}

元素类型

  • 实现了Comparable接口

  • 用作排序的元素

    intForSort.java

package MYSORT;

public class intForSort implements Comparable<intForSort> {
    private int data;
    public intForSort(int data)
    {this.data = data;}
    @Override
    public int compareTo(intForSort o) {
        if (this.data>o.data) return 1;
        if (this.data==o.data) return 0;
        return -1;
    }

    @Override
    public String toString() {
        return String.valueOf(data);
    }
}

堆排序

HeapSort.java

package MYSORT;

public class HeapSort extends Sort
{
    private static int HeapSize;

    private static int GetHeapSize()
    { return HeapSize; }
    private static void SetHeapSize(int o)
    { HeapSize=o; }
    public static void sort(Comparable[] a, boolean printProcess)
    {
        BuildMaxHeap(a);
        for (int i=a.length-1;i>=1;i--)
        {
            exchange(a, i, 0);
            SetHeapSize(GetHeapSize()-1);
            MaxHeapify(a,0);
            if (printProcess) print(a);
        }
    }

    private static void BuildMaxHeap(Comparable[] a)
    {
        SetHeapSize(a.length);
        for (int i=(int) Math.ceil((double)a.length/2)-1;i>=0;i--) MaxHeapify(a,i);
    }

    private static void MaxHeapify(Comparable[] a, int i)
    {
        int l ,r ,largest;
        l = GetLeftChild(i);
        r = GetRightChild(i);
        if (l<GetHeapSize() && less(a[i], a[l]))             largest=l;
        else                                                 largest=i;
        if (r<GetHeapSize() && less(a[largest], a[r]))       largest=r;
        if (largest != i) {
            exchange(a, i, largest);
            MaxHeapify(a, largest);
        }
    }

    private int GetParent(int i)
    { return i/2-1; }

    private static int GetLeftChild(int i)
    { return 2*i+1; }

    private static int GetRightChild(int i)
    { return 2*i+2; }
}

排序测试

SortTest.java

package MYSORT;

public class SortTest {
    public static void main(String[] args) {
        int[] data = {5,5,9,6,7,9,1,12,35,62,14,181,17,2,23,88,45,76,98,145,126,26,45,18,13,24};
        intForSort []elems = new intForSort[data.length];
        for (int i = 0;i<data.length;i++)
        {
            elems[i] = new intForSort(data[i]);
        }
        System.out.println("排序前：");
        Sort.print(elems);
        System.out.println("堆排序过程：");
        HeapSort.sort(elems,true);
        System.out.println("排序后：");
        Sort.print(elems);
    }
}

运行结果

排序前：
5| 5| 9| 6| 7| 9| 1| 12| 35| 62| 14| 181| 17| 2| 23| 88| 45| 76| 98| 145| 126| 26| 45| 18| 13| 24| Disordered
堆排序过程：
145| 126| 24| 98| 62| 18| 23| 88| 76| 9| 45| 13| 17| 2| 1| 12| 45| 6| 35| 5| 7| 26| 14| 9| 5| 181| Disordered
126| 98| 24| 88| 62| 18| 23| 45| 76| 9| 45| 13| 17| 2| 1| 12| 5| 6| 35| 5| 7| 26| 14| 9| 145| 181| Disordered
98| 88| 24| 76| 62| 18| 23| 45| 35| 9| 45| 13| 17| 2| 1| 12| 5| 6| 9| 5| 7| 26| 14| 126| 145| 181| Disordered
88| 76| 24| 45| 62| 18| 23| 14| 35| 9| 45| 13| 17| 2| 1| 12| 5| 6| 9| 5| 7| 26| 98| 126| 145| 181| Disordered
76| 62| 24| 45| 45| 18| 23| 14| 35| 9| 26| 13| 17| 2| 1| 12| 5| 6| 9| 5| 7| 88| 98| 126| 145| 181| Disordered
62| 45| 24| 35| 45| 18| 23| 14| 9| 9| 26| 13| 17| 2| 1| 12| 5| 6| 7| 5| 76| 88| 98| 126| 145| 181| Disordered
45| 45| 24| 35| 26| 18| 23| 14| 9| 9| 5| 13| 17| 2| 1| 12| 5| 6| 7| 62| 76| 88| 98| 126| 145| 181| Disordered
45| 35| 24| 14| 26| 18| 23| 12| 9| 9| 5| 13| 17| 2| 1| 7| 5| 6| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
35| 26| 24| 14| 9| 18| 23| 12| 9| 6| 5| 13| 17| 2| 1| 7| 5| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
26| 14| 24| 12| 9| 18| 23| 7| 9| 6| 5| 13| 17| 2| 1| 5| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
24| 14| 23| 12| 9| 18| 5| 7| 9| 6| 5| 13| 17| 2| 1| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
23| 14| 18| 12| 9| 17| 5| 7| 9| 6| 5| 13| 1| 2| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
18| 14| 17| 12| 9| 13| 5| 7| 9| 6| 5| 2| 1| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
17| 14| 13| 12| 9| 2| 5| 7| 9| 6| 5| 1| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
14| 12| 13| 9| 9| 2| 5| 7| 1| 6| 5| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
13| 12| 5| 9| 9| 2| 5| 7| 1| 6| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
12| 9| 5| 7| 9| 2| 5| 6| 1| 13| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
9| 9| 5| 7| 1| 2| 5| 6| 12| 13| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
9| 7| 5| 6| 1| 2| 5| 9| 12| 13| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
7| 6| 5| 5| 1| 2| 9| 9| 12| 13| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
6| 5| 5| 2| 1| 7| 9| 9| 12| 13| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
5| 2| 5| 1| 6| 7| 9| 9| 12| 13| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
5| 2| 1| 5| 6| 7| 9| 9| 12| 13| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
2| 1| 5| 5| 6| 7| 9| 9| 12| 13| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Disordered
1| 2| 5| 5| 6| 7| 9| 9| 12| 13| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Ordered
排序后：
1| 2| 5| 5| 6| 7| 9| 9| 12| 13| 14| 17| 18| 23| 24| 26| 35| 45| 45| 62| 76| 88| 98| 126| 145| 181| Ordered

参考资料

Robert Sedgewick and Kevin Wayne《Algorithms》FOURTH EDITION

Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein 《Introduction to Algorithms》SECOND EDITION

代码主义
关注
专栏目录
heapsort
01-19
基于c++的堆积排序算法。排序算法大体可分为两种： 一种是比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。 另一种是非比较排序，时间复杂度可以达到...
Java实现堆排序(Heapsort)实例代码
09-04
堆排序(Heapsort)是一种基于比较的排序算法，它利用了数据结构中的二叉堆特性。在Java中，我们可以通过编写相应的代码来实现堆排序。以下是对标题和描述中涉及的知识点的详细说明： 1. **二叉堆**： - 二叉堆是一...
Heapsort
qq_41951198的博客
04-22 316
heapsort.h #include <iostream> using namespace std; template <class T> class Heapsort { public: void swap1(T &a, T &b) { T tmp; tmp = a; a = b...
java heapsort_Java HeapSort
weixin_39737831的博客
02-13 111
/*** * * Copyright 1994-2018 JasonInternational * All rights reserved.* Created on 2018年4月10日 * Created by Jason* * */package cn.ucaner.algorithm.sorts;/*** Heapsort is a comparison-based sor...
heapSort
gewgAA的博客
07-26 120
HeapSort（堆排序）： 堆 二叉树，有父节点（parent）和左孩子（left），右孩子（right） 堆的大小等于这个堆中有多少个元素 最大堆性质：parent>=children，父节点 大于等于 两个孩子 最小堆性质： children>=parent，父节点 小于等于 两个孩子 下标推算 叶节点（没有children的节点）的下标为(n/2)+1, (n/2)+2, ..., n, n为hea
heapsort 堆排序
qq_59109552的博客
08-20 180
堆排序
堆排序演示代码C++ heapsort.cpp
07-08
本代码主要演示了堆排序的排序方法，代码在centos7中测试通过。 编译方法使用g++ heapsort.cpp -o heapsort，运行heapsort即可
heapSort-heapSort
12-23
heapSort-heapSort
sort-使用C++实现的排序算法之HeapSort.zip
03-10
本主题聚焦于C++实现的HeapSort（堆排序）算法，这是一种高效的、基于比较的排序方法。HeapSort利用了二叉堆的数据结构特性来实现排序，其过程分为两个主要阶段：构建最大（或最小）堆和交换堆顶元素。 **1. 堆的...
排序算法总结（四）归并排序
tomcoding的博客
10-13 691
归并排序的实质就是两个有序数组的合并操作，把数组拆分成单个元素时，这个包含一个元素的数组就是有序的，再把这些小数组逐级合并成大数组，大数组就是有序的了，示例代码演示了排序的过程。
七大经典排序算法优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序、归并排序代码详解
weixin_64593595的博客
10-15 1737
本文深入探讨了七大经典排序算法的优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序和归并排序。适合需要稳定性排序的场景，通过对这些算法的分析和优化，能够根据具体需求选择合适的排序方法，从而提高程序性能和效率。
数据结构（七大排序）
2301_80475151的博客
10-14 954
数据结构的插入排序、选择排序、交换排序、快排、归并排序以及非比较排序
【排序】——2.快速排序法（含优化）
最新发布
金哥的博客
10-17 1059
快速排序法：三种递归+非递归+两大优化
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 542
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 413
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 701
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
qq_57340195的博客
10-17 850
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
heapsort()
07-28
Heapsort is a comparison-based sorting algorithm that works by dividing the input into a max heap and repeatedly extracting the maximum element from it. Here's a simplified implementation of the ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值