二叉树的遍历

中序，前序，后序，都是利用栈的思想

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

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

输出: [1,3,2]

树根 - 左子树 - 右子树
递归实现

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root == None:
            return []
        else:
            tree = []
            tree.extend(self.inorderTraversal(root.left))
            tree.append(root.val)
            tree.extend(self.inorderTraversal(root.right))
            return tree

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

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

输出: [1,2,3]

递归实现：左子树-树根- 右子树

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        
        if root == None:
            return []
        else:
            tree = []
            tree.append(root.val)
            tree.extend(self.preorderTraversal(root.left))
            tree.extend(self.preorderTraversal(root.right))
            return tree

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

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

输出: [3,2,1]

递归实现：左子树-右子树-树根

class Solution(object):
   def postorderTraversal(self, root):
       """
       :type root: TreeNode
       :rtype: List[int]
       """
       if root ==None:
           return []
       else:
           tree = []
           tree.extend(self.postorderTraversal(root.left))
           tree.extend(self.postorderTraversal(root.right))
           tree.append(root.val)
           return tree

层次遍历利用队列的思想

二叉树的层次遍历
给定一个二叉树，返回其按层次遍历的节点值。（即逐层地，从左到右访问所有节点）。

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

思路：

利用队列的思想
repeat{
      将树根添加到队列中
      弹出队列的值到输出列表
      添加此树根的左子树和右子树到队列中
 }until 队列为空

python代码

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        outlist = []
        if root == None:
            return outlist
        quene = [root]
        while quene:
            res = []
            i = 0
            queneNumber = len(quene)
            while i< queneNumber:
                point = quene.pop(0)
                res.append(point.val)
                if point.left:
                    quene.append(point.left)
                if point.right:
                    quene.append(point.right)
                i+=1
            outlist.append(res)
        return outlist

二叉树的层序遍历II
给定一个二叉树，返回其节点值自底向上的层次遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其自底向上的层次遍历为：

[
  [15,7],
  [9,20],
  [3]
]

思路：
与102题类似，最后要返回的是反转后的数组
python代码：

class Solution(object):
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if root == None:
            return []
        else:
            quene = [root]
            res = []
            while quene:
                current = []
                nodenum = len(quene)
                for i in range(nodenum):
                    point = quene.pop(0)
                    current.append(point.val)
                    if point.left:
                        quene.append(point.left)
                    if point.right:
                        quene.append(point.right)
                res.append(current)
            return res[-1::-1]

N叉树的遍历

N叉树的遍历的思路与二叉树的类似，主不过N叉树的每一个节点有一个chrldren的属性，是列表用于存储节点的多个孩子，加一个for循环即可。

N叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。

例如，给定一个 3叉树 :
Leetcode.关于树的遍历的一些题目
返回其层序遍历:

[
[1],
[3,2,4],
[5,6]
]