堆排序

堆排序

堆结构是一种树结构，准确的说是一个完全二叉树。在这个树中每个结点对应原始数据的一个记录，并且每个结点应满足：

• 如果按照从小到大的顺序排序，要求非叶子结点的数据要大于或等于其左、右子结点的数据。
• 如果按照从大到小的顺序排序，要求非叶子结点的数据要小于等于其左、右子结点的数据。

排序过程：

例如，对于一个非叶结点A，假定Ai的左子树和右子树均已进行筛运算，也就是说左子树和右子树均已构成堆结构。对Ai进行筛运算，操作步骤如下：
1. 比较Ai的左子树和右子树的最大值，将最大值放在Aj中。
2. 将Ai的数据和Aj的数据进行比较，如果Ai大于等于Aj，表示以Aj为根的子树已构成堆结构。便可以终止筛运算。
3. 如果Ai小于Aj，则将Ai与Aj互换位置。
4. 经过第3步后，可能会破坏以Ai为根的堆，因为此时Ai的值为原来Aj。下面以Aj为根重复前面的步骤，直到满足堆结构的定义，即父节点数据大于子结点。这样，以Aj为根的子树就被调整为一个堆。

代码：

public class P4_6 {

    static final int SIZE = 7;

    public static void heapSort(int a[],int n){
        int i,j,h,k;
        int t;
        for (i=n/2-1;i>=0;i--){
            while (2*i+1<n){
                j=2*i+1;
                if((j+1)<n){
                    if(a[j]<a[j+1]){
                        j++;
                    }
                }
                if(a[i]<a[j]){
                    t=a[i];
                    a[i]=a[j];
                    a[j]=t;
                    i=j;
                }
                else{
                    break;
                }
            }
        }

        System.out.println("输出构成的堆：");
        for (h=0;h<n;h++){
            System.out.print(" " +a[h]);
        }
        System.out.println();

        for(i=n-1;i>0;i--){
            t=a[0];
            a[0] = a[i];
            a[i] = t;
            k=0;
            while (2*k+1<i){
                j=2*k+1;
                if((j+1)<i){
                    if (a[j]<a[j+1]){
                        j++;
                    }
                }
                if (a[k]<a[j]){
                    t = a[k];
                    a[k] = a[j];
                    a[j] = t;
                    k = j;
                }else
                {
                    break;
                }
            }
            System.out.println("第"+(n-i)+"步排序结果：");
            for (h=0;h<n;h++){
                System.out.print(" "+a[h]);
            }
            System.out.println();
        }

    }

    public static void main(String[] args) {
        int[] shuzu = new int[SIZE];
        for (int i = 0; i < SIZE; i++) {
            shuzu[i] = (int)(100 + Math.random()*(100+1));
        }
        //
        System.out.println("排序前数组为：");
        for (int i = 0; i < shuzu.length; i++) {
            System.out.print("  "+ shuzu[i]);
        }
        //
        System.out.println();
        heapSort(shuzu,SIZE);
        System.out.println("排序后数组为：");
        for (int i = 0; i < shuzu.length; i++) {
            System.out.print("  "+ shuzu[i]);
        }

    }
}

测试输出：

排序前数组为：
  161  138  122  185  146  123  190
输出构成的堆：
 190 185 161 138 146 123 122
第1步排序结果：
 185 146 161 138 122 123 190
第2步排序结果：
 161 146 123 138 122 185 190
第3步排序结果：
 146 138 123 122 161 185 190
第4步排序结果：
 138 122 123 146 161 185 190
第5步排序结果：
 123 122 138 146 161 185 190
第6步排序结果：
 122 123 138 146 161 185 190
排序后数组为：
  122  123  138  146  161  185  190