一个面试题

[圣诞老人123]

百度面试题，假设一整型数组存在若干正数和负数，现在通过某种算法使得该数组的所有负数在正数的左边，且保证负数件和正数间元素相对位置不变。时空复杂度要求分别为：o(n),o(1)
例如
-3 4 2 -1 7 3 -5
排序后
-3 -1 -5 4 2 7 3

[downmooner]

题目空间复杂度要求01.

[ringer564597]

题目要求是O(1)空间复杂度。。
[Quote=引用 14 楼 ringer564597 的回复:]
哎，我会错意了，是O(n)，看成O(1)了。。

引用 12 楼 luciferisnotsatan 的回复:
引用 8 楼 xubin_sh 的回复:

4#空间复杂度是O(n*2)

O(n)吧，多了个临时的b[10] = {0};。而且O(2n)简化后就是O(n)。
[/Quote]

[luciferisnotsatan]

[Quote=引用 16 楼 ringer564597 的回复:]

题目要求是O(1)空间复杂度。。
引用 14 楼 ringer564597 的回复:
哎，我会错意了，是O(n)，看成O(1)了。。

引用 12 楼 luciferisnotsatan 的回复:
引用 8 楼 xubin_sh 的回复:

4#空间复杂度是O(n*2)

O(n)吧，多了个临时的b[10] = {0};。而且O(2n)简化后就是O(n)。
[/Quote]
嗯。

这题还真有点难度，要是链表就容易了。

[ringer564597]

我觉得可以反正它无解。。

[Quote=引用 17 楼 luciferisnotsatan 的回复:]
引用 16 楼 ringer564597 的回复:

题目要求是O(1)空间复杂度。。
引用 14 楼 ringer564597 的回复:
哎，我会错意了，是O(n)，看成O(1)了。。

引用 12 楼 luciferisnotsatan 的回复:
引用 8 楼 xubin_sh 的回复:

4#空间复杂度是O(n*2)

O(n)吧，多了个临时的b[10] = {0};。……
[/Quote]

[knightzhuwei]

[Quote=引用 18 楼 ringer564597 的回复:]

我觉得可以反正它无解。。

引用 17 楼 luciferisnotsatan 的回复:
引用 16 楼 ringer564597 的回复:

题目要求是O(1)空间复杂度。。
引用 14 楼 ringer564597 的回复:
哎，我会错意了，是O(n)，看成O(1)了。。

引用 12 楼 luciferisnotsatan 的回复:
引用 8 楼 xubin_sh 的回……
[/Quote]
如何反证？

[luciferisnotsatan]

移动中间某块连续正数元素的时间不是常量O(1)，链表的话就行了。

目前也觉得无解。即使是多次遍历，O(cn)的时间。

[sea313081574]

坐等高手，实在没办法了。

[chen_ya_ping]

 //int[] arr = new int[]{ -3, 4 ,2 ,-1 ,7 ,3 ,-5  };
           // int[] arr = new int[] { -3,  -1, -5 };
           //int[] arr = new int[] { 3, 4, 2, -1, 7, -3, -5 };
            // int[] arr = new int[] { 3,  1, 5 };
          //  int[] arr = new int[] { 3, 4, 2, -1, 7, -3, 5 };
            int[] arr = new int[]{ -3, -4 ,2 ,-1 ,7 ,3 ,-5  };
            OutPutArr(arr);
            RangeArr(arr);
            Console.WriteLine();
            OutPutArr(arr);

 private static void OutPutArr(int[] arr)
        {
            foreach (int i in arr)
            {
                Console.Write(string.Format("{0},", i));
            }
        }

private static void RangeArr(int[] arr)
        {
            int k=-1;
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] < 0)
                {
                    if (i > k && i - k > 1)
                    {
                        int j=i;
                        while (j-1>k)
                        {
                            int t = arr[j];
                            arr[j] = arr[j - 1];
                            arr[j - 1] = t;
                            j--;
                        }
                        k =j;
                    }
                    else
                    {
                        k = i;
                    }
                }
            }
        }

[chen_ya_ping]

如果要是可以减少其中的while的话，时间就可以减少到o(n)

[luuillu]

我也想不出解决方法。
假如存在这个算法，那么可以用这个算法改进快速排序。得到一个稳定的快速排序算法。
可以用这个算法去替换快速排序算法中的划分算法，因为它能保证负数件和正数间元素相对位置不变，所以改进后的快速排序是稳定的。

[TitanQuest]

如果让使用 memmove的话，可以满足结果

int a[10] = {2, 5, -4, 6, -2, 9, -11, 99, 56, -12};
  int ilen = sizeof(a)/sizeof(int) -1, i, ipos[2] = {0}, itemp = 0, bfirst = 1;
  for(i = 0; i <= ilen; i++){
    printf(" i = %d, a[i] = %d \n", i, a[i]);
    if(a[i] > 0){
      if(bfirst){
        ipos[0] = i;
        bfirst = 0;
      }
      ipos[1]++;
    }
    if(a[i] < 0){
      if(ipos[1]){
        itemp = a[i];
        memmove(&a[ipos[0] + 1], &a[ipos[0]], (sizeof(int)) * ipos[1]);
        a[ipos[0]] = itemp;
        ipos[0]++;
      }
    }
  }

[shenyan008]

从连端分别开始，左边遇到正数停，右边遇到负数停，然后交换，接下来不同时，右边继续前进的时候的时候，遇到正数，需要和前面的正数交换，以保证正确的顺序。
稍后上代码。

[shenyan008]

从两端分别开始，左边遇到正数停，右边遇到负数停，然后交换，接下来不同的是，右边继续前进的时候的时候，遇到正数，需要和前面的正数交换，以保证正确的顺序。

[TitanQuest]

楼上的，你是写不出来代码滴

[shi3590]

[Quote=引用 27 楼 shenyan008 的回复:]
从两端分别开始，左边遇到正数停，右边遇到负数停，然后交换，接下来不同的是，右边继续前进的时候的时候，遇到正数，需要和前面的正数交换，以保证正确的顺序。
[/Quote]
提醒一下，正数那块不是交换，而是每次插入到队尾。

[shenyan008]

[Quote=引用 28 楼 titanquest 的回复:]
楼上的，你是写不出来代码滴
[/Quote]
写的过程发现，如果要保证空间O(1)，无法保证时间O(n)，不断交换的不是一个数，而是前面交换的所有数。

[二进制浮游]

整了一下还是达不到要求，求高人了。

[gzyyan249]

本想写一个的 但是看了大牛们的回复，想写的心情都没了。。。。

[wangjj89621]

这个真的很难哟！

[leo_dengzx]

没搞定。