《左神算法初级班》第一节课：复杂度估计和排序算法

一、第一节课：复杂度估计和排序算法

0. 本节课知识点

---

1. 认识 时间复杂度和空间复杂度：

• 常数操作：数组寻址、位操作等
• 时间复杂度是常数操作数量的指标。
• 在比较时间复杂度时：先拼指标（数量级），再拼常数项。

算法流程3：有两步。

• 先对B排序，时间复杂度为O(M*logM)
• 再用双指针法向后移动比较，时间复杂度为O(M+N)
• 所以，总的时间复杂度为O(M*logM)+O(M+N)（样本量不确定，不能化简）。

• 空间复杂度：需额外申请的空间。跟最初的已有的无关。

• 如果仅仅需要申请有限个空间，则空间复杂度为O(1)。

---

2. 排序算法

2.1 冒泡排序：

• 每一轮结束把“当前最大”的放在“当前最后面的位置”。
• 所以每次都是相邻两个位置比较，如果i位置上的数大于i+1位置上的数，则交换。
• 一轮结束后，“当前最后面的位置”在下一轮中不再考虑。（外层for循环控制）
• 每一轮都是从0位置开始，到“这一轮的最后位置”。（内层for循环控制）
• 形象化解释：“blue blue” 大的气泡往上走。
• 时间复杂度为O(N²)；额外空间复杂度为O(1)

    public static void bubbleSort(int[] arr) {
   
        if(arr == null || arr.length < 2) {
   
            return;
        }
        //注意边界
        for(int i = arr.length - 1; i >= 1; i--) {
   
            for(int j = 0; j < i; j++) {
   
                if(arr[j] > arr[j+1]) {
   
                    swap(arr, j, j+1);
                }
            }
        }
    }
    public static void swap(int[] arr, int i, int j) {
   
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

	// for test
	public static void comparator(int[] arr) {
   
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
   
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
   
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
   
		if (arr == null) {
   
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
   
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
   
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
   
			return false;
		}
		if (arr1 == null && arr2 == null) {
   
			return true;
		}
		if (arr1.length != arr2.length) {
   
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
   
			if (arr1[i] != arr2[i]) {
   
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
   
		if (arr == null) {
   
			return;
		}
		for (int i = 0; i < arr.length; i++) {
   
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
   
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
   
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			bubbleSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
   
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		bubbleSort(arr);
		printArray(arr);
	}

2.2 选择排序：

• 每轮选择“整体最小”的放在“当前的最低位置处”。
• 外层for循环控制每轮的起点；
• 冒泡排序和选择排序共同点是每轮的范围都变化。但是冒泡排序每轮的终点变化，用外层for循环控制终点的值；选择排序每轮起点变化，用外层for循环控制起点的值。
• 时间复杂度为O(N²)；额外空间复杂度为O(1)
• 冒泡排序和选择排序的复杂度是严格的O(N²)，跟数据状态无关。因为已经把排序的流程定好了，都要依次两两比较，只是如果有序，不发生交换。

    public static void selectSort(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