記錄了初步解題思路 以及本地實現程式碼；並不一定為最優 也希望大家能一起探討 一起進步

目錄

• 71. simplify-path 簡化路徑
• 94.binary-tree-inorder-traversal 二叉樹的中序遍歷
• 144.binary-tree-preorder-traversal 二叉樹的前序遍歷
• 150.evaluate-reverse-polish-notation 逆波蘭表示式求值
• 173.binary-search-tree-iterator 二叉搜尋樹迭代器
• 331.verify-preorder-serialization-of-a-binary-tree 驗證二叉樹的前序序列化

71. simplify-path 簡化路徑

解題思路：用/分割字串
判斷每一個字串是否有效 放入stack中
.不做處理 …如果stack不為空則將最後一個彈出 否則將內容放入stack中

def simplifyPath(path):
    """
    :type path: str
    :rtype: str
    """
    l = path.split("/")
    stack = []
    for i in l:
        if i=="" or i==".":
            continue
 

        elif i=="..":
            if stack:
                stack.pop()
        else:
            stack.append(i)
            
    res =""
    for i in stack:
        res+="/"+i
    if res=="":
        res = "/"
    return res

94.binary-tree-inorder-traversal 二叉樹的中序遍歷

解題思路：中序遍歷 左根右

class
 
 TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
def inorderTraversal(root):
    """
    :type root: TreeNode
    :rtype: List[int]
    """
    stack=[]
    def traversal(node):
        if node:
            traversal(node.left)
            stack.append(node.val)
            traversal(node.right)
    traversal(root)
    return stack

144.binary-tree-preorder-traversal 二叉樹的前序遍歷

解題思路：前序遍歷 根左右

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
def inorderTraversal(root):
    """
    :type root: TreeNode
    :rtype: List[int]
    """
    stack=[]
    def traversal(node):
        if node:
            stack.append(node.val)
            traversal(node.left)
            traversal(node.right)
    traversal(root)
    return stack

150.evaluate-reverse-polish-notation 逆波蘭表示式求值

解題思路：把數值放到stack中 遇到運算子取出末尾兩個
不知道為什麼int(y/x) 對於負數的時候在自己的機子上是可以的 就是通不過

def evalRPN(tokens):
    """
    :type tokens: List[str]
    :rtype: int
    """
    stack = []
    
    for i in tokens:
        if i=="+":
            x = stack.pop()
            y = stack.pop()
            res = x+y
            print(y,i,x,res)
            stack.append(res)
        elif i=="-":
            x = stack.pop()
            y = stack.pop()
            res = y-x
            print(y,i,x,res)
            stack.append(res)
        elif i=="*":
            x = stack.pop()
            y = stack.pop()
            res = x*y
            print(y,i,x,res)
            stack.append(res)
        elif i=="/":
            x = stack.pop()
            y = stack.pop()
            if x*y<0:
                res = -((-y)//x)
            else:
                res = y//x
            print(y,i,x,res)
            stack.append(res)
        else:
            stack.append(int(i))
    return stack[0]

173.binary-search-tree-iterator 二叉搜尋樹迭代器

解題思路：左子樹及較小數壓入stack中，每次取出一個值，將其右子樹下的左子樹同樣壓入stack

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class BSTIterator(object):
    def __init__(self, root):
        """
        :type root: TreeNode
        """
        self.stack =[]
        while root:
            self.stack.append(root)
            root = root.left

    def hasNext(self):
        """
        :rtype: bool
        """
        return len(self.stack)>0

    def next(self):
        """
        :rtype: int
        """
        node = self.stack.pop()
        ret = node.val
        node = node.right
        while(node):
            self.stack.append(node)
            node = node.left
        return ret

331.verify-preorder-serialization-of-a-binary-tree 驗證二叉樹的前序序列化

解題思路：1.計算葉節點個數 新增一個數值必定有兩個葉節點（包括#）+2,每一個值也必定是一個葉節點(-1) 最終葉節點剩餘值為0
2.將節點壓入棧中，根據根左右順序如果壓入的是葉節點必定左右為# 及後面兩個為# 則可以將這個葉節點取出用#代替 最終stack中只剩一個#

def isValidSerialization(preorder):
    """
    :type preorder: str
    :rtype: bool
    """
    l = preorder.split(",")
    leaf = 1
    for i in l:
        leaf -=1
        if leaf<0:
            return False
        if i!="#":
            leaf+=2
    return leaf==0
              

def isValidSerialization2(preorder):
        """
        :type preorder: str
        :rtype: bool
        """
        l = preorder.split(",")
        if len(l)>1 and (l[-1]!="#" or l[-2]!="#"):
          return False
        stack =[]
        for i in l:

            stack.append(i)
            if len(stack)<2:
                continue
            while stack[-1]=="#" and stack[-2]=="#":
                if len(stack)==2 or stack[-3]=="#":
                    return False
                stack.pop()
                stack.pop()
                stack.pop()
                stack.append("#")
                if len(stack)==1:
                    break

        if len(stack)==1 and stack[0]=="#":
            return True
        else:
            return False