zoukankan      html  css  js  c++  java
  • 栈及其应用(二叉树遍历)

     

    495. 实现栈

    中文English

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

    Example

    例1:

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

    例2:

    输入:
    isEmpty()

     1 class Stack:
     2     def __init__(self):
     3         self.array = []
     4     """
     5     @param: x: An integer
     6     @return: nothing
     7     """
     8     def push(self, x):
     9         # write your code here
    10         self.array.append(x)
    11 
    12     """
    13     @return: nothing
    14     """
    15     def pop(self):
    16         # write your code here
    17         self.array.pop()
    18 
    19     """
    20     @return: An integer
    21     """
    22     def top(self):
    23         # write your code here
    24         return self.array[-1]
    25 
    26     """
    27     @return: True if the stack is empty
    28     """
    29     def isEmpty(self):
    30         # write your code here
    31         return len(self.array) == 0
    View Code

    144. 二叉树的前序遍历

    难度中等

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

     示例:

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

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

    递归:

     1 # Definition for a binary tree node.
     2 # class TreeNode:
     3 #     def __init__(self, x):
     4 #         self.val = x
     5 #         self.left = None
     6 #         self.right = None
     7 
     8 class Solution:
     9     def preorderTraversal(self, root: TreeNode) -> List[int]:
    10         if not root:
    11             return list()
    12         
    13         res = list()
    14         
    15         res.append(root.val)
    16         res += self.preorderTraversal(root.left)
    17         res += self.preorderTraversal(root.right)
    18 
    19         return res
    20 
    21         
    View Code

    非递归:

     1 # Definition for a binary tree node.
     2 # class TreeNode:
     3 #     def __init__(self, x):
     4 #         self.val = x
     5 #         self.left = None
     6 #         self.right = None
     7 
     8 class Solution:
     9     def preorderTraversal(self, root: TreeNode) -> List[int]:
    10         if not root:
    11             return list()
    12         
    13         node = root
    14         stack = list()
    15         res = list()
    16 
    17         while stack or node:
    18             if node:
    19                 res.append(node.val)
    20                 stack.append(node)
    21                 node = node.left
    22             else:
    23                 node = stack.pop()
    24                 node = node.right        
    25 
    26         return res
    27 
    28         
    View Code

    94. 二叉树的中序遍历

    难度中等

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

    示例:

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

    递归:

     1 # Definition for a binary tree node.
     2 # class TreeNode:
     3 #     def __init__(self, x):
     4 #         self.val = x
     5 #         self.left = None
     6 #         self.right = None
     7 
     8 class Solution:
     9     def inorderTraversal(self, root: TreeNode) -> List[int]:
    10         if not root:
    11             return list()
    12 
    13         res = self.inorderTraversal(root.left)
    14         res += [root.val]
    15         res+= self.inorderTraversal(root.right)
    16 
    17         return res
    View Code

    非递归:

     1 # Definition for a binary tree node.
     2 # class TreeNode:
     3 #     def __init__(self, x):
     4 #         self.val = x
     5 #         self.left = None
     6 #         self.right = None
     7 
     8 class Solution:
     9     def inorderTraversal(self, root: TreeNode) -> List[int]:
    10         if not root:
    11             return list()
    12 
    13         stack = list()
    14         node = root
    15         res = list()
    16         
    17         while stack or node:
    18             if node:
    19                 stack.append(node)
    20                 node = node.left
    21 
    22             else:
    23                 node = stack.pop()
    24                 res.append(node.val)
    25                 node = node.right
    26         
    27         return res
    View Code

    145. 二叉树的后序遍历

    难度困难

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

    示例:

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

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

    递归:

     1 # Definition for a binary tree node.
     2 # class TreeNode:
     3 #     def __init__(self, x):
     4 #         self.val = x
     5 #         self.left = None
     6 #         self.right = None
     7 
     8 class Solution:
     9     def postorderTraversal(self, root: TreeNode) -> List[int]:
    10         if not root:
    11             return list()
    12         
    13         res = self.postorderTraversal(root.left)
    14         res += self.postorderTraversal(root.right)
    15         res+= [root.val]
    16 
    17         return res
    View Code

     非递归:

     1 # Definition for a binary tree node.
     2 # class TreeNode:
     3 #     def __init__(self, x):
     4 #         self.val = x
     5 #         self.left = None
     6 #         self.right = None
     7 
     8 class Solution:
     9     def postorderTraversal(self, root: TreeNode) -> List[int]:
    10         if not root:
    11             return list()
    12         
    13         stack = [root]
    14         res = list()
    15 
    16         while stack:
    17             node = stack.pop()
    18             res.append(node.val)
    19             if node.left:
    20                 stack.append(node.left)
    21             if node.right:
    22                 stack.append(node.right)
    23                 
    24         return res[::-1]
    View Code

    71. 简化路径

    难度中等

    以 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"
     1 class Solution:
     2     def simplifyPath(self, path: str) -> str:
     3         if not path:
     4             return ''
     5             
     6         stack = []
     7         path = path.split("/")
     8 
     9         for item in path:
    10             if item == "..":
    11                 if stack :
    12                     stack.pop()
    13 
    14             elif item and item != ".":
    15                 stack.append(item)
    16         
    17         return "/" + "/".join(stack)
    View Code

    739. 每日温度

    难度中等

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

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

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

     1 class Solution:
     2     def dailyTemperatures(self, T: List[int]) -> List[int]:
     3         if not T:
     4             return list()
     5         
     6         T_len = len(T)
     7         res = [0 for _ in range(T_len)]
     8         stack = list()
     9 
    10         for index, value in enumerate(T):
    11             if not stack:
    12                 stack.append((index, value))
    13                 continue
    14             
    15             top_stack_index, top_stack_value = stack[-1]
    16 
    17             while value > top_stack_value:
    18                 res[top_stack_index] = index - top_stack_index
    19                 stack.pop()
    20                 if stack:
    21                     top_stack_index, top_stack_value = stack[-1]
    22                 else:
    23                     break
    24             
    25             stack.append((index, value))
    26             
    27         return res
    28                 
    View Code

     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
    数据保证没有不合法的操作

     1 #
     2 # return a array which include all ans for op3
     3 # @param op int整型二维数组 operator
     4 # @return int整型一维数组
     5 #
     6 class Solution:
     7     def __init__(self):
     8         self.stack = []
     9         self.min_stack = []
    10         
    11     def getMinStack(self , op ):
    12         # write code here
    13         res = []
    14         for index in range(len(op)):
    15             if op[index][0] == 1:
    16                 self.__Push(op[index][1])
    17             elif op[index][0] == 2:
    18                 self.__Pop()
    19             else:
    20                 res.append(self.__getMin())
    21                 
    22         return res
    23     
    24     def __Push(self, x):
    25         self.stack.append(x)
    26         if not self.min_stack or self.min_stack[-1] >= x:
    27             self.min_stack.append(x)
    28             
    29     def __Pop(self):
    30         if self.stack:
    31             if self.stack[-1] == self.min_stack[-1]:
    32                 self.min_stack.pop()
    33             self.stack.pop()
    34     
    35     def __getMin(self):
    36         return self.min_stack[-1]
    37     
    View Code

     NC 123 序列化二叉树

     题目描述
    请实现两个函数,分别用来序列化和反序列化二叉树
    二叉树的序列化是指:把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串,从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改,序列化的结果是一个字符串,序列化时通过 某种符号表示空节点(#),以 ! 表示一个结点值的结束(value!)。
    二叉树的反序列化是指:根据某种遍历顺序得到的序列化字符串结果str,重构二叉树。
    例如,我们可以把一个只有根节点为1的二叉树序列化为"1,",然后通过自己的函数来解析回这个二叉树
    示例1

    输入

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

    返回值

    {8,6,10,5,7,9,11}
     1 # -*- coding:utf-8 -*-
     2 # class TreeNode:
     3 #     def __init__(self, x):
     4 #         self.val = x
     5 #         self.left = None
     6 #         self.right = None
     7 import collections
     8 class Solution:
     9     def Serialize(self, root):
    10         # write code here
    11         
    12         if not root:
    13             return ""
    14         queue = collections.deque([root])
    15         res = []
    16         while queue:
    17             node = queue.popleft()
    18             if node:
    19                 res.append(str(node.val))
    20                 queue.append(node.left)
    21                 queue.append(node.right)
    22             else:
    23                 res.append('None')
    24         print(res)
    25         return '[' + ','.join(res) + ']'
    26         
    27     def Deserialize(self, data):
    28         # write code here
    29         if not data:
    30             return None
    31         dataList = data[1:-1].split(',')
    32         root = TreeNode(int(dataList[0]))
    33         queue = collections.deque([root])
    34         i = 1
    35         while queue:
    36             node = queue.popleft()
    37             if dataList[i] != 'None':
    38                 node.left = TreeNode(int(dataList[i]))
    39                 queue.append(node.left)
    40             i += 1
    41             if dataList[i] != 'None':
    42                 node.right = TreeNode(int(dataList[i]))
    43                 queue.append(node.right)
    44             i += 1
    45         return root
    View Code

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

    题目描述

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

     1 # class TreeNode:
     2 #     def __init__(self, x):
     3 #         self.val = x
     4 #         self.left = None
     5 #         self.right = None
     6 
     7 #
     8 # 
     9 # @param pRootOfTree TreeNode类 
    10 # @return TreeNode类
    11 #
    12 class Solution:
    13     def Convert(self , pRootOfTree ):
    14         # write code here
    15         if not pRootOfTree:
    16             return None
    17         stack = self._preorderIravel(pRootOfTree)
    18         for i in range(1, len(stack)):
    19             stack[i-1].right = stack[i]
    20             stack[i].left = stack[i-1]
    21         return stack[0]
    22         
    23     def _preorderIravel(self, root):
    24         if not root:
    25             return list()
    26         
    27         node = root
    28         stack = []
    29         res = list()
    30         while node or stack:
    31             if node:
    32                 stack.append(node)
    33                 node = node.left
    34             else:
    35                 node = stack.pop()
    36                 res.append(node)
    37                 node = node.right
    38         return res
    View Code
  • 相关阅读:
    程序猿小白博客报道
    UML
    mysql隔离级别相关
    mac使用相关笔记
    git相关
    maven相关
    springboot相关
    guava
    IDEA高效运用技巧
    spring事务相关
  • 原文地址:https://www.cnblogs.com/dede-0119/p/12501932.html
Copyright © 2011-2022 走看看