排序（一）

冒泡排序：

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

时间复杂度：O(n²)    空间复杂度：O(1)，稳定排序。

选择排序：

	private static void selectionSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
				minIndex = arr[j] < arr[minIndex] ? j : minIndex;
			}
			int temp = arr[minIndex];
			arr[minIndex] = arr[i];
			arr[i] = temp;
		}
	}

时间复杂度：O(n²)    空间复杂度：O(1)，不稳定排序。

插入排序：

	private static void insertionSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
				int temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;
			}
		}
	}

时间复杂度：有序为O(n),逆序为O(n²)，时间复杂度为O(n²)    空间复杂度：O(1)，稳定排序。

归并排序：

	public static void mergeSort(int[] arr, int l, int r) {
		if (l == r) {
			return;
		}
		int mid = (l + r) / 2;
		mergeSort(arr, l, mid);
		mergeSort(arr, mid + 1, r);
		merge(arr, l, mid, r);
	}

	private static void merge(int[] arr, int l, int mid, int r) {
		int[] help = new int[r - l + 1];
		int i = 0;
		int p1 = l;
		int p2 = mid + 1;
		while (p1 <= mid && p2 <= r) {
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
		while (p1 <= mid) {
			help[i++] = arr[p1++];
		}
		while (p2 <= r) {
			help[i++] = arr[p2++];
		}
		for (i = 0; i < help.length; i++) {
			arr[l + i] = help[i];
		}
                for (int f = 0; f < help.length; f++) {
			arr[l + f] = help[f];
		}
	}

时间复杂度：O(n*logn)，空间复杂度:O(n),可以做到稳定性：meger时相等值先拷贝左区域，再拷贝右区域。

时间复杂度分析：

 

a是切分的次数

N/b是切分后的样本量

O(N^d)是切分后的额外时间复杂度（除去调用子过程外，剩下的代价）

因为：T(N)=2*T(n/2)+O(1)，所以:log(b,a)=1，时间复杂度为：O(n*log(n))

空间复杂度：O(n)