堆排序的java 实现

/*
 ***********完完整整的用堆排序来对一个序列进行排序 ************
 * */

import java.util.Random;
public class HeapSort {
    public static void main(String args[]){
        int[] a = new int[1050];
        InitList(a);//初始化
        PrintList(a);//打印随机生成的序列     System.out.println();//打印一行空格,区分排序前还是排序后new HeapSort().Heap_Sort(a);
        PrintList(a);//打印排序之后的序列
    }
    /*
     ********************HeapSort******************
     * */
    public void Heap_Sort(int a[]){
        int length = a.length;
        //建造一个堆
        CreatHeap(a,length);
        for(int i = length ; i > 0 ; i-- ){
            //把最小的放到最后边,然后重新构造小顶堆
            int temp = a[0];
            a[0] = a[i-1];
            a[i-1] = temp;
            CreatHeap(a,i-1);
        }
    }
    /*
     ********************构造小顶堆*********************
     *
     */
    public void CreatHeap(int a[],int length){
        //从最后一个非叶节点开始,一个个逐渐向前调整来构造一个小顶堆
        for(int i = length/2 ; i >=0 ; i--){
            HeapAdjust(a,i,length);
        }
    } 

    /*
     ************************调整小顶堆 ************************
     * */
    public void HeapAdjust(int a[],int pos,int length){
        //pos为待调整节点,leftChild为待调整节点的左孩子,rightChild为带调整节点的右孩子
        int leftChild = pos*2;
        int rightChild = pos*2+1;
        int min = pos;
        if(leftChild<length && a[leftChild]<a[min]){
            min = leftChild;
        }
        if(rightChild<length && a[rightChild]<a[min]){
            min = rightChild;
        }
        if(min !=pos){// 调整当前节点,若有比当前节点小的节点,则交换
             int temp = a[pos];
             a[pos] = a[min];
             a[min] = temp;
             //交换后的节点可能会不满足小顶堆,则递归调整交换后的节点
             //若min==pos,即上述交换过程没发生,则也不会执行次递归调整的过程
             HeapAdjust(a,min,length);
        }
        //调整当前节点的孩子节点
    }
    public static void InitList(int[] a){
        Random intr = new Random();
        for(int i = 0 ; i < a.length ; i ++){
            a[i] =intr.nextInt(1000);
        }
    }
    public static void PrintList(int[] a){
        for(int i = 0 ; i < a.length ; i ++){
            System.out.print(a[i]+ "  ");
        }
    }

}
时间: 2025-01-01 20:59:58

堆排序的java 实现的相关文章

堆排序之Java实现

堆排序思想: 堆排序,顾名思义,就是基于堆.堆分为最大堆和最小堆,其实就是完全二叉树.最大堆要求节点的元素都要大于其孩子,最小堆要求节点元素都小于其左右孩子,两者对左右孩子的大小关系不做任何要求,其实很好理解.有了上面的定义,我们可以得知,处于最大堆的根节点的元素一定是这个堆中的最大值.其实我们的堆排序算法就是抓住了堆的这一特点,每次都取堆顶的元素,将其放在序列最后面,然后将剩余的元素重新调整为最大堆,依次类推,最终得到排序的序列. 或者说,堆排序将所有的待排序数据分为两部分,无序区和有序区.无

希尔排序与堆排序(Java版)

希尔排序 package ShellSort; import Utils.SortUtils; public class Demo { public static void shellSort(int[] a){ int temp,j; int increment = a.length; do{ increment = increment/3+1;//如果是直接插入排序,这里的increment都为1. //System.out.println(increment); for (int i =

选择排序(直接选择排序、堆排序)——Java

选择排序 思想:每趟从待排序的记录序列中选择关键字最小的记录放置到已排序表的最前位置,直到全部排完. 关键问题:在剩余的待排序记录序列中找到最小关键码记录. 方法: –直接选择排序 –堆排序 (1)简单的选择排序 1.基本思想:在要排序的一组数中,选出最小的一个数与第一个位置的数交换:然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止. 2.实例 实现代码: public static void main(String[] args) { int[] n

堆排序示例-java

package Heapsort; public class TestMain { /** * 调整堆 * @param array 数组 * @param i 调整的元素i * @param length 堆元素个数 */ public static void adaptationArray(int[] array,int i, int length) { // 当前元素 int cur = i; while(2*cur+2<=length) { int curValue = array[cu

堆排序算法的java实现

     堆积排序(Heapsort)是指利用堆积树(堆)这种资料结构所设计的一种排序算法,可以利用数组的特点快速定位指定索引的元素.堆排序是不稳定的排序方法,辅助空间为O(1), 最坏时间复杂度为O(nlog2n) ,堆排序的堆序的平均性能较接近于最坏性能. 中心思想是在使用数组存储的完全二叉树内从下往上每次构造大顶堆或者小顶堆,然后将找出来的堆顶数字放到数组结尾,剩下数组继续构造堆结构. 主要是参考了网上比较常见的两种堆排序的java实现,自己加了一些注释 实现1 采用递归,每次父节点与最大

优先队列之堆排序

1.最大堆 import java.util.Scanner ; public class MaxPQ<Key extends Comparable<Key>>{ private int N = 0 ; private Key[] pq ; public MaxPQ(int max){ pq = (Key[])new Comparable[max+1] ; } public MaxPQ(Key[] a){ pq = (Key[])new Comparable[a.length+1]

(高效率排序算法三)堆排序

一.堆的介绍         动态效果图         堆有如下特点的二叉树: 1.他是完全的二叉树.也就是说,除了树的最后一层布需要时满的,其他的每一层从左到右都是满的.(如下图的完全二叉树跟不完全二叉树) 2.它常常用一个数组在实现.(如下图显示了堆它与数组之间的关系.堆在存储器中的表示是数组:堆只是概念上的表示.注意树是完全二叉树,并且所有的节点满足堆的条件) 3.堆中的每一个节点都满足堆的条件,也就是说每一个节点的值都大于或者等于这个节点的子节点的值(如上图) 二,堆的移除 1.只能移

Java实现8中常用的排序

直接插入排序 import java.util.HashMap; /** * 直接插入排序 * @author HHF * 2014年3月19日 */ public class InsertSort { private static int contrastCount = 0;//对比次数 private static int swapCount = 0;//交换次数 public static void main(String[] args) { System.out.println("直接插

Java常用排序算法/程序员必须掌握的8大排序算法

转载自http://blog.csdn.net/qy1387/article/details/7752973 分类: 1)插入排序(直接插入排序.希尔排序)2)交换排序(冒泡排序.快速排序)3)选择排序(直接选择排序.堆排序)4)归并排序5)分配排序(基数排序)所需辅助空间最多:归并排序所需辅助空间最少:堆排序平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序.    [java] view plain copy print? // 排序原始数据 private static final