常见的排序算法

1. 冒泡排序（稳定排序算法，O（n²））
   它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序错误就把他们交换过来。
   走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。
   冒泡排序算法的原理如下：
   1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
   2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
   3. 针对所有的元素重复以上的步骤，除了最后一个。
   4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public void BubbleSort(int[] arr) {
		int len = arr.length;
		if (len <= 0) {
			return;
		}
		for (int j = 0; j < len - 1; j++) {
			for (int i = 0; i < len - 1 - j; i++) {
				if (arr[i] > arr[i + 1]) {
					int temp = arr[i];
					arr[i] = arr[i + 1];
					arr[i + 1] = temp;
				}
			}
		}
	}

---

2. 选择排序（不稳定排序算法，O（n²））
   选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数
   据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继
   续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

public void SelectionSort(int[] arr) {
		int len = arr.length;
		if (len <= 0) {
			return;
		}
		for(int i=0;i<len-1;i++){
			int minVal = i;
			for(int j=i+1;j<=len-1;j++){
				if(arr[j]<arr[minVal]){
					minVal=j;
				}
			}
			if(minVal!=i){
				int temp = arr[i];
				arr[i]=arr[minVal];
				arr[minVal]=temp;
			}
			
		}
	}

---

3. 插入排序（稳定排序算法，O（n²））
   插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据。

   public static void insertSort(int[] arr){
        int len=arr.length;
        if (len<=1){
            return;
        }
        for (int i=1;i<len;i++){
            int val = arr[i];
            int pos = i;
            while(arr[pos-1]>val){
                arr[pos]=arr[pos-1];
                pos--;
            }
            arr[pos]=val;
        }
    }

---

4. 归并排序（稳定的排序算法，O(n log n) ）
   归并排序是建立在归并操作上的一种有效的排序算法,该
   算法是采用分治法的一个非常典型的应用。
   将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

 public static void MergeSort(int[] arr,int start,int end){
        if (start<end){
            int mid = (start+end)>>1;
            MergeSort(arr,start,mid);
            MergeSort(arr,mid+1,end);
            Merge(arr,start,mid,end);
        }
    }

    private static void Merge(int[] arr, int start, int mid, int end) {
        int[] tmp = new int[arr.length];
        int startTmp = start,midTmp=mid+1,k=start;
        while (startTmp<=mid && midTmp<=end){
            if (arr[startTmp]<=arr[midTmp]){
                tmp[k++]=arr[startTmp++];
            }else {
                tmp[k++]=arr[midTmp++];
            }
        }
        while(startTmp<=mid){
            tmp[k++]=arr[startTmp++];
        }
        while (midTmp<=end){
            tmp[k++]=arr[midTmp++];
        }
        for (int i=start;i<=end;i++){
            arr[i]=tmp[i];
        }
    }

---

5. 快速排序（不稳定的排序算法，O(n log n) ）
   随机选择一个关键值作为基准值。比基准值小的放在该值得左边，比基准值大的放在该值的右边，然后对左右两边循环使用快速排序。

public class QuickSort {
    public static void main(String[] args) {
        int[] arr={6,8,7,5,9};
        QuickSortCyc(arr,0,arr.length-1);
        for (int x:arr) {
            System.out.print(x+"\t");
        }
    }
    private static void QuickSortCyc(int[] arr,int start,int end){
        int baseVal=arr[start];
        int low=start;
        int high=end;
        while (low<high){
            while (arr[high]>baseVal){
                high--;
            }
            while (arr[low]<baseVal){
                low++;
            }
            int tmp=arr[low];
            arr[low]=arr[high];
            arr[high]=tmp;
        }
        if (low>start){
            QuickSortCyc(arr,start,low-1);
        }
        if (high<end){
            QuickSortCyc(arr,high+1,end);
        }
    }
}

---

6. 希尔排序（不稳定，O(n^（1.3—2）)）
   希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。
   希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含
   的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

   public static void ShellSort(int[] arr){
        int len = arr.length;
        if (len<=1||arr==null){
            return;
        }
        int increatNum = len>>1;
        while (increatNum>=1){
            for (int i=increatNum;i<len;i++){
                int tmp=arr[i];
                int j=i-increatNum;
                while(j>=0&&tmp<arr[j]){
                    arr[j+increatNum]=arr[j];
                    j=j-increatNum;
                }
                arr[j+increatNum]=tmp;
            }
            increatNum=increatNum>>1;
        }
    }