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

Posted 2022-04-15 肉丸不肉

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

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++) 
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            
            swap(arr, i, minIndex);
        

    
    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);
			selectionSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) 
				succeed = false;
				printArray(arr1);
				printArray(arr2);
				break;
			
		
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

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

2.3 插入排序：

• 插入排序现在还很有用，冒泡和选择排序现在在工程中已经几乎见不到了。
• 类似“玩扑克牌”，每次“摸一张牌”（用外层for循环来控制，从1开始是因为第一张牌已经有序了），在“有序区”中找个合适的位置把它插进去（按照大小）（依次向前两两比较，交换）。 （左神的这个例子真的好形象哇~）
• 插入排序的时间复杂度与数据状况有关。若整个数组有序，不需要怎么交换和比较，时间复杂度为O(N)；若整个数组为逆序，每个数都要一路向前交换到底，时间复杂度为O(N²)。
• 时间复杂度：最好情况、最坏情况、平均情况。要按照最坏情况下来估计。所以此时时间复杂度的描述为“一个算法流程中，最差数据状况下常数操作数量的指标。”

    public static void insertSort(int[] arr) 
        if(arr == null || arr.length < 2) 
            return;
        
        for(int i = 1; i < arr.length; i++) 
            for(int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) 
                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
以上是关于《左神算法初级班》第一节课：复杂度估计和排序算法的主要内容，如果未能解决你的问题，请参考以下文章
 
 左神算法进阶班1_5BFPRT算法
 左神算法书籍《程序员代码面试指南》——1_10最大值减去最小值小于或等于num的子数组数量
 左神算法第八节课：介绍递归和动态规划（汉诺塔问题；打印字符串的全部子序列含空；打印字符串的全排列，无重复排列；母牛数量；递归栈；数组的最小路径和；数组累加和问题，一定条件下最大值问题（01背包））
 左神算法之获取栈中最小值
 2021算法竞赛入门班第一节课枚举贪心习题
 左神算法书籍《程序员代码面试指南》——1_01设计一个有getMin功能的栈