数据结构与算法分析(3)：算法运行时间中的对数

1 二分搜索算法

算法思想

假定数据已被排序，查找其中是否存在某个元素

算法实现

int binSearch(const vector<int> a, int b)
{
	int left = 0, right = a.size() - 1;
	while(left <= right)
	{
		int mid = (left + right) / 2;
		if(a[mid] < b)
		{
			left = mid + 1;
		}else if(a[mid] > b)
		{
			right = mid - 1;
		}else
		{
			return a[mid];
		}
	}
	return -1;
}

二分搜索复杂度分析

从right - left = N - 1开始，每次折半，直到right - left >= -1为止，可知：算法复杂度为log(N)

2 欧几里德算法

算法描述：求两个数值的最大公约数

算法实现：

int getMaxFactor(int a, int b)
{
	cout << a << "和" << b << "的最大公约数为";
	while(b != 0)
	{
		int rem = a % b;
		a = b;
		b = rem;
	}
	cout << a << endl;
	return a;
}

算法分析：

(1) 对于两个整数a和b，显然两个数的余数必然小于这两个数中最小的数

(2) 两个数的余数小于其中较大的数的一半，即

(3)算法的最坏情形为输入的两个数字出自斐波那契数列，拉梅定理就给出了步数的计算公式。

由此，算法的复杂度将介于log a 和log b之间

 

3 幂运算

算法描述

分四种情形考虑该问题，

情形一：所有数值的0次幂均为1；

情形二，所有数的一次幂等于他本身；

情形三，所有数的偶次幂等于其平方的折半次幂；

情形四，所有数的奇次幂等于其平方的折半次幂再乘以他本身。

代码实现

int myPow(int a, int b)
{
	if(b == 0)
	{
		return 1;
	}
	else if(b == 1)
	{
		return a;
	}
	else if(b % 2 == 0)
	{
		return myPow(a * a, b / 2); 
	}
	else
	{
		return myPow(a * a, b / 2) * a;
	}
}

算法分析：每次递归调用，问题规模减小一半，所需次数最多为

不可行的做法：将问题分解成N/2次递归调用子问题，算法复杂度不再是logN级别

int myPow(int a, int b)
{
	if(b == 0)
	{
		return 1;
	}
	else if(b == 1)
	{
		return a;
	}
	else if(b % 2 == 0)
	{
		return myPow(a, b / 2) * myPow(a, b / 2);
        //return myPow(myPow(a, 2), b / 2);
        //return myPow(myPow(a, b / 2), 2);
	}
	else
	{
		return  myPow(a, b / 2) * myPow(a, b / 2) * a;
	}
}