lintcode练习-66.67.68.二叉树的三种递归遍历和非递归遍历

 

二叉树的先序， 中序， 后序遍历 都是属于深度优先遍历。

 

 

 

直接上代码：

先序遍历：

 

 

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

class Solution:
    """
    @param root: A Tree
    @return: Preorder in ArrayList which contains node values.
    """
    def preorderTraversal(self, root):
        # write your code here
        self.results = []
        self.traverse(root)
        return self.results

    def traverse(self, root):
        if root is None:
            return
        self.results.append(root.val)
        self.traverse(root.left)
        self.traverse(root.right)


# 非递归版本
class Solution1:
    def preorderTraversal(self, root):
        if root is None:
            return []
        stack = [root]
        preorder = []
        while stack:
            node = stack.pop()
            preorder.append(node.val)
            if node.right:  # 先放入右子树
                stack.append(node.right)
            if node.left:  # 再放入左子树， 这样能保证左子树先被弹出
                stack.append(node.left)
        return preorder

 

 

中序遍历：

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

class Solution:
    """
    @param root: A Tree
    @return: Inorder in ArrayList which contains node values.
    """

    def inorderTraversal(self, root):
        # write your code here
        self.results = []
        self.traverse(root)
        return self.results

    def traverse(self, root):
        if root is None:
            return
        self.traverse(root.left)
        self.results.append(root.val)
        self.traverse(root.right)


# 添加所有最左边节点到栈。
# pop stack 然后添加到结果。
# 查找当前node的右边节点是否为空， 如果不为空，重复step 1。

class Solution:
    def inorderTraversal(self, root):
        if root is None:
            return []
        stack = []
        inorder = []
        while root:
            stack.append(root)
            root = root.left

        while stack:
            node = stack.pop()
            inorder.append(node.val)

            if node.right:
                node = node.right
                while node:
                    stack.append(node)
                    node = node.left
        return inorder

 

 

 

后序遍历：

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


class Solution:
    """
    @param root: A Tree
    @return: Preorder in ArrayList which contains node values.
    """
    def preorderTraversal(self, root):
        # write your code here
        self.results = []
        self.traverse(root)
        return self.results

    def traverse(self, root):
        if root is None:
            return
        self.traverse(root.left)
        self.traverse(root.right)
        self.results.append(root.val)



# 二叉树的非递归后序遍历
#
# 在实现遍历的循环中维持一种不变的关系：
#
# 栈中结点序列的左边是二叉树已遍历过的部分，右边是尚未遍历的部分
# 如果curNode不空，其父结点就是栈顶结点
# curNode空时，栈顶就是应访问的结点
# 根据被访问结点是其父结点的左子结点或右子结点，就可以决定下一步怎么做：
# 如果是左子结点就转到右兄弟；如果是右子结点，就应该处理根结点并强制退栈

class Solution:
    """
    @param root: A Tree
    @return: Postorder in ArrayList which contains node values.
    """

    def postorderTraversal(self, root):
        # write your code here
        if root is None:
            return  []
        stack = []
        postorder = []

        while stack or root:
            while root:
                stack.append(root)
                root = root.left if root.left else root.right

            root = stack.pop()
            postorder.append(root.val)
            if stack and stack[-1].left == root:
                root = stack[-1].right
            else:
                root = None

        return postorder