LeetCode:Valid Parentheses && Remove Duplicates from Sorted Array

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

    Open brackets must be closed by the same type of brackets.
    Open brackets must be closed in the correct order.

Note that an empty string is also considered valid.

Example 1:

Input: "()"
Output: true

Example 2:

Input: "()[]{}"
Output: true

Example 3:

Input: "(]"
Output: false

题目需要求解的是让括号进行匹配，自己的想法又是想先把（）这种直接闭合的括号先找出来，再把那些融合的括号进行配对，但是写着写着感觉代码量比较大，这是一道简单的题，应该是自己的思路出了问题，就开始看了其他人的求解方式，官方解答和其他人的解答都是通过栈来求解的，自己虽然学过一些的数据结构，但是基本上全忘了，需要好好补一补了。直接贴出了官方的解答，当做是对自己的一个警醒吧。

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        mapping = {")": "(", "}": "{", "]": "["}
        
        for char in s:
            
            if char in mapping:
                    top_element = stack.pop() if stack else '#'
                    if mapping[char] != top_element:
                        return False
            else:
                stack.append(char) 
        return not stack

思想就是利用栈先进后出的结构特点，当出现了右括号后，肯定是得与栈顶元素进行匹配，若是匹配成功了则该括号是正确匹配，算法继续，如果没有匹配成功的话就证明是无效的。当所有的都匹配成功之后，就变成了空栈。最后判断判断空栈即可。

 

 

后来又翻了翻讨论区，在讨论区里面找到了一个和我开始想法相类似的解题思路，以及作者使用了一个我完全不熟悉的函数replace，就比我开始自己写的代码少了很多冗余，还是自己对Python基本用法不太熟悉，得多练多看！！

class Solution:
    def isValid(self, s):
        if len(s)%2 != 0:
            return False
        while '{}' in s or '()' in s or '[]' in s:
            s = s.replace('{}', '')
            s = s.replace('[]', '')
            s = s.replace('()', '')
        return s == ''

因为一个有效的匹配括号在其最内部一定是存在一个闭合的括号的，当去除掉这对括号之后又会出现一个新的闭合括号，最终都会匹配完成为一个空的字符串，最终的输出只要判断他是不是空字符串就行了。

 

 

Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

Example 1:

Given nums = [1,1,2],

Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.

It doesn't matter what you leave beyond the returned length。

题目的要求是让去除一个排好序的列表中重复元素，并且只能够在原来的列表上操作，不能够增加另外的空间复杂度，返回的结果是不重复数据的长度。

第一个想法是使用字典先找到没有重复的数据，再进行排序放在原来的列表上，代码如下：

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        flag = 0
        for i in sorted(set(nums)):
            nums[flag] = i 
            flag += 1
        return len(set(nums))

但是这样确实用了额外的空间，虽然不是列表空间，但是跑出来的空间复杂度蛮高的。

第二种思路就是使用了指针的思想，一个是用来更换不同数据的指针，一个是用来遍历整个列表找到不同数据的指针，从而来去除冗余的数据，代码如下：

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if len(nums) == 0:
            return 0
        flag = 0
        for i in range(len(nums)-1):
            if nums[flag] != nums[i+1]:
                nums[flag+1] = nums[i+1]
                flag += 1 
                
        return flag+1
            

这个方案满足了题目的要求，就增加了O(1)的空间复杂度，但是时间效率低了很多，不过还是满足了要求了。这个思路和大多是讨论区的思路类似，就不贴其他人的代码了。