Python-BinaryTree
前中后序三种遍历方法对于左右结点的遍历顺序都是一样的（先左后右），唯一不同的就是根节点的出现位置。
中序遍历：
先左再根后右
递归实现：
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def MidTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
ans = []
def recurse(root):
if root:
recurse(root.left)
ans.append(root.val)
recurse(root.right)
recurse(root)
return ans
循环实现：
对于树的遍历，循环操作基本上要用到栈(stack)这个结构。对于中序遍历的循环实现，每次将当前结点(curr)的左子结点push到栈中，直到当前结点(curr)为None。这时，pop出栈顶的第一个元素，设其为当前结点，并输出该结点的value值，且开始遍历该结点的右子树。
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def MidTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
stack = []
ans = []
curr = root
while stack or curr:
if curr:
stack.append(curr)
curr = curr.left
else:
curr = stack.pop()
ans.append(curr.val)
curr = curr.right
return ans
先序遍历：
先根再左后右
递归实现：
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
ans = []
def recurse(root):
if root != None:
ans.append(root.val)
recurse(root.left)
recurse(root.right)
recurse(root)
return ans
循环实现:
先看先序遍历。我们仍然使用栈stack，由于前序遍历的顺序是根左右，所以我们每次先打印当前结点curr，并将当前结点push到栈中，然后将左子结点设为当前结点，直到当前结点(curr)为None。pop出栈顶的第一个元素，设其为当前结点，开始遍历该结点的右子树。入栈和出栈条件以及循环结束条件与中序遍历一模一样。
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
stack = []
ans = []
curr = root
while stack or curr:
if curr:
ans.append(curr.val)
stack.append(curr)
curr = curr.left
else:
curr = stack.pop()
curr = curr.right
return ans后序遍历：
先左再右后根
递归实现：
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def postorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
ans = []
def recurse(root):
if root:
recurse(root.left)
recurse(root.right)
ans.append(root.val)
recurse(root)
return ans循环实现：
由于后序遍历的顺序是左右中，我们把它反过来，则遍历顺序变成中右左，再逆序。
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def postorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
stack = []
ans = []
curr = root
while stack or curr:
if curr:
ans.append(curr.val)
stack.append(curr)
curr = curr.right
else:
curr = stack.pop()
curr = curr.left
return ans[::-1]
层次遍历：
层序遍历也可以叫做宽度优先遍历：先访问树的第一层结点，再访问树的第二层结点...然后一直访问到最下面一层结点。在同一层结点中，以从左到右的顺序依次访问。
二叉树的按层输出即从上往下、从左至右依次打印树的节点。每一层输出一行。
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def levelOrder(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
ans = []
queue = [root]
if not root:
return []
while queue:
temp = []
i = 0
numQueue = len(queue) #记录当前层中的结点个数
while i < numQueue: #遍历每一层
curr = queue.pop(0)
temp.append(curr.val)
if curr.left:
queue.append(curr.left)
if curr.right:
queue.append(curr.right)
i += 1
ans.append(temp)
return ans