学习笔记 Day 22 (数据结构算法 -- 树)

树的术语:

 树的种类:

 树的存储:

(顺序存储)

链式存储:

二叉树: 

性质:

二叉树的广度优先遍历(层次遍历)

队列的方式遍历,从根节点中选择子节点,列出来之后,在遍历子节点的子节点...

代码实现:

class Node(object):
    '''新节点'''
    def __init__(self,item):
        self.item = item
        self.lchid = None
        self.rchid = None

class Tree(object):
    '''二叉树'''
    def __init__(self):
        self.root = None# 跟节点

    def add(self,item):
        '''添加节点'''
        node = Node(item) # 构造节点(要添加的节点
        if self.root is None: # 列表里面即使是None  也返回True
            self.root = node
            return
        queue = [self.root] # 列表根据队列来操作

        while queue:
            cur_node = queue.pop(0)  # 当前节点  取根节点判断
            if cur_node.lchid is None:
                cur_node.lchid = node  # 如果左节点为空,放在当前位置
                return
            else:
                queue.append(cur_node.lchid) # 如果左节点存在,从后面追加到列表中数一次

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

层次遍历实现:

class Node(object):
    '''新节点'''
    def __init__(self,item):
        self.item = item
        self.lchid = None
        self.rchid = None

class Tree(object):
    '''二叉树'''
    def __init__(self):
        self.root = None# 跟节点

    def add(self,item):
        node = Node(item) # 构造节点(要添加的节点
        if self.root is None: # 列表里面即使是None  也返回True
            self.root = node
            return
        queue = [self.root] # 列表根据队列来操作

        while queue:
            cur_node = queue.pop(0)  # 当前节点  取根节点判断
            if cur_node.lchid is None:
                cur_node.lchid = node  # 如果左节点为空,放在当前位置
                return
            else:
                queue.append(cur_node.lchid) # 如果左节点存在,从后面追加到列表中数一次

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

    def breadth_travel(self):
        '''广度遍历'''
        if self.root is None:
            return
        queue = [self.root]
        # print(queue)
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.item) # 打印遍历的值
            if cur_node.lchid is not None:
                queue.append(cur_node.lchid)
            if cur_node.rchid is not None:
                queue.append(cur_node.rchid)

if __name__ == '__main__':
    tree = Tree()
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)    # 添加
    tree.breadth_travel()  # 遍历

深度遍历:

先序遍历:

根 -- 左 -- 右

中序遍历:

左 -- 跟 -- 右

后序遍历:

左 -- 右 -- 跟

全部代码实现:

    def preorder(self,node):
        '''先序遍历'''

        if node is None:
            return
        print(node.item,end=' ')  # 根节点

        self.preorder(node.lchid) # 左节点

        self.preorder(node.rchid) # 右节点

    def inorder(self, node):
        '''中序遍历'''

        if node is None:
            return
        self.inorder(node.lchid)  # 左节点

        print(node.item, end=' ')  # 根节点

        self.inorder(node.rchid)  # 右节点

    def postorder(self, node):
        '''后序遍历'''

        if node is None:
            return
        self.postorder(node.lchid)  # 左节点

        self.postorder(node.rchid)  # 右节点

        print(node.item, end=' ')  # 根节点

由遍历确定二叉树,一定需要中序,先确定根节点,将左右分开,再找根再分开....推导就行了