排序算法二（时间复杂度为O(N*logN)）

快速排序：
 1 package test;

public class QuickSort {
    // 快速排序
    public void quickSort(int s[], int l, int r) {
        if (l < r) {
            // Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
            int i = l, j = r, x = s[l];
            while (i < j) {
                while (i < j && s[j] >= x) // 从右向左找第一个小于x的数
                    j--;
                if (i < j)
                    s[i++] = s[j];

                while (i < j && s[i] < x) // 从左向右找第一个大于等于x的数
                    i++;
                if (i < j)
                    s[j--] = s[i];
            }
            s[i] = x;
            quickSort(s, l, i - 1); // 递归调用
            quickSort(s, i + 1, r);
        }
    }

    public static void main(String[] args) {
        QuickSort quick = new QuickSort();
        int[] A = { 1, 2, 3, 5, 2, 3 };
        quick.quickSort(A, 0, A.length - 1);
        for (int i = 0; i < A.length; i++) {
            System.out.println(A[i]);
        }
    }

}

结果运行如下： 1 2 2 3 3 4 5 

其主要思想如下：先从原序列中随机选取一个初始值，然后在剩下的数组中分别找出比其小的元素，将其分别放到两个序列中，以此类推，采用随机+分治的思想

堆排序：

package test;

public class HeapSortTest {
    public static void main(String[] args) {
        int[] initialData = { 7, 6, 5, 4, 3, 8, 9 };
        HeapSortTest heapSortTest = new HeapSortTest();
        System.out.println("排序之前的原始数据：");
        heapSortTest.print(initialData);

        heapSortTest.heapSort(initialData);
        System.out.println("
");
        System.out.println("排序之后的数据：");
        heapSortTest.print(initialData);

    }

    public void heapSort(int[] data) {
        // 考虑到需要创建多少次堆
        for (int i = 0; i < data.length - 1; i++) {
            createMaxHeap(data, data.length - 1 - i);
            swap(data, 0, data.length - 1 - i);
            // print(data);

        }
    }

    public void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    public void createMaxHeap(int[] data, int indexMax) {
        // 需要创建堆
        for (int currentNode = (indexMax - 1) / 2; currentNode >= 0; currentNode--) {
            // 找出子节点中的较大值
            int bigChildNode = 2 * currentNode + 1;
            // 因为每次更新后
            // while (bigChildNode<=indexMax)//这里的等号就是只有一个元素时
            // {
            if (bigChildNode < indexMax) {
                // 选取子节点中较大的那个节点
                if (data[2 * currentNode + 1] < data[2 * currentNode + 2]) {
                    bigChildNode = 2 * currentNode + 2;
                }
            }
            if (data[currentNode] < data[bigChildNode]) {
                swap(data, currentNode, bigChildNode);
                // currentNode=bigChildNode;
            }
            // else
            // {
            // break;
            // }
            // }

        }
    }

    public void print(int[] data) {
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + "	");
        }

    }
}

输出结果： 排序之前的原始数据： 2 7 6 5 4 3 8 9 3 4 排序之后的数据： 5 3 4 5 6 7 8 9 

其主要思想：就是建造堆和更新堆，需要注意的是：每更新一次堆时，实际上下次就会少更新一个元素，即排序序的部分就会多一个元素。