待字闺中之巧妙排序分析：

题目来源，待字闺中，原创@陈利人 ，欢迎大家继续关注微信公众账号“待字闺中” 

排序只有1，2，3三个元素的数组，不能统计1，2，3的个数。

分析：这个题目，尽管也是排序，但却不能使用快速排序的方法。只有三个元素，如果时间复杂度仍旧是O(nlogn)，显然不是最好的。那就可以使用线性的排序算法，例如计数排序，可是题目中要求，不能够对1，2，3进行统计个数。那该如何处理呢？请大家看下面的方法，我们首先通过例子来说明：

2	1	1	3	3	2
p1	p2				p3

假设，我们有三个指针：p1、p2、p3.p1从左侧开始，指向第一个非1的数字；p3从右侧开始，指向第一个非3的数字。p2从p1开始遍历，如果是2，p2继续遍历，直到p2遇到1或者3：

如果遇到1，则和p1进行交换，然后p1向右，指向第一个非1的数字

如果遇到3，则和p3进行交换，然后p3向左，指向第一个非3的数字

1	2	1	3	3	2
	p1,p2				p3

交换之后，p2继续从p1开始，如果是2继续遍历，如果是1或者3，重复上面的步骤，所得如下：

1	1	2	3	3	2
		p1，p2			p3

根据上面的方法继续下去

1	1	2	2	3	3
p1	p3	p2

p2在p3右侧，算法结束。具体代码如下：

void SortWithThreePointer(vector<int>& data)//用三个指针进行排序，缺点，只能对三个数有效
{
	int length = data.size();
	if(length <= 0)return;
	int begin = 0,cur = 0,end = length -1;
	while(cur <=  end )
	{
		if(data[cur] == 1)
		{
			swap(data[begin],data[cur]);
			begin ++;
			cur ++;
		}
		else if(data[cur] == 3)
		{
			swap(data[cur],data[end]);
			end --;
		}
		else cur ++;
	}
}

基于快排划分的思路

上面的思路，是针对三个数的，如果有更多的数，怎么处理呢？比如，4个，5个等等。下面根据快速的排序的启发，介绍一种算法，尽管在处理三个数的时候，比较次数会多些，但，具有很好的通用性。

思路来自快排的划分部分，快排的划分部分：给定pivot，然后将数据划分为<=pivot和>pivot两部分。这样，三个数字时，需要两次划分：

第一次，用1作为pivot,划分1到最左边；

第二次，用2作为pivot，划分2到左边，则得到整体的排序。

具体代码如下：

int partition(vector<int>& data,int provit,int begin,int end)
{
	int i;
	for(i = begin;i <= end;i++)
	{
		if(data[i] == provit)
		{
			swap(data[begin],data[i]);//找到给定的provit，交换到第一个位置
			break;
		}
	}
	if(i == end+1)return begin-1;
	while(begin < end)
	{
		while(begin < end && data[end] > provit ) end --;
		if(begin < end) data[begin++] = data[end];
		while(begin < end && data[begin] <= provit) begin++;
		if(begin < end)data[end--] = data[begin];
	}
	data[begin] = provit;
	return begin;
}
//numbers是已经排好序的可能会出现的数字，如1，2，3，对每一个数字进行partition
void SortWithPartition(vector<int>& data,vector<int>& number)
{
	int i,provit,dataLen = data.size(),numberLen = number.size();
	if(dataLen <= 0 || numberLen <= 0)return;
	int begin = 0,end = dataLen-1;
	for(i=0;i<numberLen && begin < end;i++)
	{
		provit = partition(data,number[i],begin,end);
		begin = provit + 1;
	}
}

最巧妙的思路

我们将1，2，3，替换为互质的2，3，5，得到如下：

2	1	1	3	3	2
3	2	2	5	5	3

之后，乘起来得到的900.这900里，除以2，有多少个2，就有多少个1；然后除以3，有多少个3，就有多少个3对应的2；然后除以5，有多少个5，就有多少个5对应的3。这是如何保证的呢？因为2，3，5是互质的。

如下：

被除数	除数	商	余数	排序结果
900	2	450	0	1
450	2	225	0	1
225	2	112	1	2尝试结束，尝试3
225	3	75	0	2
75	3	25	0	2
25	3	8	1	3尝试结束，尝试5
25	5	5	0	3
5	5	1	0	3
1	5	1	1	全部结束

最终结果为112233.上面的这种思路，实际上是计数的一种变种。没有直接的技术，那自然就是可以的。具体代码如下：

//numbers是已经排好序的可能会出现的数字，如1，2，3。把每一个数映射为素数，该方法的缺陷是可能会出现溢出
void SortWithPrimeNum(vector<int>& data,vector<int>& number)
{
	int prime[26] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};//100以内的素数
	int dataLen = data.size(),numberLen = number.size();
	if(dataLen <= 0 || numberLen <= 0 || numberLen >= 25)return;
	map<int,int> hashMap;
	int i,j=0,product = 1;
	for(i=0;i<numberLen;i++)
	{
		hashMap[number[i]] = prime[i];//把可能出现的数字映射为素数
	}
	for(i=0;i<dataLen;i++)
	{
		product *= hashMap[data[i]];
	}
	for(i=0;i<numberLen && product != 0;i++)
	{
		cout << hashMap[number[i]] << endl;
		while(product % hashMap[number[i]] == 0)
		{
			data[j++] = number[i];
			product = product / hashMap[number[i]];
		}
	}
}