【leetcode】遍历二叉树

对于二叉树，有深度遍历和广度遍历：

• 深度遍历：前序、中序 以及 后序。
• 广度遍历：层序。

预准备

定义节点类

#coding=utf-
class Node():
    """节点类"""
    def __init__(self, val=-1, l=None, r=None):
        self.val = val
        self.l = l
        self.r = r

定义树类

class Tree():
    """树类"""
    def __init__(self):
        self.root = Node()
        self.queue = []

    def add(self, val):
        """为树添加节点"""
        cur = Node(val)
        if self.root.val == -1:         # 如果树是空的，则对根节点赋值
            self.root = cur
            self.queue.append(self.root)
        else:
            treeNode = self.queue[0]    # 此结点的子树还没有齐。
            if treeNode.l == None:
                treeNode.l = cur
                self.queue.append(treeNode.l)
            else:
                treeNode.r = cur
                self.queue.append(treeNode.r)
                self.queue.pop(0)       # 如果该结点存在右子树，将此结点丢弃。

遍历树

层序遍历

# 按层
def levelorder(root):
    if not root:
        return
    level, res = [root], []
    while level:
        res.extend([_.val for _ in level])
        tmp = []
        for cur in level:
            if cur.l:
                tmp.append(cur.l)
            if cur.r:
                tmp.append(cur.r)
        level = tmp
    return res

# 队列
def levelorder(root):
    if not root:
        return
    queue, res = [root], []
    while queue:
        cur = queue.pop(0)
        res.append(cur.val)
        if cur.l:
            queue.append(cur.l)
        if cur.r:
            queue.append(cur.r)

前序遍历

# 递归
def preorder(root):
    if not root:
        return
    print(root.val)
    preorder(root.l)
    preorder(root.r)

# 栈
def preorder(root):
    if not root:
        return
    stack, cur = [], root
    res = []
    while stack or cur:
        while cur:
            res.append(cur.val)
            stack.append(cur)
            cur = cur.l
        cur = stack.pop()
        cur = cur.r

# visited
def preorder(root):
    if not root:
        return
    stack, res = [(root, False)], []
    while stack:
        cur, visited = stack.pop()
        if not cur:
            continue
        elif visited == True:
            res.append(cur.val)
        else:
            stack.append((cur.r, False))
            stack.append((cur.l, False))
            stack.append((cur, True))

中序遍历

# 递归
def inorder(root):
    if not root:
        return
    inorder(root.l)
    print(root.val)
    inorder(root.r)

# 栈
def inorder(root):
    if not root:
        return
    stack, cur = [], root
    res = []
    while stack or cur:
        while cur:
            res.append(cur.val)
            cur = cur.l
        cur = stack.pop()
        stack.append(cur)
        cur = cur.r

# visited
def inorder(root):
    if not root:
        return
    stack, res = [(root, False)], []
    while stack:
        cur, visited = stack.pop()
        if not cur:
            continue
        elif visited == True:
            res.append(cur.val)
        else:
            stack.append((cur.r, False))
            stack.append((cur, True))
            stack.append((cur.l, False))

后序遍历

# 递归
def postorder(root):
    if not root:
        return
    postorder(root.l)
    postorder(root.r)
    print(root.val)

# 栈
def postorder(root):
    if not root:
        return
    stack, res = [root], []
    while stack:
        cur = stack.pop()
        res.append(cur.val)
        if cur.l:
            stack.append(cur.l)
        if cur.r:
            stack.append(cur.r)
    while res:
        print(res.pop().val)

# visited
def postorder(root):
    if not root:
        return
    stack, res = [(root, False)], []
    while stack:
        cur, visited = stack.pop()
        if not cur:
            continue
        elif visited == True:
            res.append(cur.val)
        else:
        	stack.append((cur, True))
            stack.append((cur.r, False))
            stack.append((cur.l, False))

---

[1] 基于python二叉树的学习理解