给定一个只包括 '(', ')', '{', '}', '[', ']' 的字符串, 判断字符串是否有效.

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合.
2. 左括号必须以正确的顺序闭合.

注意空字符串可被认为是有效字符串.

题目地址:https://leetcode-cn.com/problems/valid-parentheses/

(看了评论才知道是B站开发岗面试题)

示例

输入: "()"
输出: true

输入: "()[]{}"
输出: true

输入: "(]"
输出: false

输入: "([)]"
输出: false

输入: "{[]}"
输出: true

解答

思路一

class Solution:
    def isValid(self, s):
        while '{}' in s or '()' in s or '[]' in s:
            s = s.replace('{}', '')
            s = s.replace('[]', '')
            s = s.replace('()', '')
        return s == ''

对于正确的来说, 每次都能去掉一对括号, 最后就成了空.

思路二

其实这个题主要是考大家关于栈的应用

原理

• 栈先入后出特点恰好与本题括号排序特点一致, 即若遇到左括号入栈, 遇到右括号时将对应栈顶左括号出栈, 则遍历完所有括号后 stack 仍然为空；

• 建立哈希表dic构建左右括号对应关系：key 左括号, value 右括号；这样查询 2 个括号是否对应只需 $O(1)$ 时间复杂度；建立栈 stack, 遍历字符串s 并按照算法流程一一判断.

流程

如果 c 是左括号, 则入栈 push； 否则通过哈希表判断括号对应关系, 若 stack 栈顶出栈括号 stack.pop() 与当前遍历括号 c 不对应, 则提前返回 false.

提高算法效率

提前返回false

• 边界问题栈 stack 为空： 此时stack.pop()操作会报错；因此, 我们采用一个取巧方法, 给 stack 赋初值 ? , 并在哈希表 dic 中建立 key: '?', value:'?'的对应关系予以配合. 此时当 stack 为空且 c 为右括号时, 可以正常提前返回 false；

• 字符串 s 以左括号结尾： 此情况下可以正常遍历完整个 s, 但 stack 中遗留未出栈的左括号；因此, 最后需返回 len(stack) == 1, 以判断是否是有效的括号组合.

时间复杂度

• 时间复杂度 $O(N)$：正确的括号组合需要遍历 11 遍 s；
• 空间复杂度 $O(N)$：哈希表和栈使用线性的空间大小.

示意图

代码

class Solution:
    def isValid(self, s: str) -> bool:
        dic = {'{': '}',  '[': ']', '(': ')', '?': '?'}
        stack = ['?']
        for c in s:
            if c in dic: stack.append(c)
            elif dic[stack.pop()] != c: return False 
        return len(stack) == 1

原作者:Krahets

问题描述

给定一个非空整数数组, 除了某个元素只出现一次以外, 其余每个元素均出现两次. 找出那个只出现了一次的元素.

题目地址: https://leetcode-cn.com/problems/single-number/

说明

你的算法应该具有线性时间复杂度. 你可以不使用额外空间来实现吗？

示例

输入: [2,2,1]
输出: 1
输入: [4,1,2,1,2]
输出: 4

解答

开始想的是用collection函数来统计次数, 但发现题目的说明讲到了不使用额外的空间, 所以作罢.

后来想用sort来进行排序, 再进行for num in nums进行遍历, 来判断相邻两个是否相同从而找出不同的元素, 但这样O(n)的时间复杂度就太高了. 而且严格来说sort也使用了额外的空间(见下文解释)

python的sort方法

见python源码中的sort实现

int PyList_Sort(PyObject *v)
{
    if (v == NULL || !PyList_Check(v)) {
        PyErr_BadInternalCall();
        return -1;
    }
    v = list_sort_impl((PyListObject *)v, NULL, 0);
    if (v == NULL)
        return -1;
    Py_DECREF(v);
    return 0;
}

使用的是Timsort算法, 从时间复杂度来讲, 这个算法是高效的.

从空间复杂度来讲，需要的开销在数量大的时候会增大.

下面是JSE7 中Timsort实现代码中的一段话，可以很好的说明Timsort的优势：

A stable, adaptive, iterative mergesort that requires far fewer than n lg(n) comparisons when running on partially sorted arrays, while offering performance comparable to a traditional mergesort when run on random arrays. Like all proper mergesorts, this sort is stable and runs O(n log n) time (worst case). In the worst case, this sort requires temporary storage space for n/2 object references; in the best case, it requires only a small constant amount of space.

大体是说，Timsort是稳定的算法，当待排序的数组中已经有排序好的数，它的时间复杂度会小于$n log(n)$。与其他合并排序一样，Timesrot是稳定的排序算法，最坏时间复杂度是$O（n log n）$。在最坏情况下，Timsort算法需要的临时空间是$\frac{n}{2}$，在最好情况下，它只需要一个很小的临时存储空间.

最终解法

异或

1. 交换律：a ^ b ^ c <=> a ^ c ^ b
2. 任何数于0异或为任何数 0 ^ n => n
3. 相同的数异或为0: n ^ n => 0

2 ^ 3 ^ 2 ^ 4 ^ 4等价于 2 ^ 2 ^ 4 ^ 4 ^ 3 => 0 ^ 0 ^3 => 3

class Solution:
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        a = 0
        for num in nums:
            a = a ^ num
        return a