1

我有源数组，我想通过从源数组中删除指定数量的元素来从源数组生成新数组，我希望新数组中的元素覆盖源数组中尽可能多的元素（新元素均匀分布在源数组上）并保持第一个和最后一个元素相同（如果有）。

我试过这个：

public static void printArr(float[] arr)
    {
        for (int i = 0; i < arr.length; i++)
            System.out.println("arr[" + i + "]=" + arr[i]);

    }
public static float[] removeElements(float[] inputArr , int numberOfElementToDelete)
    {
       float [] new_arr = new float[inputArr.length - numberOfElementToDelete];
        int f = (inputArr.length  ) / numberOfElementToDelete;
        System.out.println("f=" + f);
        if(f == 1)
        {
            f = 2;
            System.out.println("f=" + f);
        }

       int j = 1 ;
        for (int i = 1; i < inputArr.length ; i++)
        {
            if( (i + 1) % f != 0)
            {

                System.out.println("i=" + i + "   j= " + j);
                if(j < new_arr.length)
                {
                    new_arr[j] = inputArr[i];
                    j++;
                }

            }

        }

        new_arr[0] = inputArr[0];
        new_arr[new_arr.length - 1] = inputArr[inputArr.length - 1];
        return new_arr;
    }
public static void main(String[] args)
    {

        float [] a = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
        a = removeElements(a, 6);
        printArr(a);
    }

我已经测试了(removeElements(a, 5) and removeElements(a, 4) and removeElements(a, 3)) 但是removeElements(a, 6); 给了：

 arr[0]=1.0
arr[1]=3.0
arr[2]=5.0
arr[3]=7.0
arr[4]=9.0
arr[5]=11.0
arr[6]=13.0
arr[7]=15.0
arr[8]=0.0
arr[9]=16.0

问题是 (arr[8]=0.0) 它必须取一个值..如何解决这个问题？是否有任何代码可以删除指定数量的元素（并保持元素分布在源数组上而不在某些元素中生成零）？

编辑 ：

示例：removeElements(a, 1) ==> 从中间移除一个元素 (7) {1,2,3,4,5,6,7,9,10,11,12,13,14,15,16 }

removeElements(a, 2) ==> 删除索引 (4,19) 或 (5,10) 或 (4,10) 处的两个元素（没问题）

removeElements(a, 3) ==> 删除索引 (4,9,14) 或 (4,10, 15) 处的三个元素或（也没有问题）

removeElements(a, 4) ==> 删除索引 (3,7,11, 15) 或 (3,7,11,14) 处的四个元素，例如 .. 我想要的是如果我在源数组中绘制值在（例如 Excel 上的图表）上，我从新数组中绘制值，我必须得到相同的线（或接近它）。

4

3 回答 3

1

我认为您的代码中的主要问题是您将选择绑定到

(inputArr.length  ) / numberOfElementToDelete

这样，您就不会考虑不想删除的第一个和最后一个元素。

一个例子：如果你有一个包含 16 个元素的数组，并且你想删除 6 个元素，这意味着最终数组将有 10 个元素，但是由于第一个和最后一个元素是固定的，你必须从剩下 14 个。这意味着您必须从数组中选择 8/14 (0,57) 个元素（不考虑第一个和最后一个）。这意味着您可以将计数器初始化为零，从第二个开始扫描数组并将分数的值与计数器相加，当计数器的值达到一个新的整数时（例如，在第三个元素处，计数器将达到 1,14）您将有一个元素可以选择并放入新数组。

所以，你可以做这样的事情（伪代码）：

    int newLength = originalLength - toDelete;
    int toChoose = newLength - 2;
    double fraction = toChoose / (originalLength -2)
    double counter = 0;
    int threshold = 1;
    int newArrayIndex = 1;
    for(int i = 1; i < originalLength-1; i++){
        **counter += fraction;**            
        if(integerValueOf(counter) == threshold){
            newArray[newArrayIndex] = originalArray[i];
            threshold++;
            **newArrayIndex++;**
        }

     }
     newArray[0] = originalArray[0];
     newArray[newArray.length-1] = originalArray[originalArray.length-1];

您应该检查特定情况，例如长度为 1 的 originalArray 或删除所有元素，但我认为它应该可以工作。

编辑 这是一个Java实现（即时编写，所以我没有检查空值等）

public class Test {

    public static void main(String[] args){
        int[] testArray = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
        int[] newArray = remove(testArray, 6);
        for(int i = 0; i < newArray.length; i++){
            System.out.print(newArray[i]+" ");
        }
    }

    public static int[] remove(int[] originalArray, int toDelete){  
        if(toDelete == originalArray.length){
            //avoid the removal of all the elements, save at least first and last
            toDelete = originalArray.length-2;
        }
        int originalLength = originalArray.length;
        int newLength = originalLength - toDelete;
        int toChoose = newLength - 2;
        int[] newArray = new int[newLength];
        double fraction = ((double)toChoose) / ((double)originalLength -2);
        double counter = 0;
        int threshold = 1;
        int newArrayIndex = 1;
        for(int i = 1; i < originalLength-1; i++){
            counter += fraction;            
            if(((int)counter) == threshold ||
                //condition added to cope with x.99999999999999999... cases 
               (i == originalLength-2 && newArrayIndex == newLength-2)){
                newArray[newArrayIndex] = originalArray[i];
                threshold++;
                newArrayIndex++;
            }           
         }
         newArray[0] = originalArray[0];
         newArray[newArray.length-1] = originalArray[originalArray.length-1];
         return newArray;
    }
}
于 2012-07-11T10:23:26.107 回答
0

为什么你不能初始化i=0

for (int i = 0; i < inputArr.length; i++) {
        if ((i + 1) % f != 0) {

以下是输出：

arr[0]=1.0
arr[1]=1.0
arr[2]=3.0
arr[3]=5.0
arr[4]=7.0
arr[5]=9.0
arr[6]=11.0
arr[7]=13.0
arr[8]=15.0
arr[9]=16.0
于 2012-07-11T09:51:12.460 回答
0

如果我理解正确，这就是水库采样，即从一个大数组中，通过随机选择创建一个小数组。

于 2012-07-11T10:05:36.613 回答