简单选择排序

算法思想

从头到尾顺序扫描序列，找出最小的一个关键字，和第一个关键字交换，接着从剩下的关键字中继续这种选择和交换。
选择类排序 - 图1

  1.     public static void simpleSelectSort(int arrray[]) {
  2.         //最小数下标
  3.         int minIndex = 0;
  4.         int temp;
  5.         for (int i = 0; i < arrray.length; i++) {
  6.             minIndex = i;
  7.             //找出未排序区中的最小值下标
  8.             for (int j = i + 1; j < arrray.length; j++) {
  9.                 if (arrray[minIndex] > arrray[j])
  10.                     minIndex = j;
  11.             }
  12.             //最小值交换
  13.             temp = arrray[i];
  14.             arrray[i] = arrray[minIndex];
  15.             arrray[minIndex] = temp;
  16.         }
  17.     }

复杂度分析

时间复杂度：O(n2)
空间复杂度：O(1)

堆排序

算法思想

堆是一种数据结构，可以把堆看成一颗完全二叉树，这可完全二叉树满足：任何一个非叶节点的值都不大于（或不小于）其左右孩子结点的值。若父亲大孩子小，则这样的堆叫做大顶堆；若父亲小孩子大，这样的堆叫做小顶堆。
选择类排序 - 图2

  1.     public static void buildMaxHeap(int array[]){
  2.         for (int i = array.length/2; i >= 0; i--){
  3.             heapAdujust(array,i,array.length);
  4.         }
  5.     }
  7.     public static void heapAdujust(int array[], int k, int len){
  8.         int temp = array[k];
  9.         for (int i = k*2; i < len; i *= 2){
  10.             if ((array[i] < array[i+1]) && (i < len))
  11.                 i++;
  12.             if (temp >= array[i])
  13.                 break;
  14.             else{
  15.                 array[k] = array[i];
  16.                 k = i;
  17.             }
  18.         }
  19.         array[k] = temp;
  20.     }
  22.     public static void swap(int array[], int index){
  23.         int temp = array[0];
  24.         array[0] = array[index];
  25.         array[index] = temp;
  26.     }
  28.     public static void heapSort(int array[]){
  29.         buildMaxHeap(array);
  30.         for (int i = array.length-1; i >= 0; i--) {
  31.             swap(array,i);
  32.             heapAdujust(array,0,i-1);
  33.         }
  34.     }