双指针法 283移除零 844比较合适退格的字符串

双指针法

题目

283.移除零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

思路

可以使用多种方法来在不复制数组的情况下将数组中的所有 0 移动到末尾，同时保持非零元素的相对顺序。下面是几种在 Java 中实现的方案。

方法 1：双指针法

使用两个指针：slow 指针用于指向非零元素应该放置的位置，fast 指针用于遍历数组。如果 fast 指针指向的元素非零，则将该元素赋值到 slow 指针的位置，并将 slow 向右移动一位。

public void moveZeroes(int[] nums) {
    int slow = 0;
    // 遍历数组，将所有非零元素移动到数组的前面
    for (int fast = 0; fast < nums.length; fast++) {
        if (nums[fast] != 0) {
            nums[slow] = nums[fast];
            slow++;
        }
    }
    // 将 slow 指针后面的所有元素设为 0
    while (slow < nums.length) {
        nums[slow] = 0;
        slow++;
    }
}

方法 2：双指针 + 交换

在这种方法中，我们只要找到 fast 指针指向的非零元素，就将其与 slow 指针位置的元素进行交换。这样会将所有非零元素移动到前面，同时将 0 移到后面。

public void moveZeroes(int[] nums) {
    int slow = 0;
    for (int fast = 0; fast < nums.length; fast++) {
        if (nums[fast] != 0) {
            // 交换非零元素到前面
            int temp = nums[slow];
            nums[slow] = nums[fast];
            nums[fast] = temp;
            slow++;
        }
    }
}

方法 3：计数法

先遍历数组，统计非零元素的数量，同时将非零元素按顺序放置到数组的前面。然后，从最后一个非零元素的索引开始，将剩余的元素设为 0。

public void moveZeroes(int[] nums) {
    int index = 0;
    // 将所有非零元素移动到数组前面
    for (int num : nums) {
        if (num != 0) {
            nums[index] = num;
            index++;
        }
    }
    // 剩余的位置填充 0
    while (index < nums.length) {
        nums[index] = 0;
        index++;
    }
}

方法 4：Java Streams （适用于 JDK 8+）

此方法使用 Java 的 Stream API，尽管不能直接改变数组，但可以生成新的有序数组，然后将其赋回给原数组。

import java.util.Arrays;

public void moveZeroes(int[] nums) {
    int[] result = Arrays.stream(nums)
            .filter(num -> num != 0)
            .toArray();
    System.arraycopy(result, 0, nums, 0, result.length);
    Arrays.fill(nums, result.length, nums.length, 0);
}

选择方法

通常情况下，方法 1 和方法 2 是最常用的，因为它们在不增加额外空间的情况下完成了操作，并且效率较高。

844.比较含退格的字符串

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

思路

可以通过使用栈或双指针的方法来实现。以下是两种方法的 Java 代码。

方法 1：使用栈

利用栈来模拟退格的过程。每次遇到正常字符就压入栈中，遇到 # 时就从栈中弹出一个字符（如果栈不为空）。最后比较两个栈是否相等即可。

import java.util.Stack;

public class Solution {
    public boolean backspaceCompare(String s, String t) {
        return build(s).equals(build(t));
    }

    private String build(String str) {
        Stack<Character> stack = new Stack<>();
        for (char c : str.toCharArray()) {
            if (c != '#') {
                stack.push(c);
            } else if (!stack.isEmpty()) {
                stack.pop();
            }
        }
        // 将栈中的字符转化为字符串
        return String.valueOf(stack);
    }
}

方法 2：双指针法（从后向前遍历）

从后向前遍历字符串，跳过退格字符和它影响的字符。每次从后向前找到一个有效字符进行比较，如果两个字符串的有效字符序列相等，则返回 true。

public class Solution {
    public boolean backspaceCompare(String s, String t) {
        int i = s.length() - 1;
        int j = t.length() - 1;
        
        while (i >= 0 || j >= 0) {
            int skipS = 0, skipT = 0;
            
            // 找到 s 中下一个有效字符
            while (i >= 0) {
                if (s.charAt(i) == '#') {
                    skipS++;
                    i--;
                } else if (skipS > 0) {
                    skipS--;
                    i--;
                } else {
                    break;
                }
            }
            
            // 找到 t 中下一个有效字符
            while (j >= 0) {
                if (t.charAt(j) == '#') {
                    skipT++;
                    j--;
                } else if (skipT > 0) {
                    skipT--;
                    j--;
                } else {
                    break;
                }
            }
            
            // 比较两个有效字符
            if (i >= 0 && j >= 0 && s.charAt(i) != t.charAt(j)) {
                return false;
            }
            // 检查是否有一个字符串遍历结束而另一个没有
            if ((i >= 0) != (j >= 0)) {
                return false;
            }
            
            i--;
            j--;
        }
        
        return true;
    }
}

选择方法

• 方法 1（栈）：简单易懂，但需要额外的空间来存储字符。
• 方法 2（双指针）：空间效率更高，因为不需要额外的数据结构。

双指针方法的效率和空间复杂度都更优，所以在此问题上通常推荐使用双指针法。