首先排序分为四种：
交换排序： 包括冒泡排序，快速排序。
选择排序： 包括直接选择排序，堆排序。
插入排序： 包括直接插入排序，希尔排序。
归并排序： 归并排序。
（一） 冒泡排序
冒泡排序的基本思想是，对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序。时间复杂度为==O(n^2）==。
/**
* 冒泡排序
*
* @param arr
*/
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
boolean flag = true;//设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已然完成。
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr,j,j+1);
flag = false;
}
}
if (flag) {
break;
}
}
}（二）插入排序
想想扑克牌就很好理解了。时间复杂度为==O(n^2)==
Java代码实现
public static void insertSort(int[] A){
for(int right = 1;right < A.length;right++){
int temp = A[right];
int left = right-1;
while(left >= 0 && A[left]>temp){
A[left+1] = A[left];
left--;
}
A[left+1] = temp;
}
}复杂度分析
①插入排序的时间复杂度 就是判断比较次数有多少，而比较次数与 待排数组的初始顺序有关，当待排数组有序时，没有移动操作（第8行for不成立），此时复杂度为O(N)，当待排数组是逆序时，比较次数达到最大–对于下标 i 处的元素，需要比较 i-1 次。总的比较次数：1+2+…+N-1 ，故时间复杂度为==O(n^2)==
①可以看出，算法中只用到了一个临时变量（第6行），故空间复杂度为O(1)
（三）归并排序
思想
分解：分解待排序的n个元素的序列成n/2个元素的两个子序列
解决：使用归并排序递归地排序两个子序列
合并：合并两个已经排序好地子序列为一个序列 产生答案
public static int[] mergeSort(int[] A ,int left,int right){
if(left < right){
int mid = left + (right - left)/2;
//分
mergeSort(A,left,mid);
mergeSort(A,mid+1,right);
//合并
mergeGetArray(A,left,mid,right);
}
return A;
}
public static void mergeGetArray(int[] A,int left,int mid,int right){
int[] TempRes = new int[right-left+1];
int i = left,j = mid +1;
int k = 0;
while(i <= mid && j <= right){
if(A[i]<A[j]){
TempRes[k++] = A[i++];
}else{
TempRes[k++] = A[j++];
}
}
while(i <= mid){
TempRes[k++] = A[i++];
}
while(j <= right){
TempRes[k++] = A[j++];
}
for(i = 0;i < TempRes.length;i++){
A[left+i] = TempRes[i];
}
}(四)堆排序
堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为==O(nlogn)==，它也是不稳定排序。
思想：
将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
代码实现
维护堆的性质的函数
//维护堆的性质的函数,根据大小来调整某个结点以及它的孩子结点的位置
MAX_HEAPIFY(A,i){
left = 2i+1; //左孩子
right = 2i+2 ; //右孩子
//以下为判断结点以及它的孩子结点哪个最大，孩子结点比父节点大则调整二者位置
if( A[left] <= A.heap-size and A[Left]>A[i])
largest = Left;
else largest = i;
if( A[right] <= A.heap-size and A[right]>A[largest])
largest = r;
if( largets != i)
{
exchage A[i] with A[largest]
MAX_HEAPIFY(A,largest)
}
}构建堆的函数
//构建堆的函数
BUID-HEAP(A){
A.heap-size = A.length;
for(int i = A.length/2-1;i>=0;i++){
MAX-HEAPIFY(A,i);//从最后一个非叶子结点开始调整，直到根节点的index为0
}
}有了前面的铺垫，我们可以很容易写出堆排序
堆排序：
HEAP-SORT(A){
BUID-HEAP(A) //构建堆
for(int i = A.length-1;A>=0;A--){
exchange A[0] with A[i] //每次将堆的顶端也就是最大值放在数组最后边
A.heap-size = A.heap-size -1
MAX-HEAPIFY(A,1) //维护堆
}
}
```
### （五）快速排序
在平均状况下，排序 n 个项目要==Ο(n log n)== 次比较。在最坏状况下则需要Ο(n^2)次比较，但这种状况并不常见。
快速排序使用分治法（Divide and conquer）策略(归并排序也是分治法)来把一个串行（list）分为两个子串行（sub-lists）。是冒泡排序的改进型.
**算法步骤：**
1. 首先在数组中选择一个基准点（该基准点的选取可能影响快速排序的效率，后面讲解选取的方法）
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
``` java
public static void QuickSort(int[] arr,int low,int high){
while(low < high){
int mid = Division(arr,low,high);
QuickSort(arr,low,mid-1);
QuickSort(arr,mid+1,high);
}
}
private static int Division(int[] arr,int low,int high) {
//选择一个基准数，一次循环将其放到属于它的位置
int temp = arr[low];
while(low < high){
while(low < high && arr[high] >= temp){
high--;
}
arr[low] = arr[high];
while(low < high && arr[low] <= temp){
low++;
}
arr[high] = arr[low];
}
arr[low] = temp;
return low;
}
<div class="se-preview-section-delimiter"></div>
注意：快速排序在序列中元素很少时，效率将比较低，不然插入排序，因此一般在序列中元素很少时使用插入排序，这样可以提高整体效率。
(六)直接选择排序
直接选择排序最类似于人的本能思想，比如把大小不一的玩具让三岁小毛孩对大小排个序，那小孩首先会在这么多玩具中找到最小的放在第一位，然后找到次小的放在第二位，以此类推。。。。。。
public static void SelectSort(int[] arr){
for(int i = 0;i<arr.length-1;i++){
int Index = i;
for(int j = i+1;j<arr.length;j++){
if(arr[Index]>arr[j])
Index = j;
}
//swap arr[i] with arr[Index]
int temp = arr[i];
arr[i] = arr[Index];
arr[Index] = temp;
}
}
<div class="se-preview-section-delimiter"></div>
（七）希尔排序
希尔是插入排序的改进版。 如果当数据是”5, 4, 3, 2, 1“的时候，此时我们将“无序块”中的记录插入到“有序块”时，估计俺们要崩盘，
shell根据这个弱点进行了算法改进，融入了一种叫做“==缩小增量排序法==”的思想。
首先要明确一下增量的取法：
第一次增量的取法为： d=count/2;
第二次增量的取法为: d=(count/2)/2;
最后一直到: d=1;
public static void shellSort(int[] arr){
int j = 0;
int temp = 0;
for(int incre = arr.length/2 ; incre>0 ;incre /= 2){
for(int i = incre; i < arr.length;i++){
temp = arr[i];
for(j = i-incre; j >= 0 ; j -= incre){
if(temp < arr[j]){
arr[j + incre] = arr[j];
}else{
break;
}
}
arr[j + incre] = temp;
}
}
}