重新排列包含正数和负数的数组

给定一个包含正数和负数的整数数组，重新排列它，使得所有的负数排在前面，所有的正数排在后面。正数间和负数间的相对顺序保持不变。期望时间复杂度是O(n), 空间复杂度是O(1).

例如: 给定 [-1,2,-2,3,5,-4], 重新排列后变成 [-1,-2,-4,2,3,5]

分析： 1. 最简单的算法是O(n^2), 遇到每个负数都把它移动到数组前面已经排列好的负数部分后面。

2. O(n)的算法暂时没想出来，似乎比较难，下面给出一个O(nlogn)的算法。基本思想类似于Merge Sort. 空间复杂度由于用到递归，是O(logn). 不过可以很容易改写为bottom-up的迭代版本。

void Main()
{
	int[] nums = new int[] {-1, 2, -2, 3, 5, -4};

	Reorder(nums, 0, nums.Length-1);
}

// Define other methods and classes here
public void Reorder(int[] nums, int start, int end)
{
    if(start >= end) {
	    return;
	}

	int middle = start + (end-start)/2;
	Reorder(nums, start, middle);
	Reorder(nums, middle+1, end);
	Merge(nums, start, middle, end);
}

private void Merge(int[] nums, int start, int end)
{
    int i = start;
	while(nums[i] < 0 && i <= end) i++;
	int j = end;
	while(nums[j] >= 0 && j >= start) j--;

	// Shift the negative part to the front
	if(i < j) {
	   int k = j;
	   while(k>=i && nums[k]<0) k--;

	   Reverse(nums, i, k);
	   Reverse(nums,k+1,j);
	   Reverse(nums,i,j);
	}
}

private void Swap(int[] nums, int i, int j)
{
    int t = nums[i];
	nums[i] = nums[j];
	nums[j] = t;
}

private void Reverse(int[] nums, int i, int j)
{
    while(i < j) {
	    Swap(nums, i, j);
		i++;
		j--;
	}
}

下面是自底向上的迭代版本。空间复杂度是O(1).

public void Reorder(int[] nums)
{
    int n = nums.Length;

	for(int size = 1; size < n; size += size)
	{
	    for(int low = 0; low < n-size; low+=size+size)
		{
		    Merge(nums, low, Math.Min(low+size+size-1, n-1));
		}
	}
}