Randomized Algorithm 随机算法 和 随机快速排序例子

随机算法           

随机算法听起来是很高级的内容了，但是，其实随机算法是很简单的内容，很好理解的。

 

随机算法对于一个问题也许不是准确的解法，而且对于同一个输入，也许每次运行也会产生不同的结果。

随机算法可以在运行的时候，利用一个数据流，在其中做随机选择。

 

相对比一般的算法（e.g.deterministic algorithm)，主要有两个优点：

1 运行时间和空间都比一般的我们现在知道的最优算法都要好(the best deterministic algorithm)

2. 更加容易理解，且容易实现

 

例子1：

我们要求验证F(x1,x2,……xn)这个函数是否是等于0.如果按照一般算法分析的话，那么如果数量大的话，用超级计算机也不一定能搞定，但是我们随机产生几组x1,x2...xn值，然后代入验证，如果有一次是不等于零的，那么这个函数就不等于零了，如果代入10次值还是等于零的话，就可以说函数恒为零。

有一定几率这个结果是不正确的，但是这个几率非常非常低，可以忽略不计了。

这个看起来是很高级的算法，其实思想是很简单的吧。

 

随机算法可以分为两大类：

1 Las Vegas算法：

这个算法总是能产生正确的结果，否则就不会返回结果。

2 Monte Carlo算法：

总是会返回结果，但是结果不一定是正确的。但是出现不正确的答案的几率可以非常非常低，而且我们可以多次运行，每次做不同的随机选择，那么几率就更加低了。

随机算法的效率：比如一般算法的效率是O(n)，那么随机算法可以是O(1)，我们只选择一个实例来验证就可以了，比如前面的列子。当然我们也可以根据我们的需要选择多个实例m。那么效率就是O(m)。这个m要比n少很多。那么效率就高很多了。

例子2：

如我们都比较熟悉的快速排序，平均效率是O(nlgn)，但是最坏效率是O(n*n)；

快速排序可以参考这里：http://blog.csdn.net/kenden23/article/details/14643823

最坏情况就是出现在这个数量原来就是排好序的。那么如何尽量避免这种情况出现呢？

就是在选择数轴的时候，随机的选择一个数，而不是固定的选择一个数。这样主要不一样就是：这个数的选择不依赖于原数列了。最大可能地保证了不会出现最坏情况。

下面我们看看如何写这个随机算法（算法包含了随机和非随机算法比较）：

#include<iostream>
#include<vector>
#include<cstdlib>
#include<ctime>

using namespace std;

//C++'s array range should be [low, up], the same as [low, up+1)
int partition(vector<int> &vi, int low, int up)
{
	int pivot = vi[up];
	int i = low-1;
	for (int j = low; j < up; j++)
	{
		if(vi[j] <= pivot)
		{
			i++;
			swap(vi[i], vi[j]);
		}
	}
	swap(vi[i+1], vi[up]);
	return i+1;
}

int randomizedPartition(vector<int> &vi, int low, int up)
{
	int i = rand() % (up-low) + low;
	swap(vi[i], vi[up]);
	return partition(vi, low, up);
}


//C++'s array range should be [low, up], the same as [low, up+1)
void quickSort(vector<int> &vi, int low, int up)
{
	if(low < up)
	{
		int mid = partition(vi, low, up);
		//Watch out! The mid position is on the place, so we don't need to consider it again.
		//That's why below is mid-1, not mid! Otherwise it will occur overflow error!!!
		quickSort(vi, low, mid-1);
		quickSort(vi, mid+1, up);
	}
}

void randomizedQuickSort(vector<int> &vi, int low, int up)
{
	if(low<up)
	{
		int mid = randomizedPartition(vi, low, up);
		randomizedQuickSort(vi, low, mid-1);
		randomizedQuickSort(vi, mid+1, up);
	}
}

void qSort(vector<int> &vi)
{
	quickSort(vi, 0, vi.size()-1);
}

void qSort(vector<int> &vi, int low, int up)
{
	quickSort(vi, low, up-1);
}
void randomizedQSort(vector<int> &vi)
{
	randomizedQuickSort(vi, 0, vi.size() - 1);
}

void randomizedQSort(vector<int> &vi, int low, int up)
{
	randomizedQuickSort(vi, low, up-1);
}

int main()
{
	int a[] = {3,5,7,9,2,3,1,0,7,5,4};
	vector<int> va(a, a+11);
	int b[] = {31,25,37,49,52,63,71,20,87,95,34};
	vector<int> vb(b, b+11);

	cout<<"Before quicksort:\n";
	for(auto x:va)
		cout<<x<<" ";
	cout<<endl;

	QSort(va);

	cout<<"After quicksort:\n";
	for(auto x:va)
		cout<<x<<" ";
	cout<<endl;
	
	srand(time(NULL));

	cout<<"Before randomized quick sort:\n";
	for(auto x:vb)
		cout<<x<<" ";
	cout<<endl;

	randomizedQSort(vb);

	cout<<"After randomized quick sort:\n";
	for(auto x:vb)
		cout<<x<<" ";
	cout<<endl;
	
	cout<<endl;
	system("pause");
	return 0;
}

输出结果：

如果您觉得这样出现最坏情况的概率还不够小，那么可以进一步改进，使用三个随机数，然后用三个随机数的中间数来作为新的中轴数值，程序如下：

int median(int a, int b, int c)
{
	if (a>b && a<c || a>c && a<b) return a;
	else if (b>a && b<c || b>c && b<a) return b;
	else return c;
}

int medianRandPartition(vector<int> &vi, int low, int up)
{
	int a = rand() % (up-low) + low;
	int b = rand() % (up-low) + low;
	int c = rand() % (up-low) + low;
	int i = median(a, b, c);
	swap(vi[i], vi[up]);
	return partition(vi, low, up);
}

void medianRandQuickSort(vector<int> &vi, int low, int up)
{
	if(low<up)
	{
		int mid = medianRandPartition(vi, low, up);
		medianRandQuickSort(vi, low, mid-1);
		medianRandQuickSort(vi, mid+1, up);
	}
}

void medianRandQSort(vector<int> &vi)
{
	medianRandQuickSort(vi, 0, vi.size() - 1);
}

void medianRandQSort(vector<int> &vi, int low, int up)
{
	medianRandQuickSort(vi, low, up-1);
}

顺便提一下，Quick sort其实可以不用两个递归函数，使用一个如下：

void tailQuickSort(vector<int> &vi, int low, int up)
{
	while (low < up)
	{
		int mid = partition(vi, low, up);
		tailQuickSort(vi, low, mid-1);
		low = mid+1;
	}
}

一般应用使用一般的快速排序就可以了，但是到了某些特殊应用或者高级应用随机算法就显得非常有用了。