java堆排序

/*堆排序属于选择排序
时间复杂度：
平均情况：O(nlogn)
最好情况：O(nlogn)
最坏情况：O(nlogn)
稳定性：不稳定
 */
public class my堆排序 {
    // 筛运算
    public static void sift(Object[] a, int n, int i) {
        Object x = a[i];
        int j = 2 * i + 1;
        // 左孩子不为空时进行循环
        while (j <= n - 1) {
            // 判断左右孩子哪个大
            if (j < n - 1
                    && (((Comparable) a[j]).compareTo((Comparable) a[j + 1]) < 0)) {
                j++;
            }
            // 将父节点与孩子进行交换，并继续下一层筛运算
            if (((Comparable) x).compareTo((Comparable) a[j]) < 0) {
                a[i] = a[j];
                i = j;
                j = 2 * i + 1;
            } else
                break;
        }
        a[i] = x;
    }

    // 初始化堆+排序，两次筛运算
    public static void heapSort(Object[] a, int n) {
        Object x;
        int i;
        // 初始化堆，从n/2-1元素往回一直到根
        for (i = n / 2 - 1; i >= 0; i--) {
            sift(a, n, i);
        }
        // 排序过程，将堆顶和堆根对调，然后筛运算，进行n-1次排序即完成
        for (int i1 = 1; i1 <= n - 1; i1++) {
            x = a[0];
            a[0] = a[n - i1];
            a[n - i1] = x;
            sift(a, n - i1, 0);
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Object[] a = new Object[] { 25, 56, 32, 20, 1, 5, 89, 3, 8, 41 };
        heapSort(a, 10);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

}