1，插入排序 2，冒泡排序 3，选择排序 4，快速排序 5，归并排序

共同点：
时间复杂度 O(n^2) ：冒泡，选择，插入
时间复杂度 O(nlogn) : 快排，归并
时间复杂度 O(n) ：痛，计数，基数

分析一个排序算法：
一，排序算法的执行效率
1，最好情况，最坏情况，平均情况的复杂度
2，时间复杂度的系数，常数，低阶
3，比较次数和交换（或移动）次数
二，排序算法的内存消耗
空间复杂度，原地排序，是空间复杂度为O(1)的情况
三，排序算法的稳定性
释意：如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间的先后顺序保持不变。
例子：十万订单数据，我们希望金额按照金额排序，对于金额相同的订单，我们希望按照下单的时间的先后排序。
方法，先按照订单时间排序，排序完成之后，我们用稳定的排序算法，按照订单金额重新排序。

冒泡排序：
只会操作相邻的两个数据，一次冒泡会让至少一个元素移动到它应该的位置，重复 n 次，就完成了 n 个拍讯工作。
冒泡优化：当某次冒泡操作已经没有数据交换时，说明已经达到完全有序，不用再继续执行后续的冒泡的操作。

// a 为要排序的数据，n 为数组的大小
public voi bubbleSort(int [] a, int n) {
	if(n <= 1 ) return;
	for(int i = 0; i < n; i++) {
		boolean flag = false;
		for (int j = 0 ;j < n - i - 1; j++) {
			if (a[j] > a[j + 1]) {
				int temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
				falg = true; // 表示有数据交换
			}
		}
		if(!flag) break; // 没有数据交换，提前结束
	}
}

1，空间复杂度为 O(1)，是原地排序算法
2，不会改变两个相等元素的位置，是稳定排序算法
3，时间复杂度，最好 O(n)，最坏O(n^2),
有序度分析：6，5，4，3，2，1 有序度 0，
1，2，3，4，5，6 有序度 15；（1 + 5）* 5 / 2 = 15.(满有序度)
平均复杂度 O(n^2)

插入排序
一个有序数据，我们向其中插入一个新的数据，遍历数据，找到数组应该插入的位置即可。
1，也包含两个操作，一个是元素的比较，一个是元素的移动

public void insertionSort(int[] a, int n) {
	if(n <= 1) return;
	for(int i = 1; i < n; i++) {
		int value = a[i];
		int j = i - 1;
		for(; j >= 0; j--) {
		    if(a[j] > value) {
			a[j + 1] = a[j]; // 数据移动
			} else {
			break;	
			}
		}
		a[j + 1] = value; // 插入数据
	}
}

1，插入排序也是标胶两个相近数据，因此空间复杂度为 O(1)，是原地排序算法
2，对于相同值得元素，我们可以选择将后面出现的元素，插入到前面出现的元素后面，是稳定排序算法。
3，时间复杂度，最好为 O(n);最坏为O(n ^ 2) ， 平均时间复杂度为 O(n^2).

选择排序
1，空间复杂度为 O(1)，原地排序
2，最好，最坏，平均时间复杂度都为 O(n^2);
3, 选择拍讯不是稳定排序算法

public void selectSort(int [] arr, int n) {
		for(int i = 0 ; i < n; i++) {
			for(int j = i + 1;, j < n; j++) {
				if(arr[i] > arr[j]) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}

插入排序为什么比冒泡排序更受欢迎：
冒泡排序的数据交换要麻烦与插入排序。

快速排序
1,时间复杂度O(nlogn)
1,空间复杂度O(1)，原地排序

public class sortQuick {

    public static void main(String[] args) {
        int arr[] = {5, 4, 9, 8, 7, 6, 0, 1, 3, 2};

        QuickSort(arr);


        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }


    private static void QuickSort(int[] arr) {
        sort(arr, 0, arr.length - 1);
    }

    private static void sort(int[] arr, int low, int high) {
        if (low >= high) {
            return;
        }

        int point = arr[high];
        int i = low;
        for (int j = low; j < high; j++) {

            if (arr[j] < point) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                i++;
            }

        }

        int temp = arr[i];
        arr[i] = arr[high];
        arr[high] = temp;

        sort(arr, low, i - 1);
        sort(arr, i + 1, high);
    }
}

归并排序
1,时间复杂度O(nlogn)
1,空间复杂度O(n)，非原地排序，弱点

 public static void main(String[] args) {
        int[] arr = {3, 7, 5, 8, 9, 10, 4, 2, 13, 15};

        merge(arr);

        for (int i = 0; i <= arr.length - 1; i++) {
            System.out.println(arr[i]);
        }

    }

    private static void merge(int[] arr) {
        mergeSort(arr, 0, arr.length - 1);
    }

    private static void mergeSort(int[] arr, int p, int r) {
        if (p >= r) {
            return;
        }

        int q = (p + r) / 2;

        mergeSort(arr, p, q);
        mergeSort(arr, q + 1, r);

        mergeArr(arr, p, q, r);
    }

    private static void mergeArr(int[] arr, int p, int q, int r) {
        int[] temp = new int[r - p + 1];
        System.out.println("temp length = " + (r - p + 1));

        int i = p;
        int j = q + 1;
        int k = 0;

        while (i <= q && j <= r) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }

        int start = i <= q ? i : j;
        int end = i <=  q ? q : r;

        while (start <= end) {
            temp[k++] = arr[start++];
        }

        for (i = 0; i <= r - p; i++) {
            arr[p + i] = temp[i];
        }

    }