一个未排序整数数组，有正负数,,,,

[daijope]

一个未排序整数数组，有正负数，重新排列使负数排在正数前面，并且要求不改变原来的 相对顺序 比如： input: 1,7,-5,9,-12,15 ans: -5,-12,1,7,9,15 要求时间复杂度O(N),空间O(1) 。

Java Code!

[getserved]

從后往前排序，如果a(n-1)為負數則a(n-1) = a(n)+a(n-1),a(n) = a(n-1),以LZ的數組為例a(3)=-3,a(4)=9，則交換時為a(n-1) = a(n-1)-a(n) = a(3) - a(4) = -12, a(n) = a(n-1) = 9
這樣應該是滿足O(N)了吧

[SnoopyChen789]

[BanUBB]
#include <stdio.h>
#include <stdlib.h>

static void arrange ( const int x[], int y[], int size )
{
	int	first = 0;
	int last = size;
	int i;

	for (i = 0; i < size; i++) {
		int a = x[i];
		if (a < 0) {
			y[first++] = a;
		} else {
			y[--last] = a;
		}
	}
	first = size;
	while (--first > last) {
		int a = y[first];
		y[first] = y[last];
		y[last++] = a;
	}
}


static int A[] = {1,7,-5,9,-12,15};

int main ( int argc, char *argv[] )
{
	int i;
	int	n = argc - 1;
	int *x, *y;
	if (n > 0 ) {
		x = malloc(n*sizeof(int));
		for (i = 0; i < n; i++) {
			x[i] = atoi(argv[i+1]);
		}
	} else {
		x = A;
		n = sizeof(A) / sizeof(int);
	}

	y = malloc(n*sizeof(int));
	arrange(x,y,n);

	for (i = 0; i < n; i++) {
		printf("%d",y[i]);
		if (i+1 < n) putchar(',');
	}
	putchar('\n');

	return 0;
}
[/BanUBB]

[SnoopyChen789]

[BanUBB]
#include <stdio.h>
#include <stdlib.h>

static int arrange(int x[], int size, int setpos, int getpos)
{
	while (getpos < size) {
		int tmp = x[getpos++];
		if (tmp < 0 ) {
			if (getpos != setpos) x[setpos] = tmp;
			setpos++;
		} else {
			setpos = arrange(x,size,setpos,getpos) - 1;
			x[setpos] = tmp;
			return setpos;
		}
	}

	return getpos;
}


static int A[] = {1,7,-5,9,-12,15};

int main ( int argc, char *argv[] )
{
	int i, pivot;
	int	n = argc - 1;
	int *x;
	if (n > 0 ) {
		x = malloc(n*sizeof(int));
		for (i = 0; i < n; i++) {
			x[i] = atoi(argv[i+1]);
		}
	} else {
		x = A;
		n = sizeof(A) / sizeof(int);
	}

	pivot = arrange(x,n,0,0);
	for (i = 0; i < n; i++) {
		if (i > 0) {
			if (i == pivot)
				printf(" || ");
			else
				printf(",");
		}
		printf("%d",x[i]);
	}
	printf("\n");

	return 0;
}
[/BanUBB]

[SnoopyChen789]

#include <stdio.h>
#include <stdlib.h>

static void arrange ( const int x[], int y[], int size )
{
	int	first = 0;
	int last = size;
	int i;

	for (i = 0; i < size; i++) {
		int a = x[i];
		if (a < 0) {
			y[first++] = a;
		} else {
			y[--last] = a;
		}
	}
	first = size;
	while (--first > last) {
		int a = y[first];
		y[first] = y[last];
		y[last++] = a;
	}
}


static int A[] = {1,7,-5,9,-12,15};

int main ( int argc, char *argv[] )
{
	int i;
	int	n = argc - 1;
	int *x, *y;
	if (n > 0 ) {
		x = malloc(n*sizeof(int));
		for (i = 0; i < n; i++) {
			x[i] = atoi(argv[i+1]);
		}
	} else {
		x = A;
		n = sizeof(A) / sizeof(int);
	}

	y = malloc(n*sizeof(int));
	arrange(x,y,n);

	for (i = 0; i < n; i++) {
		printf("%d",y[i]);
		if (i+1 < n) putchar(',');
	}
	putchar('\n');

	return 0;
}

[lhttlf1]

int a[5]={7,-5,9,-12,15};
for(int i=0;i<5;i++}
{
int pas=0;
//如果小于0就位置交换，但是如果前面没有正数就不交换
if(a[i]<0)
{
if(pas<i)
{
//a[i]与a[pas]数据交换
int temp = a[i];
a[i] = a[pas];
a[pas] = temp;
}
pas++;
}
}
要求时间复杂度O(N),空间O(1)

[jjjiaml]

学习一下。

[xues]

懒得用Java这种弱智语言.用C给出一个很笨的算法,满足你的条件
void sort(int vec[], int len)
{
int i=0;
int j=len-1;
int tmp;
while(i<j)
{
while(vec[i]<0)
i++;
while(vec[j]>=0)
j--;
if( i<j)
{
tmp = vec[i];
vec[i] = vec[j];
vec[j] = tmp;
}

}
}

[猪小娣]

remark

[lsongiu86]

貌似都要用到两次for循环呢

[tedcy]

[Quote=引用 138 楼 genivs007 的回复:]

但是如果你这个排序只是要做到负数放左边正数放右边的话，那么利用类似快速排序的方法就行了。利用两个指针分别从头尾开始，头部的指针遇到正的就停，尾部的遇到负的就停，然后交换。当两个指针相遇的时候就结束了。
[/Quote]
要求稳定

[tedcy]

[Quote=引用 139 楼 is_zhoufeng 的回复:]

Java code

/负数排在正数前面，并且要求不改变原来的 相对顺序
public List<Integer> sort(int[] arry){
ArrayList<Integer> list = new ArrayList();
for(int a : arry){
if(a < 0){
l……
[/Quote]
能链表就无意义了

[tedcy]

[Quote=引用 151 楼 nicholas_lin 的回复:]

要满足时间复杂度O(N)，空间复杂度O(1)，也就是只能使用有限次循环（嵌套循环，递归基本都不用考虑），且不能用数组、列表、链表等集合结构，只能用有限个临时变量缓存数据。

主要困难在有限次循环的过程中，移动元素不能影响原来的顺序，我的解法中需要使用冒泡，和时间复杂度冲突。

想了一个晚上，没有想出解法。坐等高手。
[/Quote]
在移动的时候出现逆序，而通过一定的算法消除逆序，应该就是本题核心了。
也许可以转换为一个哈密顿通路的问题。如何安排路径，使该元素重新回到原位置。
唉- =不会

[Jobernowl]

看楼主这么久都没结帖 我就贴出比较简单易懂的代码吧

public   class   Test   { 
    
	public static int[] psortArray(int[] sourceArray){
		int length=sourceArray.length;
		int[] temp=new int[length];
		List<Integer> indexArray=new ArrayList<Integer>();
		for(int i=0;i<length;i++){
			if(sourceArray[i]<0){
				indexArray.add(i);
			}
		}
		int j=indexArray.size();
		for(int i=0;i<j;i++){
			temp[i]=sourceArray[indexArray.get(i)];
		}
		for(int i=0;i<length;i++){
			if((j<length)&&sourceArray[i]>0){
				temp[j]=sourceArray[i];
				j++;
			}
		}
		return temp;
	}
	
	public static void main(String[] args) {
		int[] test={10,9,7,-5,9,-12,15};
		System.out.println(Arrays.toString(psortArray(test)));
	}
}

控制台输出结果是：[-5, -12, 10, 9, 7, 9, 15]

[林二棍子]

要满足时间复杂度O(N)，空间复杂度O(1)，也就是只能使用有限次循环（嵌套循环，递归基本都不用考虑），且不能用数组、列表、链表等集合结构，只能用有限个临时变量缓存数据。

主要困难在有限次循环的过程中，移动元素不能影响原来的顺序，我的解法中需要使用冒泡，和时间复杂度冲突。

想了一个晚上，没有想出解法。坐等高手。

[daijope]

看来不一定实现的了了，不过开动一下脑筋也是值了，，

[Jobernowl]

[Quote=引用 151 楼 nicholas_lin 的回复:]
要满足时间复杂度O(N)，空间复杂度O(1)，也就是只能使用有限次循环（嵌套循环，递归基本都不用考虑），且不能用数组、列表、链表等集合结构，只能用有限个临时变量缓存数据。

主要困难在有限次循环的过程中，移动元素不能影响原来的顺序，我的解法中需要使用冒泡，和时间复杂度冲突。

想了一个晚上，没有想出解法。坐等高手。
[/Quote]
不能用数组？ 要是能用就好了

[new_happly]

来学习以下

[怀念十月]

真的学习了,,原来代码还有这么多学问.

[m540920181]

[Quote=引用楼主 daijope 的回复:]
一个未排序整数数组，有正负数，重新排列使负数排在正数前面，并且要求不改变原来的 相对顺序 比如： input: 1,7,-5,9,-12,15 ans: -5,-12,1,7,9,15 要求时间复杂度O(N),空间O(1) 。

Java Code!
[/Quote]
要求时间复杂度O(N),空间O(1) 这是什么意思啊

[wandouprincess]

你这个不是O（1）的空间吧

引用 150 楼 sasuke38 的回复:

看楼主这么久都没结帖 我就贴出比较简单易懂的代码吧 Java code?1234567891011121314151617181920212223242526272829public class Test { public static int[] psortArray(int[] sourceArray){ int le……