Algorithm 拆分+；ve和-ve nums

我正在努力解决这个面试问题。我能够得到一个O（N）空间复杂度的O（N）解。我试图找出是否有一个具有O（1）空间的解决方案

问题：

给定正数和负数的未排序数组。创建一个交替的正数和负数数组，而不分别更改正数和负数的相对顺序

输入：

输入的第一行包含一个整数T，表示测试用例的数量。 每个测试用例的第一行是N，N是数组的大小。 每个测试用例的第二行包含N个输入a[]

输出：

打印一组交替的正数和负数。 注意：解决方案应以正数开始

约束条件：

一,≤ T≤ 30 1.≤ N≤ 100 -1000 ≤ a[]≤ 一千

示例：

输入

输出

9 -2 4 -1 5 -5 0 -3 2

import java.util.*；
导入java.lang.*；
导入java.io.*；
GFG类{
公共静态void main（字符串[]args）{
//代码
扫描仪序列号=新扫描仪（System.in）；
int T=sn.nextInt（）；
对于（int i=0；i如果不直接获取数组作为函数的输入，而是必须从标准输入流中读取数字，则意味着您必须自己创建数组。问题还指出：

第一行。。。
第二行

这意味着输入是逐行提供给您的，而不是作为函数的参数

这意味着就空间而言，最好的解决方案是O（n）。您已经找到了一个可行的解决方案，但您仍然可以使用“指针”方法来简化它，就像您自己所说的：

public static void main (String[] args) {
    Scanner sn = new Scanner(System.in);
    int T = sn.nextInt();
    for(int i=0; i<T; i++){
        int N = sn.nextInt();
        int[] numbers = new int[N];
        int neg_ind = 1;
        int pos_ind = 0;

        for(int j=0; j<N; j++){
            int num = sn.nextInt();
            if(num < 0){
                numbers[neg_ind] = num;
                neg_ind += 2;
            }else{
                numbers[pos_ind] = num;
                pos_ind += 2;
            }
        }

        System.out.println(Arrays.toString(numbers));
    }
}

publicstaticvoidmain（字符串[]args）{
扫描仪序列号=新扫描仪（System.in）；
int T=sn.nextInt（）；
对于（int i=0；i如果不直接获取数组作为函数的输入，而是必须从标准输入流中读取数字，则意味着您必须自己创建数组。问题还指出：

第一行。。。
第二行

这意味着输入是逐行提供给您的，而不是作为函数的参数

这意味着就空间而言，最好的解决方案是O（n）。您已经找到了一个可行的解决方案，但您仍然可以使用“指针”方法来简化它，就像您自己所说的：

public static void main (String[] args) {
    Scanner sn = new Scanner(System.in);
    int T = sn.nextInt();
    for(int i=0; i<T; i++){
        int N = sn.nextInt();
        int[] numbers = new int[N];
        int neg_ind = 1;
        int pos_ind = 0;

        for(int j=0; j<N; j++){
            int num = sn.nextInt();
            if(num < 0){
                numbers[neg_ind] = num;
                neg_ind += 2;
            }else{
                numbers[pos_ind] = num;
                pos_ind += 2;
            }
        }

        System.out.println(Arrays.toString(numbers));
    }
}

publicstaticvoidmain（字符串[]args）{
扫描仪序列号=新扫描仪（System.in）；
int T=sn.nextInt（）；
对于（int i=0；iIs，它保证有一个解决方案？即，有相同数量的负整数和正整数（或最多相差1）。我不确定是否有O（N）时间和O（1）的解决方案空间复杂性。我只是想找出解决这个问题的最佳方法。我的意思是问题的解决方案。例如，输入1 5 1 1 1似乎无效。给你的数字是字符串，你必须用扫描仪读取吗？问题表明是这样。@YeshwanthVenkatesh我在我的answ中解释了我的意思呃：）是否保证有一个解决方案？也就是说，有相同数量的负整数和正整数（或者最多相差1）。我不确定O（N）时间和O（1）是否有一个解决方案空间复杂性。我只是想找出解决这个问题的最佳方法。我的意思是问题的解决方案。例如，输入1 5 1 1 1似乎无效。给你的数字是字符串，你必须用扫描仪读取吗？问题表明是这样。@YeshwanthVenkatesh我在我的answ中解释了我的意思呃：）但这真的是空间复杂性吗？因为问题需要你创建一个数组。所以这不能被认为是额外的空间。如果你把它原样读入一个数组，然后创建一个新的数组，然后在代码中应用逻辑，那么它就是
O（n）
space.@thebenman我明白你的意思，但我想说它本质上是一个
O（n）
解决方案，因为问题要求它是
O（n）
solution。由于输入不是以数组的形式给出的，而是以数字流的形式给出的，您必须将其转换为数组，这增加了空间的复杂性。但这真的是
O（n）
空间复杂性。因为问题要求您创建一个数组。因此这不能被视为额外的空间。如果您将它原样读入数组，然后创建一个新数组，然后在代码中应用逻辑，那么它将是
O（n）
O（n）
解。@thebenman我明白你的意思，但我认为它本质上是一个
O（n）
解，因为问题要求它是一个
O（n）
解。由于输入不是以数组的形式给出的，而是以数字流的形式给出的，你必须将其转换为数组，所以它是额外的空间，因此增加了空间的复杂性。
public static void main (String[] args) {
    Scanner sn = new Scanner(System.in);
    int T = sn.nextInt();
    for(int i=0; i<T; i++){
        int N = sn.nextInt();
        int[] numbers = new int[N];
        int neg_ind = 1;
        int pos_ind = 0;

        for(int j=0; j<N; j++){
            int num = sn.nextInt();
            if(num < 0){
                numbers[neg_ind] = num;
                neg_ind += 2;
            }else{
                numbers[pos_ind] = num;
                pos_ind += 2;
            }
        }

        System.out.println(Arrays.toString(numbers));
    }
}