Question

我刚刚开始编写LeetCode问题。问题如下：给定一个排序数组，删除重复项，使每个元素只出现一次并返回新长度。

不要为另一个数组分配额外的空间，必须使用常量内存来执行此操作。

我的解决方案如下：

public static int removeDuplicates1(int[] A) {
        Set<Integer> mySet = new HashSet<Integer>();

        for(Integer i: A){
            mySet.add(i);
        }
        return mySet.size();
    }

即使我在Eclipse中得到了正确的答案，我的答案也没有被网站接受。有谁能告诉我出了什么问题？

Answer 1

如果对数组进行了排序，则可以直接比较重复项的连续元素，直到找到不同的元素。一旦完成循环，就可以使用数组长度属性返回新的长度。

显然，你必须在某些地方管理你的逻辑才能做同样的事情。

Answer 2

我尝试用以下逻辑来解决这个问题。虽然没有到位阵列分配。仍然不确定如何使用就地逻辑从数组中删除null。

 public static void main(String[] args) {

            Integer[] initArray = { 2, 3, 4, 4, 5, 6, 7, 8, 8, 9, 10, 11 };
            System.out.println("Initial Array : "+ Arrays.toString(initArray));

            System.out.println("Array Size After  Duplicates Removal : "+ removeDuplicates(initArray));
        }

    public static int removeDuplicates(Integer[] arr) {

        Integer prev = null;
        for(int index= 0; index <= arr.length -1;  index ++){
            if(arr[index] == prev)
            {
                remove(index, arr);
                prev = arr[index];
            }else{
                prev = arr[index];
                continue;
            }
        }

        List<Integer> items = new ArrayList<Integer>(arr.length);
        for(Integer input : arr) {
           if (input != null) {
              items.add(input);
           }
        }
        Integer[] outputs = items.toArray(new Integer[items.size()]);
        System.out.println("Final Array : "+ Arrays.toString(outputs));
        return outputs.length;
    }

    public static void remove(int index, Integer[] a){

        int lastIndex = a.length-1;
        if(index <= lastIndex){
            a[index] =null;
            int tmp = index;
            while(tmp < lastIndex){
                a[tmp] = a[tmp+1];
                a[tmp+1] = null;
                tmp++;
            }
            lastIndex--;
        } else {
            throw new ArrayIndexOutOfBoundsException();
        }

    }

从数组中删除双精度数

2 个答案: