查找最大小值、回文数、素数的最小时间复杂度算法

查找最大最小值

• 正常想到的是一层循环依次去比较，但是这种最坏情况下要比较2n次

	int array[] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10, 101};
	int length = sizeof(array) / sizeof(array[0]);
	int max = array[0], min = array[0];
	for(int i = 0; i < length; i++){
		if(array[i] < min)
			min = array[i];
		if(array[i] > max)
			max = array[i];
	}
	cout << max << " " << min;

• 我们可以考虑用另一种算法解决，每次先比较两个数，然后在两个数中依次寻找最大最小值，然后更新最大最小值
• 两两比较是在数组偶数个情况下进行的，因此在两两比较之前应该先判断数组个数，奇数个则将将末尾元素留到最后在比较

	int array[] = {1, 3, 5, -7, 9, 2, 4, 6, 8, 10, 101};
	int length = sizeof(array) / sizeof(array[0]);
	int max = array[0], min = array[0];
	int len = length, judge = 0;
	if(length%2 != 0){
		len--;
		judge = 1;
	}
	for(int i = 0; i < len; i += 2){
		if(array[i] >= array[i+1]){
			if(array[i] > max)
				max = array[i];
			if(array[i+1] < min)
				min = array[i+1];
		}else {
			if(array[i] < min)
				min = array[i];
			if(array[i+1] > max)
				max = array[i+1];
		}
	}
	if(judge == 1){
		if(array[len] > max)
			max = array[len];
		if(array[len] < min)
			min = array[len];
	}
	cout << max << " " << min;

 通过上述代码不难发现，循环里比较次数是n/2，每次array[i]和array[i+1]比较3次，开始先进行一次比较，然后根据第一次比较判断最后两次比较，因此一共比较3*n/2次。

判断回文数列

• 回文数：正着反着都一样的一串数字
• 这里给出两种比较算法

bool isHuiWen(int n){
	string temp = "";
	while(n){
		temp += n%10 + '0';
		n /= 10;
	}
	int len = temp.length();
	for(int i = 0; i < len/2; i++){
		if(temp[i] != temp[len - i - 1]) return false;
	}
	return true;
}

• 通过取余和除将其转换为字符串，然后在进行比较，第一个循环毫无疑问要执行n次，第二个最坏情况下也要执行n/2次。

bool isHuiWen(int n){
	int m = n, temp = 0;
	while(m){
		temp = m%10 + temp*10;
		m /= 10;
	}
	return n == temp ? true : false;
}

• 这种方法只适用数字的判断，如果数字比较大可以将其变为longlong类型。这种算法只需要执行n次外加1次判断就可以了，因此比第一种执行代价要小很多。

素数判别的几种方法

• 素数：能被除了自身和1整除外的数，不包括2

bool isPrime(int n){
	if(n == 2) return true;
	if(n%2 == 0 || n == 1) return false;
	for(int i = 3; i <= sqrt(n); i += 2){
		if(n%i == 0) return false;
	}
	return true;
}

bool isPrime(int n){
	if(n == 0 || n == 1) return false;
	for(int i = 2; i <= sqrt(n); i++){
		if(n%i == 0) return false;
	} 
	return true;
}

法一循环过程中只需要判断奇数部分就可以，偶数能被其他偶数取余为整的自然也能被2取余得整。法二显得比较繁琐，需要每次都一个个判断，当n很大时执行代价就会很大了。