对有序int数组去重，并输出去重后的长度，并打印出来，要求时间复杂度为O(n)，空间复杂度为O(1)。 例如：int[] array = {-1,0,0,2,4,4,4,6};长度为：5，打印结果为：-1，0，2，4，6

[whatshappen]

[DarrenHang]

private int[] removeRepeat2(int[] array) {

    HashSet<Integer> hashSet = new HashSet<>();//去重
    for (int i = 0; i < array.length; i++) {
        hashSet.add(array[i]);
    }

    Set<Integer> set = new TreeSet<>(hashSet);//排序
    Integer[] integers = set.toArray(new Integer[]{});

    int[] result = new int[integers.length];
    for (int i = 0; i < result.length; i++) {
        result[i] = integers[i].intValue();
    }

    for (int i : result) {
        Log.d("result>>>>", i + "-");
    }
    return result;
}

1：用 HashSet 去重时并不知道数组的长度，假定数组的长度为 n，去重 for 循环执行的次数随数组的长度 n 成正比，所以时间复杂度为 O ( n )

2：TreeSet 排序后的数组是一个固定长度的数组，它的长度我们用 X 来表示，int[] result = new int[integers.length] 这段代码申请了一个大小为 X 的 int 类型数组，剩下的代码没有占用更多的空间，所以空间复杂度为 O ( 1 )

[whatshappen]

private int[] removeRepeat2(int[] array) {

    HashSet<Integer> hashSet = new HashSet<>();//去重
    for (int i = 0; i < array.length; i++) {
        hashSet.add(array[i]);
    }

    Set<Integer> set = new TreeSet<>(hashSet);//排序
    Integer[] integers = set.toArray(new Integer[]{});

    int[] result = new int[integers.length];
    for (int i = 0; i < result.length; i++) {
        result[i] = integers[i].intValue();
    }

    for (int i : result) {
        Log.d("result>>>>", i + "-");
    }
    return result;
}

1：用 HashSet 去重时并不知道数组的长度，假定数组的长度为 n，去重 for 循环执行的次数随数组的长度 n 成正比，所以时间复杂度为 O ( n )

2：TreeSet 排序后的数组是一个固定长度的数组，它的长度我们用 X 来表示，int[] result = new int[integers.length] 这段代码申请了一个大小为 X 的 int 类型数组，剩下的代码没有占用更多的空间，所以空间复杂度为 O ( 1 )

时间复杂度为O(n) 要求就是不能for循环嵌套，而空间复杂度为O(1)则表示不能创建新的数组或者集合

[DarrenHang]

private int[] removeRepeat2(int[] array) {

    HashSet<Integer> hashSet = new HashSet<>();//去重
    for (int i = 0; i < array.length; i++) {
        hashSet.add(array[i]);
    }

    Set<Integer> set = new TreeSet<>(hashSet);//排序
    Integer[] integers = set.toArray(new Integer[]{});

    int[] result = new int[integers.length];
    for (int i = 0; i < result.length; i++) {
        result[i] = integers[i].intValue();
    }

    for (int i : result) {
        Log.d("result>>>>", i + "-");
    }
    return result;
}

1：用 HashSet 去重时并不知道数组的长度，假定数组的长度为 n，去重 for 循环执行的次数随数组的长度 n 成正比，所以时间复杂度为 O ( n ) 2：TreeSet 排序后的数组是一个固定长度的数组，它的长度我们用 X 来表示，int[] result = new int[integers.length] 这段代码申请了一个大小为 X 的 int 类型数组，剩下的代码没有占用更多的空间，所以空间复杂度为 O ( 1 )

时间复杂度为O(n) 要求就是不能for循环嵌套，而空间复杂度为O(1)则表示不能创建新的数组或者集合

大佬，刚看数据结构和算法，for 循环嵌套的话大概时间复杂度为 O（n^2）,空间复杂度这个有点没有理解。

[ilinqh]

// 有序数组去重，返回新数组长度 private int removeDuplicates(int A[]) { int i = 0; // 第一个指针 int j; // 第二个指针 int n = A.length; if (n <=1 ) return n;
// 遍历数组 for (j = 1; j < n; j++) { if (A[j] != A[i]) { // 若两个指针所指元素不同，则i+1位置保存j所指元素的值 A[++i] = A[j]; } }
return i+1; // 返回新数组的长度 }

这样空间复杂度和时间复杂度都符合要求

[DarrenHang]

// 有序数组去重，返回新数组长度 private int removeDuplicates(int A[]) { int i = 0; // 第一个指针 int j; // 第二个指针 int n = A.length; if (n <=1 ) return n; // 遍历数组 for (j = 1; j < n; j++) { if (A[j] != A[i]) { // 若两个指针所指元素不同，则i+1位置保存j所指元素的值 A[++i] = A[j]; } } return i+1; // 返回新数组的长度 }

这样空间复杂度和时间复杂度都符合要求

感谢解答