递归二叉树的序列打印、非递归二叉树的序列打印

---

递归二叉树的序列打印

请用递归方式实现二叉树的先序、中序和后序的遍历打印。

给定一个二叉树的根结点root，请依次返回二叉树的先序，中序和后续遍历(二维数组的形式)。

我的提交

# -*- coding:utf-8 -*-

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class TreeToSequence:
    def convert(self, root):
        # write code here
        result = [[], [], []]
        if not root:
            return result
        self.pre(root, result[0])
        self.inOrder(root, result[1])
        self.afterOrder(root, result[2])
        return result

    def pre(self, root, result):
        if not root.left and not root.right:
            result.append(root.val)
            return 
        result.append(root.val)
        if root.left:
            self.pre(root.left, result)
        if root.right:
            self.pre(root.right, result)
        return

    def inOrder(self,root, result):
        if not root.left and not root.right:
            result.append(root.val)
            return
        if root.left:
            self.inOrder(root.left, result)
        result.append(root.val)
        if root.right:
            self.inOrder(root.right, result)
        return

    def afterOrder(self, root, result):
        if not root.left and not root.right:
            result.append(root.val)
            return
        if root.left:
            self.afterOrder(root.left, result)
        if root.right:
            self.afterOrder(root.right, result)
        result.append(root.val)

        return

参考答案

class TreeToSequence {
public:
    void pre(TreeNode* rt,vector &ret){
        ret.push_back(rt->val);
        if(rt->left) pre(rt->left,ret);
        if(rt->right) pre(rt->right,ret);
    }
    void mid(TreeNode* rt,vector &ret){
        if(rt->left) mid(rt->left,ret);
        ret.push_back(rt->val);
        if(rt->right) mid(rt->right,ret);
    }
    void aft(TreeNode* rt,vector &ret){
        if(rt->left) aft(rt->left,ret);
        if(rt->right) aft(rt->right,ret);
        ret.push_back(rt->val);
    }
    vector > convert(TreeNode* root) {
        vector A,B,C;
        vector > ret;
        pre(root,A); mid(root,B); aft(root,C);
        ret.push_back(A); ret.push_back(B); ret.push_back(C);
        return ret;
    }
};

---

非递归二叉树的序列打印

请用非递归方式实现二叉树的先序、中序和后序的遍历打印。

给定一个二叉树的根结点root，请依次返回二叉树的先序，中序和后续遍历(二维数组的形式)。

参考文档：【数据结构与算法】二叉树递归与非递归遍历（附完整源码）
http://blog.csdn.net/ns_code/article/details/12977901/

我的提交

# -*- coding:utf-8 -*-

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class TreeToSequence:
    def convert(self, root):
        # write code here
        result = [[],[],[]]
        if not root:
            return result
        self.pre(root, result[0])
        self.mid(root, result[1])
        self.after(root, result[2])
        return result


    def pre(self, root, result):
        """非递归前序遍历
        """
        if not root:
            return
        stack = []
        stack.append(root)

        while stack:
            node = stack.pop()
            result.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)

    def mid(self, root, result):
        """非递归中序遍历
        """
        def pushLeftChild(root, stack):
            p = root
            while p:
                stack.append(p)
                p = p.left

        stack = []

        pushLeftChild(root, stack)

        while stack:
            node = stack.pop()
            result.append(node.val)
            pushLeftChild(node.right, stack)

        return


    def after(self, root, result):
        """非递归后序遍历
        """
        if not root:
            return
        stack1 = []
        stack2 = []
        stack1.append(root)
        while stack1:
            node = stack1.pop()
            stack2.append(node)
            if node.left:
                stack1.append(node.left)
            if node.right:
                stack1.append(node.right)

        while stack2:
            result.append(stack2.pop().val)
        return