Question

我的目标是从Java中删除数组中的所有负数。

我写了下面的代码。如何提高代码的复杂性或是否有一个好的算法？

public static void main(String[] args) {
    int[] array = { 1, -3, 4, -9, 3, 4, 70, -10, 0, 7 };
    System.out.println(Arrays.toString(removeNegativeNumbers(array)));
}

public static int[] removeNegativeNumbers(int[] num) {
    List<Integer> list = new ArrayList<>();
    for (int n : num) {
        if (n >= 0) {
            list.add(n);
        }
    }
    int[] result = new int[list.size()];
    for (int i = 0; i < result.length; i++) {
        result[i] = list.get(i).intValue();
    }
    return result;
}

Answer 1

Java 8流怎么样？

Arrays.stream(num).filter(s -> s >= 0).toArray();

Answer 2

如何提高代码的复杂性或是否有一个好的算法？

这是一个具有常量空间的线性// You would go this way if you want to implement something like // Google Instant Search so you don't need to click anything, you perform // searches whenever the <input> changes $scope.$watch(function() { return $scope.searchText; }, function(newValue, oldValue) { // newValue contains current $scope.searchText value });算法（忽略输出数组所需的空间）。当元素为非负数时，复制元素并前进输出数组和输入数组导引头。当元素为负数时，仅前进输入数组导引头（indx）并避免复制到输出数组。

O(n)

节省空间的解决方案

您可以通过将输入数组转换为保持输出（如插入排序方式）来使算法就地，以避免输出数组的空间开销。

public static int[] removeNegativeNumbers(int[] num) {
    int[] output = new int[num.length];
    int k = 0;
    for(int i = 0; i < num.length; i++) {
       if(num[i] >= 0) {
           output[k++] = num[i];
       }
    }
    return Arrays.copyOfRange(output, 0, k);
}

这被称为两指针技术，非常简单但有用，可以解决许多经典难题，如数组重复数据删除，合并两个排序数组，两个排序数组的交集等。

Answer 3

我认为我们在效率方面可以比@ kaidul-islam的答案更好（和@ user6904265在简洁性方面）。

我只是添加一个在特定情况下应该具有某些价值的解决方案，其中很少出现负数且数组非常大。

基本思路是推迟实际副本，直到找到负值，然后使用System.arraycopy进行复制。如果没有找到否定，将返回源数组。

import java.util.*;

public class NotNegativeTest {

    public static void main(String[] args) {
         int[] array = { 1, -3, 4, -9, 3, 4, 70, -10, 0, 7 }; 
         System.out.println(Arrays.toString(removeNegativeNumbers(array))); 
    } 

    public static int[] removeNegativeNumbers(int[] num) {
         int[] output = new int[num.length];
         int k = 0;
         int i = 0; 
         int last=-1;
         int howmany=0;

         while(i < num.length) {
             if(num[i] < 0) {
                howmany=i-last-1;
                switch(howmany) {
                    case 0: break;
                    case 1: 
                            output[k]=num[last+1];
                            k++;
                            break;
                    default:        
                            System.arraycopy(num, last+1,  output, k, howmany);
                            k+=howmany;
                }
                last=i;
             } 
             i++;
         } 
         if (last>=0) {
              if(last!=i-1) {
                howmany=i-last-1;  
                System.arraycopy(num, last+1,  output, k, howmany);
                k+=howmany;
            }
        } else {
            return num;
        }

         return Arrays.copyOfRange(output, 0, k);
     }

}

我找到了编写JMH微基准测试的时间。

我使用过这些配置：

Options opts = new OptionsBuilder()
  .include(MyBenchmark.class.getSimpleName())
  .mode(Mode.AverageTime)
  .warmupIterations(1)
  .warmupTime(TimeValue.seconds(5))
  .measurementIterations(10)
  .measurementTime(TimeValue.seconds(5))
  .jvmArgs("-server")
  .forks(1)
  .build();
new Runner(opts).run();

（免责声明：我的第一次JMH测试，所以如果有人有一些建议，我很乐意改变它并更新结果）

以下是结果：

# Run complete. Total time: 00:02:54

Benchmark                             Mode  Cnt  Score   Error  Units
MyBenchmark.testMethodUser6904265     avgt   10  0,201 ± 0,040   s/op
MyBenchmark.testMethodInsac           avgt   10  0,093 ± 0,022   s/op
MyBenchmark.testMethodKaidul          avgt   10  0,124 ± 0,029   s/op

现在，在为我欢呼之前，请先了解测试的偏见：

 int[] array = new int[10000000];
 array[0]=-5;
 array[10000]=-3;
 array[40000]=-3;
 array[8000000]=-3;

 int[] answer=NotNegativeTest.removeNegativeNumbers(array);

所以在这里要注意的不是我的方法赢了（测试是为我的方法赢得的:-)但是即使在这种极端情况下，通用的kaidul-islam方法也有多接近。

更新：这是指向jmh benchmark I wrote的链接，以便您可以验证更真实的情况（如果有人发现我如何设置测试的问题，请告诉我）。对于我在另一个答案上做过的测试，我对Trove有所依赖。

Answer 4

这将通过一次迭代就地完成：

在原始数组上保留2个索引：src和dst。两者都被初始化为0。

当数字为正数时，将其从num[src]复制到num[dst]并推进两个索引

当数字为负数时，只需提前src。

返回原始数组，其中dst为新大小。

public static int removeNegativeNumbers(int[] num) {
  int dst=0;
  for (int src=0 ; src<num.length ; ++src)
    if (num[src]>=0)
      num[dst++] = num[src];
  return dst;
}

Answer 5

由于您必须查看每个单独的元素以确定它是否小于0，因此运行时必须至少为O（n）。由于存储输入所需的空间是O（n），因此空间至少为O（n）。您的解决方案在O（n）时间内运行时具有O（n）复杂度，因此没有解决方案可以比解决方案具有更好的空间或运行时复杂性

但是，如果我们假设数组已排序，我们可以获得更好的结果。然后，我们进行二进制搜索0.如果我们有一种方法以恒定时间返回子数组（例如C中的指针魔术，或者简单地返回要读取的起始索引），那么算法将具有O（记录时间。

Answer 6

按照以下代码（Java 8）

int test[] = new int[] { 15, -40, -35, 45, -15 };
    // here we can take the test array in to stream and filter with condition (>=0).
    int[] positives = Arrays.stream(test).filter(x -> x >= 0).toArray();

    System.out.println("Here is the positive array elements");

    for (int i : positives) {
        System.out.print(i + "\t");
    }

Answer 7

public static int[] removeNegativeNumbers(int[] num) {
    List<Integer> list = new ArrayList<>();
    for (int n : num) {
        if (n >= 0) {
            list.add(n);
        }
    }
    return list.toArray(new int[list.size()]);
}

在Java中从数组中删除负数

7 个答案:

节省空间的解决方案