各种排序

快速排序：

     /* 快速排序 */     //直接交换，better    static int partition(Integer arr[],int low,int high){        int temp,pivot = arr[high];         while(low < high){                     /* 查找顺序要和基准选取方向相反；              pivot = arr[high] 则必须先从low开始；               反之 pivot = arr[low]， 则必须先从high开始查找 */            while(arr[low] <= pivot && low < high)                low++;             arr[high] = arr[low];//直接覆盖原先的元素            while(arr[high] >= pivot && low < high)                high--;              arr[low] = arr[high];        }        // 校准，将基准移至正确位置        arr[low] = pivot;        System.out.println("low="+low+";high="+high);        return low;    }     static void  quickSort(Integer []arr,int low,int high){         if(low < high){          int pivotpos = partition(arr,low,high);          quickSort(arr,low,pivotpos-1);          quickSort(arr,pivotpos+1,high);         }    }

另一种：

    static int partition(Integer a[], int low, int high) {        int i = low, j = high;        int temp, pivot = a[i];        while (i < j) {            /*             * 查找顺序要和基准选取相反； pivot = arr[high] 则必须先从low开始；              * 反之 pivot =arr[low],则必须先从high开始查找             */            /**             * 注意：             * 1，与pivot比较必须是>=，否则在a[j]或a[i]==pivot时，会造成死循环             * 2，内层循环的i<j，保证i,j不会越过对方，因此跳出最外层循环时，i==j             */            while (a[j] >= pivot && i < j)                j--;            while (a[i] <= pivot && i < j)                i++;            // i,j位置元素，两边交换，此时无需判断i<=j，此条件在该循环中恒成立            int t = a[i];            a[i] = a[j];            a[j] = t;        }        // 校准，将基准值移至正确位置，此时i==j        a[low] = a[i];        a[i] = pivot;        System.out.println("i=" + i + ";j=" + j);// i j必相等        return i;// 返回基准所在位置划分位置    }    static void quickSort(Integer[] a, int low, int high) {        if (low < high) {            int pivotpos = partition(a, low, high);            quickSort(a, low, pivotpos - 1);            quickSort(a, pivotpos + 1, high);        }    }    public static void main(String[] args) {         Integer a[] = { 8,1,4,9,0,3,5,2,7,6};        quickSort(a, 0, a.length - 1);        Arrays.toString(a);    }

第二种
low处自始至终放的是pivot没动，最后需要把i，j指向位置的元素放到low处；
解释为什么满足放到low处：
内层两个while，先从high走，再走low;最后一次while时肯定是先不满足第一个while，第二个while又是i==j不满足；不满足第一个while但是又进得了外层的while，只能说明最后i(或j)指向的元素不满足>=pivot，即元素肯定小于pivot，所以必定满足放到low处。
这也就是为什么“查找顺序要和基准选取的方向相反”

归并排序：

//将有二个有序数列a[first...mid]和a[mid...last]合并。  void mergearray(int a[], int first, int mid, int last, int temp[])  {      int i = first, j = mid + 1;      int m = mid,   n = last;      int k = 0;      while (i <= m && j <= n)      {          if (a[i] <= a[j])              temp[k++] = a[i++];          else              temp[k++] = a[j++];      }      while (i <= m)          temp[k++] = a[i++];      while (j <= n)          temp[k++] = a[j++];      for (i = 0; i < k; i++)          a[first + i] = temp[i];  }  void mergesort(int a[], int first, int last, int temp[])  {      if (first < last)      {          int mid = (first + last) / 2;          mergesort(a, first, mid, temp);    //左边有序          mergesort(a, mid + 1, last, temp); //右边有序          mergearray(a, first, mid, last, temp); //再将二个有序数列合并      }  }  bool MergeSort(int a[], int n)  {      int *p = new int[n];      if (p == NULL)          return false;      mergesort(a, 0, n - 1, p);      delete[] p;      return true;  }  

归并排序的效率是比较高的，设数列长为N，将数列分开成小数列一共要logN步，每步都是一个合并有序数列的过程，时间复杂度可以记为O(N)，故一共为O(N*logN)。因为归并排序每次都是在相邻的数据中进行操作，所以归并排序在O(N*logN)的几种排序方法（快速排序，归并排序，希尔排序，堆排序）也是效率比较高的。
https://visualgo.net/sorting 排序可视化

堆排序

计算堆化时间复杂度时，将父节点与子节点的比较简易化，看本质（其实就是从上到下的单支链表！因为选择堆化结点时，是先从n/2处向前遍历。从上到下比较时，调整的必是或左或右的一颗子树。其实无论是否下面的一堆化，向下调整时，每次选择必走的是单支的啊。。。），其实是该节点的深度（树高H-本层高度h）
http://blog.csdn.net/yuzhihui_no1/article/details/44258297
该博客代码，时间复杂度 均解释十分详细