【算法训练营】 - ① 认识复杂度(选择排序、冒泡排序、插入排序)、对数器、二分法与异或运算

@[TOC](【算法训练营】 - ① 认识复杂度(选择排序、冒泡排序、插入排序)、对数器、二分法与异或运算)

https://www.bilibili.com/video/BV1Ef4y1T7Qi
https://github.com/algorithmzuo

认识复杂度

评价算法优劣的核心指标是什么？

1. 时间复杂度（流程决定）

何为常数时间的操作？
如果一个操作的执行时间不以具体样本量为转移，每次执行时间都是固定时间。称这样的操作为常数时间的操作。
如：常见的算术运算（+ - * / %）；常见的位运算（>>、>>>、<<、|、&、^）；赋值、比较、自增、自减；数组寻址操作。
总之，执行时间固定的操作都是常数时间的操作。反之，执行时间不固定的操作，都不是常数时间的操作。

如何确定算法流程的总操作数量与样本数量之间的表达式关系？
5. 想象该算法流程所处理的数据状况，要按照最差情况来。
6. 把整个流程彻底拆分为一个个基本动作，保证每个动作都是常数时间的操作。
7. 如果数据量为N，看看基本动作的数量和N是什么关系。

如何确定算法流程的时间复杂度？
当完成了表达式的简历，只要把最高阶项留下即可。低阶项都去掉，高阶项的稀疏也去掉。记为：O（忽略掉系数的高阶项）

时间复杂度的意义：
当我们要处理的样本量很大很大时，我们会发现低阶项是什么不是最重要的;每一项的系数是什么，不是最重要的。真正重要的就是最高阶项是什么。
这就是时间复杂度的意义，它是衡量算法流程的复杂程度的一种指标，该指标只与数据量有关，与过程之外的优化无关。

选择排序
过程:
arr[0, N-1]范围上，找到最小值所在的位置，然后把最小值交换到0位置。arr[1, N-1]范围上，找到最小值所在的位置，然后把最小值交换到1位置。arr[2, N-1]范围上，找到最小值所在的位置，然后把最小值交换到2位置。arr[N-1, N-1]范围上，找到最小值位置，然后把最小值交换到N-1位置。
估算:
很明显，如果arr长度为N，每一步常数操作的数量，如等差数列一般。所以，总的常数操作数量= a*(N^2)+ b*N +c(a、b、c都是常数)所以选择排序的时间复杂度为O(N ^2)。

public class Code01_SelectionSort {

	public static void selectionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		// 0 ~ N-1  找到最小值，在哪，放到0位置上
		// 1 ~ n-1  找到最小值，在哪，放到1 位置上
		// 2 ~ n-1  找到最小值，在哪，放到2 位置上
		for (int i = 0; i < arr.length - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) { // i ~ N-1 上找最小值的下标 
				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;
	}
}

冒泡排序
过程:
在arr[0~N-1]范围上:
arr[0]和arr[1]，谁大谁来到1位置; arr[1]和arr[2]，谁大谁来到2位置…arr[N-2]和arr[N-1]
谁大谁来到N-1位置
在arr[O~N-2]范围上，重复上面的过程，但最后一步是arr[N-3]和arr[N-2]，谁大谁来到N-2位置
在arr[O~N-3]范围上，重复上面的过程，但最后一步是arriN-4]和arriN-3j，谁大谁来到N-3位置…
最后在arr[0~1]范围上，重复上面的过程，但最后一步是arr[0]和arr[1]，谁大谁来到1位置
估算:
很明显，如果arr,长度为N，每一步常数操作的数量，依然如等差数列一般所以，总的常数操作数量= a*(N^2)+ b*N +c(a、b、c都是常数)
所以冒泡排序的时间复杂度为O(N^2)。

public class Code02_BubbleSort {

	public static void bubbleSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		// 0 ~ N-1
		// 0 ~ N-2
		// 0 ~ N-3
		for (int e = arr.length - 1; e > 0; e--) { // 0 ~ e
			for (int i = 0; i < e; i++) {
				if (arr[i] > arr[i + 1]) {
					swap(arr, i, i + 1);
				}
			}
		}
	}

	// 交换arr的i和j位置上的值
	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];
	}
}

插入排序
过程:
想让arr[O~0]上有序，这个范围只有一个数,当然是有序的。
想让arr[O~1]上有序．所以从arr[1]开始往前看，如果arr[1]<arr[0]，就交换。否则什么也不做。…
想让arr[0~i]上有序，所以从arr[]开始往前看, arr[i]这个数不停向左移动，一直移动到左边的数字不再比自己大，停止移动。
最后一步，想让arr[O~N-1]上有序, arr[N-1]这个数不停向左移动，一直移动到左边的数字不再比自己大，停止移动。
估算时发现这个算法流程的复杂程度，会因为数据状况的不同而不同。你发现了吗?

public class Code03_InsertionSort {

	public static void insertionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		// 不只1个数
		for (int i = 1; i < arr.length; i++) { // 0 ~ i 做到有序
			for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
				swap(arr, j, j + 1);
			}
		}
	}

	// i和j是一个位置的话，会出错
	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];
	}
}

注意

1. 算法的过程，和具体的语言是无关的。
2. 相分析一个算法流程的时间复杂度的前提，是对该流程非常熟悉。
3. 一定要确保在拆分算法流程时，拆分出来的所有行为都是常数时间的操作，这意味着你写算法时，对自己用过的每一个系统api，都非常的熟悉。否则会影响你对时间复杂度的估算。

2. 额外空间复杂度（流程决定）

你要实现一个算法流程，在实现算法流程的过程中，你需要开辟一些空间来支持你的算法流程。
作为输入参数的空间，不算额外空间。
作为输出结果的空间，也不算额外空间。
因为这些都是必要的、和现实目标有关的。所以都不算。
但除此之外，你的流程如果还需要开辟空间才能让你的流程继续下去。这部分空间就是额外空间。如果你的流程只需要开辟有限几个变量，额外空间复杂度就是O(1)。

3. 常数项时间（实现细节决定）

算法流程的常数项
我们会发现，时间复杂度这个指标，是忽略低阶项和所有常数系数的。难道同样时间复杂度的流程，在实际运行时候就一样的好吗?
当然不是。
时间复杂度只是一个很重要的指标而已。如果两个时间复杂度一样的算法，你还要去在时间上拼优劣，就进入到拼常数时间的阶段，简称拼常数项。

算法流程的常数项的比拼方式？
放弃理论分析，生成随机数据直接测。为什么不去理论分析?
不是不能纯分析,而是没必要。因为不同常数时间的操作．虽然都是固定时间，但还是有快慢之分的。
比如，位运算的常数时间原小于算术运算的常数时间，这两个运算的常数时间又远小于数组寻址的时间。
所以如果纯理论分析．往往会需要非常多的分析过程。都已经到了具体细节的程度，莫不如交给实验数据好了。

面试、比赛、刷题中，一个问题的最优解是什么意思?
一般情况下，认为解决一个问题的算法流程，在时间复杂度的指标上，一定要尽可能的低,先满足了时间复杂度最低这个指标之后，使用最少的空间的算法流程，叫这个问题的最优解。
一般说起最优解都是忽略掉常数项这个因素的，因为这个因素只决定了实现层次的优化和考虑，而和怎么解决整个问题的思想无关。

常见的时间复杂度
排名从好到差:
O(1)
O(logN)
O(N)
O(N*logN)
O(N^ 2) O(N^ 3) …O(N^ K)
O(2^ N) O(3^ N) … O(K^N)
O(N!)

算法和数据结构学习的大脉络
1）知道怎么算的算法
2）知道怎么试的算法：递归等。
我们所有的题目讲解,对于大脉络的实践贯穿始终

认识对数器

你在网上找到了某个公司的面试题，你想了好久，感觉自己会做，但是你找不到在线测试,你好心烦…
你和朋友交流面试题，你想了好久，感觉自己会做，但是你找不到在线测试你好心烦…
你在网上做笔试，但是前几个测试用例都过了，突然一个巨大无比数据量来了，结果你的代码报错了，如此大的数据量根本看不出哪错了，你好心烦…

1，你想要测的方法a
2，实现复杂度不好但是容易实现的方法b
3，实现一个随机样本产生器
4，把方法a和方法b跑相同的随机样本，看看得到的结果是否一样
5，如果有一个随机样本使得比对结果不一致，打印样本进行人工干预，改对方法a和方法b
6，当样本数量很多时比对测试依然正确，可以确定方法a已经正确。

认识二分法

1. 在一个有序数组中，找某个数是否存在
2. 在一个有序数组中，找>=某个数最左侧的位置
3. 在一个有序数组中，找<=某个数最右侧的位置
4. 局部最小值问题

经常见到的类型实在一个有序数组上，开展二分搜索。
但有序真的是所有问题求解时使用二分的必要条件吗？不
只要能正确构建左右两侧的淘汰逻辑，你就可以二分。

认识异或运算

异或运算：相同为0，不同为1
同或运算：相同为1，不同为0

上面两行记住的概率接近0%，所以异或运算记成无进位相加！

异或运算的性质

1. 0 ^ N == N N ^ N == 0
2. 异或运算满足交换律和结合律

以上两个性质用无进位相加理解就非常容易。

题目一：如何不使用额外变量交换两个数？

a = a ^ b
b = a ^ b
a = a ^ b

题目二：一个数组中有一种数出现了奇数次，其他数都出线了偶数次，怎么找到并打印这种数？

eor = 0
for i in list:
	eor = eor ^ i
print(eor)

题目三：如何把一个int类型的数，提取出最右侧的1来？

N & ((~N) + 1)

题目四：一个数组中有两种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这两种数？

// arr中，有两种数，出现奇数次
	public static void printOddTimesNum2(int[] arr) {
		int eor = 0;
		for (int i = 0; i < arr.length; i++) {
			eor ^= arr[i];
		}
		// a 和 b是两种数
		// eor != 0
		// eor最右侧的1，提取出来
		// eor :     00110010110111000
		// rightOne :00000000000001000
		int rightOne = eor & (-eor); // 提取出最右的1
		
		
		int onlyOne = 0; // eor'
		for (int i = 0 ; i < arr.length;i++) {
			//  arr[1] =  111100011110000
			// rightOne=  000000000010000
			if ((arr[i] & rightOne) != 0) {
				onlyOne ^= arr[i];
			}
		}
		System.out.println(onlyOne + " " + (eor ^ onlyOne));
	}

题目五：如何判断二进制数中1的个数？

public static int bit1counts(int N) {
		int count = 0;
		
		//   011011010000	// N
		//   000000010000     1			// ①  // ②
		
		//   011011000000	// ③
		// 
		// ....
		while(N != 0) {
			int rightOne = N & ((~N) + 1);	// ①
			count++;	// ②
			N ^= rightOne;	// ③
			// N -= rightOne	// 只适用于正数
		}
		
		
		return count;
		
	}