数据结构-树

最新推荐文章于 2024-08-23 08:30:41 发布

shell-x

最新推荐文章于 2024-08-23 08:30:41 发布

阅读量199

点赞数 1

文章标签：数据结构树二叉树

本文链接：https://blog.csdn.net/shell_x/article/details/103259797

版权

树

概念

树(tree)，是一种抽象的数据类型(ADT)或是实作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n(n>1)个有限节点组成一个具有层次关系的集合。

特点

每个节点有0个或多个节点；
没有父节点的节点称为根节点；
每一个非根节点有且只有一个父节点；
除了根节点外，每个节点可以分为多个不想交的子数；

在这里插入图片描述

A节点是B节点的父节点，B节点是A节点的子节点，B,C,D这三个节点有相同的父节点，他们之间相互称为兄弟节点。E没有父节点，称为根节点；G,H,K…没有子节点，称为叶子节点或叶节点。

高度、深度、层数
高度(hight)，深度(depth)，层数(level)

在这里插入图片描述

节点的高度：节点到叶子节点的最长路径
节点的深度：根节点到这个节点所经历的边的个数
节点的层数：深度+1
树的高度：根节点的高度

树的种类

无序树：树中任意节点的子节点之间没有顺序关系，这种树称为无序树，也称自由树；
有序树：树中任意节点的子节点之间有顺序关系，这种称为有序树；
- 二叉树：每个节点最多有两个子树的树称为二叉树
  - 完全二叉树：对于一颗二叉树，假设其深度为d(d>1)。出了第d层外，其他各层的节点数目均已达最大值，且第d层所有节点从左向右连续紧密排列，这样的二叉树称为完全二叉树，其中满二叉树的定义是所有叶子节点都在最底层的完全二叉树。
  - 平衡二叉树(AVL树)：当且仅当任意节点的两颗子树的高度差不大于1的二叉树；
  - 排序二叉树(二叉查找树-Binary search tree,也称二叉搜索树，有序二叉树)；
- 霍夫曼树（用于信息编码）：带权路径最短的二叉树称为霍夫曼树或最优二叉树；
- B+树：一种对读写操作进行优化的自平衡的二叉树，能够保持数据有序，拥有多余两个子树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mbDakyqT-1574757400274)(CA9D864A54AA4945B946056D93E4F861)]

这个图里面，有两个比较特殊的二叉树，分别是编号 2 和编号 3 这两个。

其中，编号 2 的二叉树中，叶子节点全都在最底层，除了叶子节点之外，每个节点都有左右两个子节点，这种二叉树就叫作满二叉树。

编号 3 的二叉树中，叶子节点都在最底下两层，最后一层的叶子节点都靠左排列，并且除了最后一层，其他层的节点个数都要达到最大，这种二叉树叫作完全二叉树。

树的存储与表示

顺序存储(sequence)：将数据结构存储在固定的数组中，虽然在遍历速度上有一定的优势，但因所占空间比较大是非主流二叉树。主流的二叉树通常以链式存储。

在这里插入图片描述

实现一颗树

class TreeNode(object):
    def __init__(self, item, left=None, right=None):
        self.item = item
        self.left = left
        self.right = right


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

    def is_empty(self):
        return self.root == None

    def add(self, item):
        node = TreeNode(item)
        if self.root == None:
            self.root = node
        else:
            # 建立一个空队列
            que = []
            # 向队列中添加根节点
            que.append(self.root)
            while que:
                # 排在前面的节点出队，并用cur_que接受该节点
                cur_que = que.pop(0)
                # 判断节点左指针是否指向空
                if cur_que.left == None:
                    cur_que.left = node
                    return
                # 判断节点右指针是否指向空
                elif cur_que.right == None:
                    cur_que.right = node
                    return
                # 如果左右均不为空，将左右指针所指向的节点传入队列
                else:
                    que.append(cur_que.left)
                    que.append(cur_que.right)

    def travel(self):
        # 遍历同样适用入队出队的思想，出一个打印一个
        if self.root == None:
            return
        else:
            que = []
            que.append(self.root)
            while que:
                node = que.pop(0)
                print(node.item, end=' ')
                if node.left != None:
                    que.append(node.left)
                if node.right != None:
                    que.append(node.right)

if __name__ == '__main__':
    t = Tree()
    print(t.is_empty())
    t.add(2)
    t.add(3)
    t.add(6)
    t.add(9)
    t.add(5)
    print(t.is_empty())
    t.travel()

# True
# False
# 2 3 6 9 5

常见的一些树的应用场景

xml,html等，编写这些东西的解析器的时候，不可避免的用到这些树
路由器的协议就是使用了树的算法
mysql数据库的索引
文件系统的目录结构
很多经典的AI算法其实是树搜索，此外机器学的决策树(decision tree)也是树结构。

二叉树的遍历

树的树的遍历是一种重要的运算，即一次对树的节点访问一次且仅访问一次。树的两种重要的遍历方式分别是，深度优先遍历（用递归）和广度优先遍历（用队列），上面代码中已经完成了一种树的遍历，我们是按照广度优先的方式遍历的。一般情况下能用递归实现的算法大部分也能用堆栈来实现。

深度优先遍历

沿着树的深度遍历树的节点，尽可能深的搜索树的分支

先序遍历，先访问根节点，递归先序遍历访问左子树，再递归访问右子树

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

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

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

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

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

class Tr(Tree):
    def preorder(self, node):
        if node == None:
            return
        print(node.item, end=' ')
        self.preorder(node.left)
        self.preorder(node.right)

    def inorder(self, node):
        if node == None:
            return
        self.inorder(node.left)
        print(node.item, end=' ')
        self.inorder(node.right)

    def postorder(self, node):
        if node == None:
            return
        self.postorder(node.left)
        self.postorder(node.right)
        print(node.item, end=' ')


if __name__ == '__main__':
    # t = Tree()
    r = Tr()
    r.add(0)
    r.add(1)
    r.add(2)
    r.add(3)
    r.add(4)
    r.add(5)
    r.add(6)
    r.add(7)
    r.add(8)
    r.add(9)

    r.preorder(r.root)
    print(' ')
    r.inorder(r.root)
    print(' ')
    r.postorder(r.root)

# 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