堆排序算法实现

摘要:
关于堆排序算法的思想,网上有很多介绍,这里就不解释了。这里提供了两个Java类。读者可以将这些类偷偷放入自己的程序中,并直接调用它们,从而省去了重写堆排序的过程。

关于堆排序算法的思想,网上有很多介绍,这里不再解释,这里提供了两个Java类,读者可以把类潜入到自己的程序中,直接调用,免去了重新编写堆排序的过程。

分为两个堆排序接口,一个是数组从下标1开始存储的堆排序类Duisort1,另一个是从下标0开始存储的堆排序类Duisort2,具体的Java代码如下:

堆排序算法实现第1张堆排序算法实现第2张
 1 import java.util.*;                                              //导入包
 2   //这个类的堆排序元素是从下标1开始的
 3  class Duisort1 {                                                //从小到大建立大头堆,从大到小建立小头堆
 4      
 5     public static void heapadjust(int H[],int s,int m){         //堆调整方法,每调整一次的时间复杂度为O(logn)
 6         int j,k;
 7         int rc=H[s];
 8         for( j=2*s;j<=m;j*=2)                                   //建立大头堆
 9         {
10             if(j<m && H[j]<H[j+1])++j;
11             if(rc>=H[j])break;
12             H[s]=H[j];
13             s=j;
14         }
15         H[s]=rc;
16     }
17     
18     public static void duisort(int array[]){                   //堆排序方法
19         for(int i=(array.length-1)/2;i>=1;--i)                 //建立初始堆,时间复杂度为O(n)
20             heapadjust(array,i,array.length-1);
21         
22         for(int i=array.length-1;i>0;i--)                      //堆排序,时间复杂度为O(nlogn)
23         {
24             int t=array[1];                                    //将堆头与堆尾元素对换
25             array[1]=array[i];
26             array[i]=t;
27             heapadjust(array,1,i-1);                           //对换完,重新调整堆
28         }
29     }
30     
31 }
32  //这个类的堆排序元素是从下标0开始的
33   class Duisort2 {                                             //从小到大建立大头堆,从大到小建立小头堆
34       
35         public static void heapadjust(int H[],int s,int m){    //堆调整方法,每调整一次的时间复杂度为O(logn)
36             int j,k;
37             int rc=H[s];
38             for( j=2*s+1;j<=m;j*=2)                            //建立大头堆
39             {
40                 if(j<m && H[j]<H[j+1])++j;                     //堆调整方法,每调整一次的时间复杂度为O(logn)
41                 if(rc>=H[j])break;
42                 H[s]=H[j];
43                 s=j;
44             }
45             H[s]=rc;
46         }
47         
48         public static void duisort(int array[]){               //堆排序方法
49             for(int i=(array.length-1)/2;i>=0;--i)             //建立初始堆,时间复杂度为O(n)
50                 heapadjust(array,i,array.length-1);
51             
52             for(int i=array.length-1;i>0;i--)                  //堆排序,时间复杂度为O(nlogn)
53             {
54                 int t=array[0];                                //将堆头与堆尾元素对换
55                 array[0]=array[i];
56                 array[i]=t;
57                 heapadjust(array,0,i-1);                       //对换完,重新调整堆
58             }    
59         }
60   }
61  
62  public class Test{                                             //测试类
63      public static void main(String[] args) {
64           Scanner scan=new Scanner(System.in);
65           int n=scan.nextInt();                                 //从键盘接受要排序的个数
66           int array1[]=new int[n+1];                            //下标从1开始存数据的数组
67           int array2[]=new int[n];                              //下标从0开始存数据的数组
68           System.out.print("排序前的数组:");                      
69           for(int i=1;i<=n;i++)                                 //输出排序前的数组
70           { 
71             array1[i]=0+(int)(Math.random()*(100-0+1));         //随机生成0~100之间的整数
72             array2[i-1]=array1[i];
73             System.out.print(array1[i]+",");
74           }
75               System.out.println();
76               
77               Duisort1.duisort(array1);                         //调用堆排序,从下标1开始
78               Duisort2.duisort(array2);                         //调用堆排序,从下标0开始
79               
80               System.out.print("排序后的数组(数组下标从1开始):");    //输出排序结果
81               for(int i=1;i<=n;i++)
82                   System.out.print(array1[i]+",");
83               System.out.println();
84               System.out.print("排序后的数组(数组下标从0开始):");
85               for(int i=0;i<n;i++)
86                   System.out.print(array2[i]+",");
87         }
88  }
View Code

在程序执行后,从键盘上输入10,输出结果为:
排序前的数组:10,28,46,70,36,53,84,4,0,11,
排序后的数组(数组下标从1开始):0,4,10,11,28,36,46,53,70,84,
排序后的数组(数组下标从0开始):0,4,10,11,28,36,46,53,70,84,

免责声明:文章转载自《堆排序算法实现》仅用于学习参考。如对内容有疑问,请及时联系本站处理。

上篇Sift算子特征点提取、描述及匹配全流程解析Dubbo扩展机制(三)Wrapper【代理】下篇

宿迁高防,2C2G15M,22元/月;香港BGP,2C5G5M,25元/月 雨云优惠码:MjYwNzM=

相关文章

看懂SqlServer查询计划

对于SQL Server的优化来说,优化查询可能是很常见的事情。由于数据库的优化,本身也是一个涉及面比较的广的话题, 因此本文只谈优化查询时如何看懂SQL Server查询计划。毕竟我对SQL Server的认识有限,如有错误,也恳请您在发现后及时批评指正。 首先,打开【SQL Server Management Studio】,输入一个查询语句看看SQL...

算法概念、大O记号

算法定义:基于特定的计算类型,旨在解决某一信息处理问题而设计的一个指令序列算法需具备以下要素 输入与输出输入(input):对所求解问题特定实例的描述 输出(output):经计算和处理之后得到的信息,即针对输入问题实例的答案 确定性和可行性:算法应可描述为由若干语义明确的基本操作组成的指令序列,且每一基本操作在对应的计算模型中均可兑现。 有穷性...

redis跳表简介

转自:https://baijiahao.baidu.com/s?id=1625500811386005937&wfr=spider&for=pc 一、前言 跳表(Skip List)这种数据结构在一般的数据结构书籍和算法书籍里都不怎么涉及----至少我大学数据结构课程没有讲这种结构。但是跳表确实是一种性能比较优秀的动态数据结构,并且Red...

湖北省大学程序设计竞赛(武大校赛)

Link A 题意 几何 分析 旋转一个三角形,观察即可得出 B 概率题,胆量== C 题意 给一棵树,问这棵树的所有子图 分析 定义:num[i]:以i为根的子树数量(i选择在内),dfs递归count即可 G   模拟题 直观的是 1、并不是一直尽可能多的买卡片好 2、X<=Y 的时候并不一定不买,因为卡片一旦买了,产生的效益可以叠加 故...

《算法导论》

序GitHub 见solution.txt 6.1 堆6.1-1 在高度为h的堆中,最多元素为2(h+1)−1个,最少元素有 2h+1 个 6.1-3 最大堆的特性是除了根结点外的每个结点都有A[PARENT(i)]>=A[i]故,在一个最大堆的某颗子树中最大元素必然位于该子树的根上。 6.1-4 根据最大堆的性质,任何子树的子结点都小于根节点,故...

信息熵 和 算法时间复杂度

本文仅仅是我个人的理解,发现错误请告诉我一下。 前几天虽然看完了吴军先生的《数学之美》,但一直搞不懂信息熵所以连带着也没搞懂 最大熵的原理,直到今天白天看了TopLanguage的一个讨论信息论的帖子 再经过晚上散步时思考才顿悟信息熵的意义。 信息是个很抽象的概念。人们常常说信息很多,或者信息较少,但却很难说清楚信息到底有多少。比如一本五十万字的中文书到底...