排序（1）

排序(1)

@(数据结构与算法)

基本排序算法的时间复杂度

如何分析排序算法

时间复杂度，空间复杂度，稳定性

冒泡排序

Java 代码如下：

//a 表示数组，n 表示数组大小
public void 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++){  //由于函数中有 j+1 ，所以此处为 n-i-1
			if(a[j] > a[j+1]){
				int temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp;
				flag = true;
			}
		}
		if (!flag) break;
	}
}

时间复杂度$O(n^2)$，空间复杂度 $O(1)$ 稳定

---

插入排序

Java 代码

// 插入排序，a 表示数组，n 表示数组大小
public void insertionSort(int[] a, int n) {
  if (a == null  || a.length() <2) return;
  for (int i = 1; i < n; i++) {
    // 查找插入的位置
    for ( int j = i - 1; j >= 0; j--) {
      if (a[j] > a[j+1]) {
        int temp = a[j];
        a[j] = a[j+1];
        a[j+1] = temp;
      } else {
        break;
      }
    }
  }
}

时间复杂度$O(n^2)$，空间复杂度 $O(1)$ 稳定

---

选择排序

java 代码

public static void selectionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		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;
			}
			swap(arr, i, minIndex);
		}
	}
	
public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

时间复杂度$O(n^2)$，空间复杂度 $O(1)$ 不稳定

---

归并排序

public static void mergeSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		process(arr, 0, arr.length - 1);
	}

public static void process(int[] arr, int l, int r) {
		if (l == r) {
			return;
		}
		int mid = l + ((r - l) >> 1);
		process(arr, l, mid);
		process(arr, mid + 1, r);
		merge(arr, l, mid, r);
	}

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

时间复杂度$O(n*logn)$，空间复杂度 $O(n)$ ,稳定