c++ 两个string比较相等_每天一道力扣题：844. 比较含退格的字符串

每天一道力扣题：844. 比较含退格的字符串

题目

给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。

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

示例 1：

输入：S = "ab#c", T = "ad#c"
输出：true
解释：S 和 T 都会变成 “ac”。

输入：S = "a##c", T = "#a#c"
输出：true
解释：S 和 T 都会变成 “c”。

输入：S = "a#c", T = "b"
输出：false
解释：S 会变成 “c”，但 T 仍然是 “b”。

思路

双栈法，重构字符串

/**
 * @param {string} S
 * @param {string} T
 * @return {boolean}
 */
var backspaceCompare = function(S, T) {
    if (!S && !T) { return true }
    const buildStr = function(str) {
        const stack = []
        let copyStr = ''
        for (let i = 0; i < str.length; i++) {
            const temp = str[i]
            if (temp === '#') {
                stack.pop()
            } else {
                stack.push(temp)
            }
        }
        while(stack.length) {
            copyStr += stack.pop()
        }
        return copyStr
    }
    return buildStr(S) === buildStr(T)
};

时间复杂度O(m+n)。 空间复杂度O(m+n)。

双指针

/**
 * @param {string} S
 * @param {string} T
 * @return {boolean}
 */
var backspaceCompare = function(S, T) {
    if (!S && !T) { return true }
    let i = S.length - 1 // S的索引
    let j = T.length - 1 // T的索引
    let skipSCount = 0 // S针对#的计数器
    let skipTCount = 0 // T针对#的计数器
    // 从后往前遍历S、T
    while(i >= 0 || j >= 0) {
        // 从后往前遍历，如果遇到#说明其左边的字符就应该被删除
        // 针对S、T遍历处理，如果遇到#则对应计数器+1, 索引-1，如果遇到非#同时计数器>0，则计数器-1，索引-1，其他情况跳出循环处理
        while(i >= 0) {
            if (S[i] === '#') {
                skipSCount++
                i--
            } else if (skipSCount > 0) {
                skipSCount--
                i--
            } else {
                break
            }
        }
        while(j >= 0) {
            if (T[j] === '#') {
                skipTCount++
                j--
            } else if (skipTCount > 0) {
                skipTCount--
                j--
            } else {
                break
            }
        }
        // 如果此时两者字符不相等,则肯定不等
        if (i >= 0 && j >= 0 && S[i] !== T[j]) {
            return false
        }
        // 如果此时两者有一个索引为负数，则肯定不等
        if (i >= 0 !==  j >= 0) {
            return false
        }
        i--;
        j--;
    }
    return true
};

时间复杂度O(m+n)。 空间复杂度O(1)。

广告位

觉得有意思点个右下角在看，或者直接关注。