Python实现二叉树遍历方法（leetcode）

无聊刷个leetcode，顺便温习一下N久没有搞过的语法训练

__author__ = 'Diro'


# Definition for a binary tree node.
class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

    def __repr__(self):
        return "Tree root: %s" % self.val


class Solution(object):
    # single stack post order
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        result = []
        if root is None:
            return []
        curr = root
        prev = None
        stack = list()
        stack.append(curr)
        while len(stack) > 0:
            curr = stack[-1]
            if (not curr.left and not curr.right) or \
                    (prev and (prev == curr.left or prev == curr.right)):
                result.append(curr.val)
                stack.pop()
                prev = curr
            else:
                if curr.right:
                    stack.append(curr.right)
                if curr.left:
                    stack.append(curr.left)
        return result

    # Two stacks post order
    def postorderTraversal2(self, root):
        s1 = list()
        s2 = list()
        result = list()
        s1.append(root)
        while len(s1) > 0:
            node = s1.pop()
            s2.append(node)
            if node.left:
                s1.append(node.left)
            if node.right:
                s1.append(node.right)
        while len(s2) > 0:
            top = s2.pop()
            result.append(top.val)
        return result

    def inorderTraversal(self, root):
        s = list()
        result = list()
        node = root
        while node or len(s) > 0:
            if node:
                s.append(node)
                node = node.left
            else:
                node = s.pop()
                result.append(node.val)
                node = node.right
        return result

    def preorderTavaersal(self, root):
        s = list()
        result = list()
        s.append(root)
        while len(s)>0:
            node = s.pop()
            result.append(node.val)
            if node.right:
                s.append(node.right)
            if node.left:
                s.append(node.left)

        return result


if __name__ == '__main__':
    node1 = TreeNode(1)
    node2 = TreeNode(2)
    node3 = TreeNode(3)
    node4 = TreeNode(4)
    node5 = TreeNode(5)
    node6 = TreeNode(6)

    node1.left = node2
    node1.right = node3
    node2.left = node4
    node2.right = node5
    node3.left = node6

    s = Solution()
    # ret = s.postorderTraversal(node1)
    # ret = s.postorderTraversal2(node1)
    # ret = s.inorderTraversal(node1)
    ret = s.preorderTavaersal(node1)
    print ret