删除元素_力扣笔记

①删除有序数组中的重复项:
1.题目：
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1：
输入：nums = [1,1,2]
输出：2, nums = [1,2]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：
输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

原题链接：26.删除有序数组中的重复项

2.思路：
用双指针法，定义左右指针，当左指针遍历到第一个与原来的元素值不同的元素时，先将右指针加一，再赋值给右指针所指向的元素。

如：

这里默认了第一个元素是有效的，实际应判断数组是否大于0.

3.代码：

class Solution {
    public int removeDuplicates(int[] nums) {
        int size = nums.length;
        if (size == 0)  return 0;
        int i = 0, j = 0;
        while(j < size-1)
        {
            while(j < size - 1&& nums[j] == nums[j+1])
            {
                j++;
            }
            if (j < size - 1 && nums[i] != nums[++j])
            {
                i++;
                nums[i] = nums[j];
            }
        }
        return i+1;
    }
}

笔记：
力扣官方题解的方法：
官方题解

class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        if (n == 0)
        {
            return 0;
        }
        int fast = 1, slow = 1;
        while (fast < n)
        {
            if (nums[fast] != nums[fast-1])
            {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }
}

好的解法来源：解法
笔记：
这种解法采用逐个赋值的方法，重新构建数组。

class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        int j = 0;
        for (int i = 0;i < n;i++)
        {
            if (nums[i] != nums[j])
            {
                j++;
                nums[j] = nums[i];
            }
        }
        return j+1;
    }   
}

②移除元素：
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]

原题链接：27.移除元素

思路：
删除元素这里定义了双指针。其中left表示待插入的元素，right表示当前处理的元素。挨个将nums[right]不为val的值插入到nums[left]中。

代码：

class Solution {
    public int removeElement(int[] nums, int val) {
        int n = nums.length;
        int left = 0;
        for (int right = 0; right < n;right++)
        {
            if (nums[right] != val)
            {
                nums[left] = nums[right];
                left++;
            }
        }
        return left;
    }
}

③删除链表中的重复项：
题目：
编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。

示例1:
输入：[1, 2, 3, 3, 2, 1]
输出：[1, 2, 3]
示例2:
输入：[1, 1, 1, 1, 2]
输出：[1, 2]

原题链接：删除链表中的重复项

思路：
法一：直接通过哈希表，如果元素不存在于哈希表，则插入哈希表；否则删除该节点。

代码：

class Solution {
    public ListNode removeDuplicateNodes(ListNode head) {
        if(head == null)   return head;
        Set<Integer> hash = new HashSet<Integer>();
        ListNode pre = head, cur;
        hash.add(pre.val);
        while (pre.next != null)
        {
            cur = pre.next;
            //当前元素在链表中不存在，插入
            if (!hash.contains(cur.val))
            {
                hash.add(cur.val);
                pre = pre.next;
            }
            //已存在该元素删除
            else
            {
                pre.next = cur.next;
            }
        }
        return head;
    }
}

法二：
采用两重循环，挨个遍历，比较当前元素与其后的元素是否相等，若相等则删除。类似于暴力匹配算法(BruteForce).

代码：

class Solution {
    public ListNode removeDuplicateNodes(ListNode head) {
        ListNode cur = head, p;
        while (cur != null)
        {
            p = cur;
            while (p.next != null)
            {
                if (p.next.val == cur.val)
                {
                    p.next = p.next.next;
                }
                else
                {
                    p = p.next;
                }
            }
            cur = cur.next;
        }
        return head;
    }
}