栈及其应用(二叉树遍历)

 

495. 实现栈

中文English

实现一个栈，可以使用除了栈之外的数据结构

Example

例1:

输入：
push(1)
pop()
push(2)
top()  // return 2
pop()
isEmpty() // return true
push(3)
isEmpty() // return false

例2:

输入：
isEmpty()

class Stack:
    def __init__(self):
        self.array = []
    """
    @param: x: An integer
    @return: nothing
    """
    def push(self, x):
        # write your code here
        self.array.append(x)

    """
    @return: nothing
    """
    def pop(self):
        # write your code here
        self.array.pop()

    """
    @return: An integer
    """
    def top(self):
        # write your code here
        return self.array[-1]

    """
    @return: True if the stack is empty
    """
    def isEmpty(self):
        # write your code here
        return len(self.array) == 0

144. 二叉树的前序遍历

难度中等226收藏分享切换为英文关注反馈

给定一个二叉树，返回它的 前序 遍历。

 示例:

输入: [1,null,2,3]  
   1
    
     2
    /
   3 

输出: [1,2,3]

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

递归：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return list()
        
        res = list()
        
        res.append(root.val)
        res += self.preorderTraversal(root.left)
        res += self.preorderTraversal(root.right)

        return res

        

非递归：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return list()
        
        node = root
        stack = list()
        res = list()

        while stack or node:
            if node:
                res.append(node.val)
                stack.append(node)
                node = node.left
            else:
                node = stack.pop()
                node = node.right        

        return res

        

94. 二叉树的中序遍历

难度中等433收藏分享切换为英文关注反馈

给定一个二叉树，返回它的中序 遍历。

示例:

输入: [1,null,2,3]
   1
    
     2
    /
   3

输出: [1,3,2]

递归：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return list()

        res = self.inorderTraversal(root.left)
        res += [root.val]
        res+= self.inorderTraversal(root.right)

        return res

非递归：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return list()

        stack = list()
        node = root
        res = list()
        
        while stack or node:
            if node:
                stack.append(node)
                node = node.left

            else:
                node = stack.pop()
                res.append(node.val)
                node = node.right
        
        return res

145. 二叉树的后序遍历

难度困难250收藏分享切换为英文关注反馈

给定一个二叉树，返回它的 后序 遍历。

示例:

输入: [1,null,2,3]  
   1
    
     2
    /
   3 

输出: [3,2,1]

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

递归：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return list()
        
        res = self.postorderTraversal(root.left)
        res += self.postorderTraversal(root.right)
        res+= [root.val]

        return res

 非递归：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return list()
        
        stack = [root]
        res = list()

        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
                
        return res[::-1]

71. 简化路径

难度中等119收藏分享切换为英文关注反馈

以 Unix 风格给出一个文件的绝对路径，你需要简化它。或者换句话说，将其转换为规范路径。

在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （..） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。更多信息请参阅：Linux / Unix中的绝对路径 vs 相对路径

请注意，返回的规范路径必须始终以斜杠 / 开头，并且两个目录名之间必须只有一个斜杠 /。最后一个目录名（如果存在）不能以 / 结尾。此外，规范路径必须是表示绝对路径的最短字符串。

示例 1：

输入："/home/"
输出："/home"
解释：注意，最后一个目录名后面没有斜杠。

示例 2：

输入："/../"
输出："/"
解释：从根目录向上一级是不可行的，因为根是你可以到达的最高级。

示例 3：

输入："/home//foo/"
输出："/home/foo"
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。

示例 4：

输入："/a/./b/../../c/"
输出："/c"

示例 5：

输入："/a/../../b/../c//.//"
输出："/c"

示例 6：

输入："/a//b////c/d//././/.."
输出："/a/b/c"

class Solution:
    def simplifyPath(self, path: str) -> str:
        if not path:
            return ''
            
        stack = []
        path = path.split("/")

        for item in path:
            if item == "..":
                if stack :
                    stack.pop()

            elif item and item != ".":
                stack.append(item)
        
        return "/" + "/".join(stack)

739. 每日温度

难度中等262收藏分享切换为英文关注反馈

根据每日 气温 列表，请重新生成一个列表，对应位置的输出是需要再等待多久温度才会升高超过该日的天数。如果之后都不会升高，请在该位置用 0 来代替。

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

class Solution:
    def dailyTemperatures(self, T: List[int]) -> List[int]:
        if not T:
            return list()
        
        T_len = len(T)
        res = [0 for _ in range(T_len)]
        stack = list()

        for index, value in enumerate(T):
            if not stack:
                stack.append((index, value))
                continue
            
            top_stack_index, top_stack_value = stack[-1]

            while value > top_stack_value:
                res[top_stack_index] = index - top_stack_index
                stack.pop()
                if stack:
                    top_stack_index, top_stack_value = stack[-1]
                else:
                    break
            
            stack.append((index, value))
            
        return res
                

 NC 90 设计getMin功能的栈

实现一个特殊功能的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作。

示例1

输入

[[1,3],[1,2],[1,1],[3],[2],[3]]

返回值

[1,2]

备注:

有三种操作种类，op1表示push，op2表示pop，op3表示getMin。你需要返回和op3出现次数一样多的数组，表示每次getMin的答案

1<=操作总数<=1000000
-1000000<=每个操作数<=1000000
数据保证没有不合法的操作

#
# return a array which include all ans for op3
# @param op int整型二维数组 operator
# @return int整型一维数组
#
class Solution:
    def __init__(self):
        self.stack = []
        self.min_stack = []
        
    def getMinStack(self , op ):
        # write code here
        res = []
        for index in range(len(op)):
            if op[index][0] == 1:
                self.__Push(op[index][1])
            elif op[index][0] == 2:
                self.__Pop()
            else:
                res.append(self.__getMin())
                
        return res
    
    def __Push(self, x):
        self.stack.append(x)
        if not self.min_stack or self.min_stack[-1] >= x:
            self.min_stack.append(x)
            
    def __Pop(self):
        if self.stack:
            if self.stack[-1] == self.min_stack[-1]:
                self.min_stack.pop()
            self.stack.pop()
    
    def __getMin(self):
        return self.min_stack[-1]
    

 NC 123 序列化二叉树

 题目描述

请实现两个函数，分别用来序列化和反序列化二叉树

二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

例如，我们可以把一个只有根节点为1的二叉树序列化为"1,"，然后通过自己的函数来解析回这个二叉树

示例1

输入

{8,6,10,5,7,9,11}

返回值

{8,6,10,5,7,9,11}

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
import collections
class Solution:
    def Serialize(self, root):
        # write code here
        
        if not root:
            return ""
        queue = collections.deque([root])
        res = []
        while queue:
            node = queue.popleft()
            if node:
                res.append(str(node.val))
                queue.append(node.left)
                queue.append(node.right)
            else:
                res.append('None')
        print(res)
        return '[' + ','.join(res) + ']'
        
    def Deserialize(self, data):
        # write code here
        if not data:
            return None
        dataList = data[1:-1].split(',')
        root = TreeNode(int(dataList[0]))
        queue = collections.deque([root])
        i = 1
        while queue:
            node = queue.popleft()
            if dataList[i] != 'None':
                node.left = TreeNode(int(dataList[i]))
                queue.append(node.left)
            i += 1
            if dataList[i] != 'None':
                node.right = TreeNode(int(dataList[i]))
                queue.append(node.right)
            i += 1
        return root

 NC 64 二叉搜索树与双向链表

题目描述

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

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

#
# 
# @param pRootOfTree TreeNode类 
# @return TreeNode类
#
class Solution:
    def Convert(self , pRootOfTree ):
        # write code here
        if not pRootOfTree:
            return None
        stack = self._preorderIravel(pRootOfTree)
        for i in range(1, len(stack)):
            stack[i-1].right = stack[i]
            stack[i].left = stack[i-1]
        return stack[0]
        
    def _preorderIravel(self, root):
        if not root:
            return list()
        
        node = root
        stack = []
        res = list()
        while node or stack:
            if node:
                stack.append(node)
                node = node.left
            else:
                node = stack.pop()
                res.append(node)
                node = node.right
        return res