Question

给定一组正数和负数（无零），我必须以这样的方式排列它们，即正数和负数应该连续排列。

正数和负数的数量可能不相等，即如果没有正数（或负数），则所有剩余的负数（或正数）将附加到数组的末尾。

顺序很重要，即输入数组为{2,-1,-3,-7,-8, 9, 5,-5,-7}，则输出数组应为{2,-1, 9,-3, 5,-7,-8,-5,-7}。代码在O（n）中完成，不使用其他数组。

这是我在java中的解决方案，我再次测试几个案例，它的工作原理。但是，我不确定这是否会在O（n）时间运行。基本上，我先计算正数和负数。然后我有两个索引i = 0和j = 1。 j总是领先一步我。从那里我一直在检查i中的数字是否为正数且j为负数，如果不是，我将遍历数组，直到找到正确位置的下一个正/负并将其移动到正确的位置

非常感谢任何建议。谢谢！

    //array of negative and positive, arrange them so that positive number follow by negative
// if no pos or neg left, the rest append to the array. 
 //should be O(n) no additional array
 public static void alter(int[] a) {
        int pos = 0;
        int neg = 0;
        int index = 0;
        while(c <a.length){
            if(a[index] > 0){
                pos++;
            }
            else neg++;             
            index++;
        }

        int i = 0;
        int j = 1;
        int temp = 0;
        //run until no more positive number or negative number
        while(pos >0 && neg > 0){
            //
            if(a[i] > 0){ 
                pos--;
                if(a[j] < 0){
                    i += 2;
                    j += 2;                 
                    neg--;
                }else // a[j] > 0
                    {
                        while(a[j] > 0){
                        j++;
                        }
                        //a[j] < 0
                    neg--;
                     //move that number to the appropriate place 
                    while(j > i){
                        temp = a[j];
                        a[j] = a[j -1];
                        a[j-1] = temp;
                        j--;                
                    }// end while
                    i += 2;
                    j +=2 ;
                    }           
            }else // a[i] < 0
                 {
                 while(a[i] < 0){
                    i++;
                 }
                 //a[i] > 0
                 //move that number to the appropriate place 
                while(i > (j -1)){
                    temp = a[i];
                    a[i] = a[i-1];
                    a[i-1] = temp;
                    i--;
                }   

            } //end else    
        }

    }

Answer 1

但是，我不确定这是否会在O(n)时间内运行

我不认为它在O(n)中运行。当你必须“找到下一个正确的元素并将其移动到正确的位置”时，你需要

循环遍历数组的其余部分。这意味着对于最坏的情况（在开始时具有所有正元素的数组，以及在结尾处的所有负元素），您将在数组的“未排序”部分的一半上再次循环每个正元素< / LI>
将元素移回正确位置时，可以按位置移动元素。这意味着您再次循环遍历数组的“未排序”部分

如果你不需要使用第三个数组就必须遵守必须遵守顺序的要求，那么你还不确定如何在O(n)中运行它。

Answer 2

是的，可以在 O（n）。

中完成

让我们假设 c 是当前位置。 a [c] 是正数。

1）从 c 向阵列末尾递增 i ，直到 i 指向第一个错误的数字（与之前符号相同的数字），在这种情况下是积极的。）

2）Set j := i;

3）向阵列末尾递增 j ，直到 j 指向带有所需符号的数字（在这种情况下为负数）。

4）Swap a[i] with a[j]。

5）Set c := j;

6）Set j := c + 1;

在每个步骤中，您总是增加 i 或 j 或 c 。 永不减量。变量 i 的增量不得超过 n 次。与 j 和 c 相同。

因此，最大增量数为 3n~O（n）。

Answer 3

PFB我的代码。如果我们将使用Stack，那么它将使我们的问题更容易。

public class AlternatePosNeg {
public static void main(String[] args) {
    int arr[] = { 2, -1, -3, -7, -8, 9, 5, -5, -7 };

    Stack<Integer> pos = new Stack<>();
    Stack<Integer> neg = new Stack<>();

    int i;

    for (i = 0; i < arr.length; i++) {
        if (arr[i] > 0) {
            pos.push(arr[i]);
        } else {
            neg.push(arr[i]);
        }
    }

    int tempArr[] = new int[arr.length];

    i = 0;

    int sizePos = pos.size();
    int sizeNeg = neg.size();

    while (i < tempArr.length) {
        if (sizePos > sizeNeg) {
            if (pos.size() > 0) {
                tempArr[i] = pos.pop();
            }
            if (neg.size() > 0) {
                tempArr[i + 1] = neg.pop();
                i++;
            }
        } else {
            if (neg.size() > 0) {
                tempArr[i] = neg.pop();
            }
            if (pos.size() > 0) {
                tempArr[i + 1] = pos.pop();
                i++;
            }
        }

        i++;
    }

    for (int no : tempArr) {
        System.out.print(no + " ");
    }
}

}

数组中的替代正数和负数

3 个答案: