一道笔试题，题目很简单，要求很苛刻

[zxt5105515]

已知一个长度为2n的数组，int a[]={a1,a2,a3...an,b1,b2,b3...bn};设计算法将a变为{a1,b1,a2,b2,a3,b3...an,bn}
要求（1）时间复杂度为0(n)
(2)空间复杂度为0(1)

[henry_zlh]

/*
int arr[len*2]
int idx 初始值: 0
*/
int swap_fun(int arr[],int len, int idx)
{
int i;
int tmp1,tmp2;
tmp1 = arr[idx];
tmp2 = arr[idx+len];
if(idx+1<len){
swap_fun(arr, len, idx+1);
}
printf(" [%d]=[%d] [%d]=[%d]\n", idx*2,tmp1,idx*2+1, tmp2);
arr[idx*2] = tmp1;
arr[idx*2+1] = tmp2;
return 0;
}

[风中0追风]

不是很难呀，新建一个数组，把a1......放在基数为 B1....放在偶数位，，，

[tengerye]

[Quote=引用 9 楼 的回复:]

不是很难呀，新建一个数组，把a1......放在基数为 B1....放在偶数位，，，
[/Quote]
看清楚题目先。人家说的是空间复杂度为0(1)。

[tengerye]

我给一个思路：
因为空间复杂度为0(1)，所以只能有一个额外变量。对于a元素现在的位置是i,应该移到a[2i-2]；对于b元素现在的位置是i+n，应该移到a[2i-1]。
初始：取a2移动到array[2]，把array[2]的元素放到临时变量中。
循环:把临时变量中的元素取出（总共有2个变量，还有一个用来记录是a的元素还是b的元素，只需要根据原位置是比n/2小还是大就行），然后算出目的位置，然后把目的位置的元素和临时变量中的元素兑换。
在这个过程中，目的位置的元素是第一次被取出（如果之前被取出，因为我们的每一次移动都是把元素直接移动到最终的位置，所以该元素不需要再被取出。），并且临时变量的元素到达最终位置。
现在我们要证明的是这个循环结束的时候所有的元素都到达最终位置。
假如循环结束的时候还有元素没有到达最终位置，那么数组中必然有两个相同的元素（想一想整个循环的过程），而少的那个元素在临时变量中，因为临时变量不可能与数组中的元素重复，因为数组已经有两个相同元素了，所以循环还没有结束。证明完成。

[请叫我杨二哥]

直接一个插入排序算法搞定，还需要那么复杂？

[tengerye]

[Quote=引用 13 楼 的回复:]

直接一个插入排序算法搞定，还需要那么复杂？
[/Quote]
这个世界真能装，你就以为自己学过算法吗？
插入排序的复杂度是O(n^2)，懂？
拿个复杂度如此高的排序方法还装。

[cooliufang]

完美洗牌问题

[xhy_April]

呜呜。。。这个复杂度是怎么算的呢？？

[hsfzxjy]

两个附加变量行不？我只能想到循环+交换。。

[无人与我共黄昏]

貌似用队列堆栈可以弄出来，曾经做过一道题也是这样的

[h_w_m]

引用 楼主 zxt5105515 的回复:

已知一个长度为2n的数组，int a[]={a1,a2,a3...an,b1,b2,b3...bn};设计算法将a变为{a1,b1,a2,b2,a3,b3...an,bn} 要求（1）时间复杂度为0(n) (2)空间复杂度为0(1)

有没有人把它简单化的想啊，分成两题： （1）时间复杂度为0(n)的处理方法 （2）空间复杂度为0(1)的处理方法 不必同时满足两要求(时间与空间是矛盾的，没理由会同时要求满足)，有时候只是考生把问题复杂化了， 这里你只要能分别用两种指定的方法做出来就很好了,两种方法都不会表明考生可能是差了点劲

[友缘仁]

请教 空间复杂怎么算？

[h_w_m]

引用 2 楼 litaoye 的回复:

谁家现场考这么难的题目，肯定不是招工程师吧？ 完美洗牌问题，可以看看这个帖子。 http://www.51nod.com/question/index.html#!questionId=278

了不起啊，还真有同时满足两要求的算法

[友缘仁]

哪个的回答是正确的？

[RobertC]

引用 7 楼 AfterSeptember 的回复:

引用 6 楼 的回复:C/C++ code int func() { int a[]={a1,a2,a3...an,b1,b2,b3...bn}; for (i = 0; i < n; ++i) { swap(a[i],a[i + n]); } } 真逗。

上面这代码真神奇啊

[bigwangdi]

完美洗牌问题吧！！

[prototyper]

我也来洗牌，还算完美，起码简洁。

Array.prototype.cross = function(arr) {
    return  this.length ? [this.slice(0, 1), arr.slice(0, 1)].concat(this.slice(1).cross(arr.slice(1))) : [];
}
var a = ["a1", "a2", "a3", "......", "an", "b1", "b2", "b3", "......", "bn"];
alert(a.slice(0, a.length >>> 1).cross(a.slice(a.length >>> 1)))

[636f6c696e]

#define  n		29

void Swap(int& a, int& b)
{
	int temp = b;
	b = a;
	a = temp;
}

void SwapTest(int* a, int begin, int end)
{
	if (end - begin == 1 || (end - begin + 1) % 2 != 0 )
	{
		return;
	}
	
	if ((end - begin + 1) % 4 == 0)
	{
		int length = (end - begin + 1) / 4;
		for (int i = length; i < 2 * length; i++)
		{
			Swap(a[begin + i], a[begin + i + length]);
		}
		SwapTest(a, begin, begin + 2 * length - 1);
		SwapTest(a, begin + 2 * length, end);
	}
	else
	{
		int length = (end - begin + 1) / 4;
		for (int i = length + 1; i < 2 * length + 1; i++)
		{
			Swap(a[begin + i], a[begin + i + length]);
		}
		for (int i = 3 * length + 1; i >  2 * length + 1; i--)
		{
			Swap(a[begin + i], a[begin + i - 1]);
		}
		SwapTest(a, begin, begin + 2 * length + 1);
		SwapTest(a, begin + 2 * length + 2, end);
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	int* a = new int[2 * n];
	for (int i = 0; i < 2 * n; i++)
	{
		if (i < n)
		{
			a[i] = 2 * i + 1;
		}
		else
		{
			a[i] = 2 * (i - n + 1);
		}
	}
	printf("before swap, the array is:\r\n");
	for (int i = 0; i < 2 * n; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\r\n");
	SwapTest(a, 0, 2 * n - 1);
	printf("after swap, the array is:\r\n");
	for (int i = 0; i < 2 * n; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\r\n");

	delete [] a;
	return 0;
}

用了分治的算法，复杂度应该符合楼主要求，楼主试试看

[zhangtonghui816]

引用 楼主 zxt5105515 的回复:

已知一个长度为2n的数组，int a[]={a1,a2,a3...an,b1,b2,b3...bn};设计算法将a变为{a1,b1,a2,b2,a3,b3...an,bn} 要求（1）时间复杂度为0(n) (2)空间复杂度为0(1)

楼主啊，这些题都出烂了，程序员面试宝典上有，编程珠玑也给了思路的

[SharpUrMind]

收藏了，稍后研究