leetcode 19 删除链表的倒数第 N 个结点 20 有效的括号

leetcode 19 删除链表的倒数第 N 个结点 20 有效的括号

19. 删除链表的倒数第 N 个结点

难度中等1385收藏分享切换为英文接收动态反馈

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

**进阶：**你能尝试使用一趟扫描实现吗？

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        ans = []
        node = head
        while node:
            ans.append(node)
            node = node.next
        alen = len(ans)
        if alen == 1:
            return None
        elif n == 1:
            ans[alen-2].next = None
        elif n == len(ans):
            return ans[1]
        else:
            ans[alen-n-1].next = ans[alen-n-1].next.next
        return ans[0]

    def removeNthFromEnd2(self, head: ListNode, n: int) -> ListNode:
        ans = []
        d = ListNode(0,head)
        node = d
        while node:
            ans.append(node)
            node = node.next
        for i in range(n):
            ans.pop()
        prev = ans[-1]
        prev.next = prev.next.next
        return d.next

    def removeNthFromEnd3(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0,head)
        first = head
        second  = dummy
        for i in range(n):
            first = first.next

        while first:
            first = first.next
            second = second.next
        second.next = second.next.next
        return dummy.next

if __name__ == '__main__':
    a = [1]
    nodes = []
    for i in range(len(a)):
        nodes.append(ListNode(a[i]))
    for i in range(1,len(a)):
        nodes[i - 1].next = nodes[i]
    a = Solution().removeNthFromEnd3(nodes[0],1)
    while a:
        print(a.val)
        a = a.next

20. 有效的括号

难度简单2426收藏分享切换为英文接收动态反馈

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

有效字符串需满足：

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

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

示例 4：

输入：s = "([)]"
输出：false

示例 5：

输入：s = "{[]}"
输出：true

提示：

• 1 <= s.length <= 104
• s 仅由括号 '()[]{}' 组成

d = {
    "(": ")",
    "{": "}",
    "[": "]"
}
dic={
    ")":"(",
    "}":"{",
    "]":"["
}
class Solution:
    def isValid(self, s: str) -> bool:
        def find_str(i,s: str):
            if len(s) == 0:
                return True
            elif i+1 < len(s):
                if s[i] not in d.keys():
                    return False
                elif d[s[i]] == s[i+1]:
                    return find_str(0,s[0:i]+s[i+2:])
                else:
                    return find_str(i+1,s)
            else:
                return False

        slen = len(s)
        if slen %2 ==1 or s[0] not in d.keys():
            return False
        elif slen == 2:
            return d[s[0]] == s[1]
        left, right = 0, slen - 1
        while right > left:
            if s[left] not in d.keys():
                return False
            if d[s[left]] == s[right] and d[s[left]] != s[left+1]:
                left += 1
                right -= 1
            else:
                break
        if left > right:
            return True
        else:
            return find_str(0,s[left:right+1])

    def isValid2(self, s: str) -> bool:
        stack=[]
        for i in range(len(s)):
            if stack and s[i] in dic:
                if stack[-1] == dic[s[i]]:
                    stack.pop()
                else:
                    return False
            else:
                stack.append(s[i])
        return not stack

if __name__ == '__main__':
    s = "[[[[[[[[[[[[[[[[[[["
    # # print(s[2:])
    # b = list(b)
    # b[3500] = "{"
    # c = "{}{{}}"
    b = "()"
    r = Solution().isValid(b)
    print(r)
        return not stack

if __name__ == '__main__':
    s = "[[[[[[[[[[[[[[[[[[["
    # # print(s[2:])
    # b = list(b)
    # b[3500] = "{"
    # c = "{}{{}}"
    b = "()"
    r = Solution().isValid(b)
    print(r)