二叉树的构建于遍历（python实现）

二叉树的构建与遍历

•  二叉树的基本概念
• 二叉树的性质
• 特殊的二叉树
• 二叉树的节点以及树的构建
• 二叉树的遍历

 

1. 二叉树的基本概念

二叉树是每个节点最多有两个子树的树结构。通常子树被称为‘左子树’和‘右子树’。

 

2. 二叉树的性质

性质1：在二叉树的第i层上至多有个节点

性质2：深度为k的二叉树至多有个节点

性质3：对于任意一颗二叉树，如果叶子节点为n0，而度数为2的节点总数为n2，则n0 = n2 + 1

证明：度之和 = 分支数 = n1 + 2n2 = n-1， n = n0 + n1 + n2 ，由这两个式子可以得到 n0 = n2 +1

性质4：具有n个节点的完全二叉树的深度必为

 

3. 特殊的二叉树

完全二叉树：对于一颗二叉树，假设其深度为h，除了第h层外，其它各层的节点数均已经达到最大值，且第h层的节点从左向右连续紧密的排序

满二叉树：最底层节点达到最大值的完全二叉树

 

4. 二叉树的节点以及二叉树的创建

4.1  二叉树的节点表示

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

 

4.2  二叉树的创建

1.首先添加根节点，根节点初始值为None,先创建节点，然后在树结构中添加根节点，将根节点添加到队列中
2.添加其他节点时，先创建接你单，遍历已经存在队列中的节点，判断他们的左子树和右子树是否都存在，每次添加节点后，将添加的节点放到队列中

代码实现：

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

    def add(self, elem):
        '''为树添加节点'''
        #创建一个节点
        node = None(elem)
        if self.root == None:
            self.root = node
        else:
            queue = []
            queue.append(self.root)

        #对已有的节点进行层次遍历
        while queue:
            #弹出队列的第一个元素
            cur = queue.pop(0)
            if cur.lchild == None:
                cur.lchild = Node
                return
            elif cur.rchild == None:
                cur.rchild = Node
                return
            else:
                #如果左右子树都不为空，加入队列继续判断
                queue.append(cur.lchild)
                queue.append(cur.rchild)

 

5.  二叉树的遍历

二叉树的遍历分为深度遍历和广度遍历,深度优先一般用递归，而广度优先一般用队列'''

深度优先遍历：
        深度优先搜索是沿着树的深度遍历树的节点，尽可能深的去探索树的分支，直到叶子节点
            1.前序遍历
            2.中序遍历
            3.后序遍历

代码实现： 

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


def preorder(root):
    '''递归实现先序遍历'''
    if root == None:
        return
    print(root.elem)
    preorder(root.lchild)
    preorder(root.rchild)


def midorder(root):
    '''递归实现中序遍历'''
    if root == None:
        return

    midorder(root.lchild)
    print(root.elem)
    midorder(root.rchild)

def afterorder(root):
    '''递归实现后序遍历'''
    if root == None:
        return

    afterorder(root.lchild)
    afterorder(root.rchild)
    print(root.elem)




if __name__=='__main__':
    root = Node('D',Node('B',Node('A'),Node('C')),Node('E',rchild=Node('G',Node('F'))))
    print('前序遍历：')
    preorder(root)
    print('\n')
    print('中序遍历：')
    midorder(root)
    print('\n')
    print('后序遍历：')
    afterorder(root)
    print('\n')
   

输出结果如下： 

前序遍历：

D

B

A

C

E

G

F





中序遍历：

A

B

C

D

E

F

G





后序遍历：

A

C

B

F

G

E

D

 

广度优先遍历：从上到下，从左到右遍历整棵树,用队列实现

代码实现： 

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



def breadth_travel(root):
    if root == None:
        return
    queue = []
    queue.append(root)
    while queue:
        node = queue.pop(0)
        print(node.elem)
        if node.lchild != None:
            queue.append(node.lchild)
        if node.rchild != None:
            queue.append(node.rchild)



if __name__=='__main__':
    root = Node('D',Node('B',Node('A'),Node('C')),Node('E',rchild=Node('G',Node('F'))))
    
    print('层次遍历：')
    breadth_travel(root)
    print('\n')

 输出结果如下：

层次遍历： 

D

B

E

A

C

G

F