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

 

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

 

posted @ 2020-03-24 11:05  aiwenhua_0610  阅读(218)  评论(0)  编辑  收藏  举报