排序算法二（时间复杂度为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("\n");
         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] + "\t");
         }
 
     }
 }

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

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