绝妙的取样(《编程珠玑(续)》第十三章)

取样产生的问题：当从N个数中取样M个数，如果M==N时，那么当M=N-1时，在插入最后一个数时，会有很多次重复，这样就会产生大量的时间耗费。为了避免这个问题，Floyd提出了下面的算法。

从j=N-M+1开始取样，如果随机选取的数已经在集合中了，那么就把第j个数放进集合，这样最多只需要O(N)的复杂度就一定能选择出随机的M个数。

注意：这里把A赋值成0~N-1，这里是没有限制的，可以随机的。

#include<iostream>
#include<set>
using namespace std;

int main()
{
	set<int> S;
	const int N=100;
	int A[N];
	for(int i=0;i<N;i++)
		A[i]=i;
	int M=10;
	for(int i=N-M+1;i<=N;i++)
	{
		int temp=A[rand()%i];
		if(S.find(temp)==S.end())
			S.insert(temp);
		else
			S.insert(A[i-1]);
	}
	for(auto iter=S.begin();iter!=S.end();iter++)
		cout<<*iter<<endl;

	system("pause");
	return 0;
}

当需要产生1~N中随机顺序的M个数时，可以先产生M个数，然后进行随机化，随机化方法可以用《编程珠玑》第二版中第十三章的方法产生。但这样需要O(N)的空间，存放数组A，还需要O(N)的时间，给A赋值并且产生M个随机数。

#include<iostream>
#include<ctime>
using namespace std;

int main()
{
	const int N=10;
	const int M=5;
	int A[10];
	for(int i=0;i<N;i++)
		A[i]=i;
	for(int i=0;i<M;i++)
		swap(A[i],A[i+rand()%(N-i)]);

	system("pause");
	return 0;
}

当N相对于M比较大时，为了减少空间和时间的复杂度，Floyd算法会有更高的效率。空间复杂度是O(M)，时间复杂度最坏是O(M^2)，此时每次插入的值都是前面已经插入的值，最后的时间复杂度是O(M)，此时每次插入的值都不是原来的值。

这里采用哈希set来存储已经存过的值，然后如果当前产生的随机值已经在链表中，则把当前i所表示的值插入到链表中随机数的后面。这样只需要一次遍历，即可产生M个随机的随机数。但是注意此时每次插入时都需要找到当前随机数的值，比较浪费时间。后面有更好的解决办法。

#include<iostream>
#include<list>
#include<unordered_set>
#include<algorithm>
#include<ctime>
using namespace std;

int main()
{
	unordered_set<int> S;
	list<int> L;
	const int N=10;
	int M=5;
	srand(time(NULL));
	for(int i=N-M+1;i<=N;i++)
	{
		int temp=rand()%i;
		if(S.find(temp)==S.end())
		{
			S.insert(temp);
			L.insert(L.begin(),temp);
		}
		else
		{
			L.insert(++find(L.begin(),L.end(),temp),i-1);
			S.insert(i-1);
		}
	}
	for(auto iter=L.begin();iter!=L.end();iter++)
		cout<<*iter<<endl;

	system("pause");
	return 0;
}

为了使插入链表的时间减少，我把链表中的值和其指针存入到unordered_map中，这样在寻找时就会很方便。为了避免冲突，把hash表开成大于N的第一个素数，这样就可以保证不会冲突。因此空间复杂度是O(N)，但此时的时间复杂度却已经降到了O(M)。如果空间不够，则只需要进行hash冲突解决，便可以节省空间，时间复杂度也不会太高。

习题13.6也就解决了。

#include<iostream>
#include<unordered_map>
#include<ctime>
using namespace std;

struct ListNode
{
	int val;
	ListNode *next;
	ListNode(int _val=0):val(_val),next(NULL){}
};

ListNode* insertAfter(int value,ListNode *node)
{
	ListNode *temp=node->next;
	node->next=new ListNode(value);
	node->next->next=temp;
	return node->next;
}

ListNode* insertHead(int value,ListNode *node)
{
	if(node==NULL)
	{
		node=new ListNode(value);
		return node;
	}
	ListNode *temp=node;
	node=new ListNode(value);
	node->next=temp;
	return node;
}

int main()
{
	unordered_map<int,ListNode*> S;
	ListNode *head=NULL;
	const int N=10;
	int A[N];
	for(int i=0;i<N;i++)
		A[i]=i;
	int M=5;
	srand(time(NULL));
	for(int i=N-M+1;i<=N;i++)
	{
		int temp=A[rand()%i];
		if(S.find(temp)==S.end())
		{
			S[temp]=insertHead(temp,head);
			head=S[temp];
		}
		else
			S[A[i-1]]=insertAfter(A[i-1],S[temp]);
	}
	ListNode *curr=head;
	while(curr!=NULL)
	{
		cout<<curr->val;
		curr=curr->next;
	}

	system("pause");
	return 0;
}