数据结构与算法笔记(十四)—— 二叉树及二叉树遍历

Posted 别呀

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据结构与算法笔记(十四)—— 二叉树及二叉树遍历相关的知识,希望对你有一定的参考价值。

一、二叉树的基本概念

二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”(left subtree) 和“右子树”(right subtree)。


二、二叉树的性质(特性)

性质 1: 在二叉树的第 i 层上至多有 2^(i-1)个节点(i>0)

性质 2: 深度为 k 的二叉树至多有 2^k - 1 个节点(k>0)

性质 3: 对于任意一棵二叉树,如果其叶节点数为 N0,而度数为 2 的结点总数为 N2, 则 N0=N2+1;

性质 4:具有 n 个节点的完全二叉树的深度必为 log2(n+1) (以2为底)

性质 5:对完全二叉树,若从上至下、从左至右编号,则编号为 i 的结点,其左孩子编 号必为 2i,其右孩子编号必为 2i+1;其双亲的编号必为 i/2(i=1 时为根,除外)


三、二叉树的节点及树的创建

3.1、节点的创建

class Node(object): 
    """节点类""" 
    def __init__(self, elem=-1, lchild=None, rchild=None): 
        self.elem = elem 
        self.lchild = lchild 
        self.rchild = rchild

3.2、树的创建

class Tree(object):
	'''树类'''
    def __init__(self):
        self.root = None

    def add(self,elem):
        '''为树添加结点'''
        node = Node(elem)
        if self.root is None:
            self.root = node
            return

        queue = [self.root]

        while queue:
            # 弹出队列的第一个元素
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)

            if cur_node.rchild is None:
                cur_node.rchild = None
                return
            else:
                queue.append(cur_node.rchild)

四、二叉树遍历

树的遍历是树的一种重要的运算。所谓遍历是指对树中所有结点的信息的访问,即依次 对树中每个结点访问一次且仅访问一次,我们把这种对所有节点的访问称为遍历(traversal)。 那么树的两种重要的遍历模式是深度优先遍历和广度优先遍历,深度优先一般用递归,广度优先一般用队列。一般情况下能用递归实现的算法大部分也能用堆栈来实现。

4.1、广度优先遍历(层次遍历)

从树的 root 开始,从上到下从从左到右遍历整个树的节点。

代码

def breadth_travel(self):
    """利用队列实现树的层次遍历"""
    if self.root is None:
        return
    queue = [self.root]
    while queue:
        cur_node = queue.pop(0)
        print(cur_node.elem)
        if cur_node.lchild is not None:
            queue.append(cur_node.lchild)
        if cur_node.rchild is not None:
            queue.append(cur_node.rchild)

4.2、深度优先遍历

对于一颗二叉树,深度优先搜索(Depth First Search)是沿着树的深度遍历树的节点,尽可能深的搜索树的分支。

那么深度遍历有重要的三种方法。这三种方式常被用于访问树的节点,它们之间的不同 在于访问每个节点的次序不同。这三种遍历分别叫做先序遍历(preorder)中序遍历(inorder)后序遍历(postorder)。我们来给出它们的详细定义,然后举例看看它们的应用。

补充小知识:
在已知中序遍历和先序遍历或者中序遍历和后序遍历)结果时,我们可以推导出树的结构(注意必须知道中序遍历结果,否则是没法推导的)


4.2.1、先序遍历

在先序遍历中,我们先访问根节点,然后递归使用先序遍历访问左子树,再递归使用先序遍历访问右子树。

根节点 --> 左子树 --> 右子树

代码

def preorder(self,node):
    '''先序遍历'''
    if node is None:
        return
    print(node.elem, end=' ')
    self.preorder(node.lchild)
    self.preorder(node.rchild)

4.2.2、中序遍历

在中序遍历中,我们递归使用中序遍历访问左子树,然后访问根节点,最后再递 归使用中序遍历访问右子树。

左子树 -->根节点 --> 右子树

代码

def inorder(self,node):
    '''中序遍历'''
    if node is None:
        return
    self.inorder(node.lchild)
    print(node.elem, end=' ')
    self.inorder(node.rchild)

4.2.3、后序遍历

在后序遍历中,我们先递归使用后序遍历访问左子树和右子树,最后访问根节点。

左子树 --> 右子树 --> 根节点

代码:

def postorder(self,node):
    '''后序遍历'''
    if node is None:
        return
    self.postorder(node.lchild)
    self.postorder(node.rchild)
    print(node.elem, end=' ')

4.3、完整代码遍历测试

class Node(object):
    """节点类"""
    def __init__(self, elem):
        self.elem = elem
        self.lchild = None
        self.rchild = None

class Tree(object):
    def __init__(self):
        self.root = None

    def add(self,elem):
        '''为树添加结点'''
        node = Node(elem)
        if self.root is None:
            self.root = node
            return

        queue = [self.root]

        while queue:
            # 弹出队列的第一个元素
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)

            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)

    def preorder(self,node):
        '''先序遍历'''
        if node is None:
            return
        print(node.elem, end=' ')
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self,node):
        '''中序遍历'''
        if node is None:
            return
        self.inorder(node.lchild)
        print(node.elem, end=' ')
        self.inorder(node.rchild)

    def postorder(self,node):
        '''后序遍历'''
        if node is None:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.elem, end=' ')


    def breadth_travel(self):
        """利用队列实现树的层次遍历"""
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.elem,end=' ')
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)


if __name__ == '__main__':
    tree = Tree()
    for i in range(10):
        tree.add(i)
    tree.breadth_travel()
    print('')
    tree.preorder(tree.root)
    print('')
    tree.inorder(tree.root)
    print('')
    tree.postorder(tree.root)

遍历结果:

层次:0 1 2 3 4 5 6 7 8 9 
先序:0 1 3 7 8 4 9 2 5 6
中序:7 3 8 1 9 4 0 5 2 6
后序:7 8 3 9 4 1 5 6 2 0 

以上是关于数据结构与算法笔记(十四)—— 二叉树及二叉树遍历的主要内容,如果未能解决你的问题,请参考以下文章

树及二叉树

(王道408考研数据结构)第五章树-第二节1:二叉树的定义特殊的二叉树及二叉树性质

一文学会树及二叉树的操作

二叉树详解及二叉树的遍历(递归与非递归C++算法实现)

算法与数据结构:树型数据结构及其应用

算法与数据结构:树型数据结构及其应用