Java学习 - 数据结构与算法 - 有序数组去重详解

问题

给定一个有序数组，要删除数组重复出现的元素，使得每个元素只出现一次，然后返回移除重复数组后的新长度；

示例：

假设给定一个数组 nums = [1,2,4,4]，删除重复出现的元素 4 后，原数组变成 nums = [1, 2, 4]，此时新的数组长度为 3；

解决思路

数组原地操作

数组原地操作，此时无需创建新的数组，只需要在原来的数组上操作即可。相当于首先要找到数组中重复的元素，然后将重复的元素移除，此时就涉及到数组中的删除操作，相关知识点可以看我的另一篇文章 数组的增删改查。

这是一种时间换空间的方法，此时的空间复杂度为 $O(1)$，时间复杂度为 $O(n^2)$，具体实现可以参考如下代码，其中也详细注释了每一步操作。

/**
* 去除有序数组中重复元素并返回数组的新长度
* @param nums
* @return 删除重复元素后数组的新长度
*/
public int removeDuplicates(int[] nums) {
    // 数组初始容量
    int length = nums.length;
    
    // 我们假定数组最后一个元素是唯一的，然后对于其他的每个元素，如果自身与它后边的数相同，那么就删除这个相同的元素
    for(int i = length - 2; i >= 0; i++){
        // 比较当前元素与其后一个元素是否相等
        if(nums[i] == nums[i + 1]){
            // 若相等，则移除后一位，并将所有元素向前移动一位
            for(int j = i + 1; j < length; j++){
                num[j - 1] = nums[j];
            }
            length--;
        }
    }
    
    // 返回数组的新长度
    return length;
}

普通方法

针对数组原地操作算法时间复杂度为 $O(n^2)$，为降低时间复杂度提高算法效率，可以通过空间换时间的做法，通过定义新的数组，从而实现去除重复元素的目的，此时的时间复杂度为 $O(n)$，而空间复杂度也由 $O(1)$ 变成了 $O(n)$。但是有几点需要注意：

1. 临界情况（即数组为空）；
2. 创建新数组时，需要指定其容量，所以需要先求出原数组中无重复元素时的元素个数；
3. 最后则是将原数组中未重复的元素赋值给新数组；

/**
* 去除有序数组中重复元素并返回数组的新长度
* @param nums
* @return 删除重复元素后的新数组
*/
public int[] removeDuplicates(int[] nums) {
    // 临界情况
    if(nums.length == 0){
        return nums;
    }
    
    // 先求出数组中无重复时的元素个数
    int size = 0;
    for(int i = 0; i < nums.length; i++){
        if(i == 0 || nums[i] != nums[i - 1]){
            size++;
        }
    }
    
    // 用于存放不含重复元素的有序数组
    int[] resultArr = new int[size];
    
    int index = 0;
    for(int i = 0; i < nums.length; i++){
        if(i == 0 || nums[i] != nums[i + 1]){
            resultArr[index++] = nums[i];
        }
    }
    
    // 返回新的不含重复元素的有序数组
    return resultArr;    
}

双指针

以上的两种方法要么是以时间换空间，要么是以空间换时间，那我们有没有一种折中的办法，既能保证时间复杂度很低，也能保证空间复杂度呢？答案是：当然有！

利用双指针的思想，既可以将空间复杂度控制在 $O(1)$，也可以将时间复杂度控制在 $O(n)$。

/**
* 去除有序数组中重复元素并返回数组的新长度
* @param nums
* @return 删除重复元素后数组的新长度
*/
public int removeDuplicates(int[] nums) {
 	// 临界情况
    if(nums.length == 0){
        reutrn 0;
    }
    
    int size = 0;
    for(int i = 1; i < nums.length; i++){
        if(nums[size] != nums[i]){
            nums[++size] = nums[i];

        }
    }    
    
    // 返回新长度
    return size + 1;
}

最后

文章向我们展示了三种不同的算法来去除有序数组中的重复元素，每种方法都有其独特的优势和适用场景。

1. 数组原地操作法：这种方法以时间效率为代价，换取空间效率。它通过直接在原数组上进行操作，避免了额外的存储需求，但可能需要更多的时间来处理数组。

2. 普通方法：这种方法通常涉及创建额外的数据结构，如哈希表或集合，来帮助识别重复元素。这种方法牺牲了一定的空间效率，但可以更快地完成去重任务。

3. 双指针方法：这种方法综合了前两种方法的优点。通过使用两个指针，一个用于遍历数组，另一个用于记录下一个非重复元素的位置，这种方法能够在不使用额外空间的情况下，以线性时间 (O(n)) 完成去重。

文章强调了在日常学习中，我们可能更注重于功能的实现，但在实际工作场景中，算法的效率变得至关重要。因此，我们需要根据具体的应用需求来选择最合适的算法。

例如，如果内存使用是一个问题，我们可能会倾向于使用原地操作法；如果速度是关键，普通方法可能更合适；而双指针方法则提供了一个平衡的解决方案，适用于对时间和空间都有要求的场景。

通过这篇文章，我们了解到即使是看似简单的数组去重问题，也涉及到多种算法设计和效率考量。这提醒我们在设计算法时，需要综合考虑时间复杂度和空间复杂度，以及它们如何适应特定的应用需求。