五.树,二叉树,二叉搜索树(BST)和自平衡二叉搜索树(AVL)

于 2023-03-03 09:33:23 发布
阅读量116 收藏
点赞数
分类专栏： 常见算法和数据结构的python实现 文章标签： 数据结构 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyou137/article/details/128852578
版权

1.树

树是一种数据结构 比如:目录结构
树是一种可以递归定义的数据结构
树是由n个节点组成的集合:
如果 n=0, 那这是一颗空树
如果 n>0, 那存在1个节点作为树的根节点,其他节点可以分为m个集合,每个集合本身又是一个树
一些概念:
根节点,叶子节点
树的深度(高度)
树的度:这个树中所有节点最大的度(孩子节点个数)
孩子节点/父节点
子树

2.用树简单模拟文件系统

"""
模拟文件系统
"""

class Node:
    def __init__(self, name, type='dir'):
        self.name = name
        self.type = type
        self.children = []
        self.parent = None

    def __repr__(self):
        return self.name
    # 链式存储方式


class FileSystemTree:
    def __init__(self):
        self.root = Node("/")
        self.now = self.root  # 当前目录

    def mkdir(self, name):
        # name必须是一个文件夹,以"/"结尾
        if name[-1] != '/':
            name += "/"
        node = Node(name)
        self.now.children.append(node)
        node.parent = self.now

    def ls(self):
        print(self.now.children)

    def cd(self, name):
        if name[-1] != "/":
            name += "/"
        if name == "../":
            self.now = self.now.parent
            return
        for child in self.now.children:
            if child.name == name:
                self.now = child
                break
        else:
            raise ValueError("invalid dir.")

tree = FileSystemTree()
tree.mkdir("var/")
tree.mkdir("bin")
tree.mkdir("usr")
print(tree.root.children)

tree.ls()

tree.cd("bin")
tree.mkdir("python")
tree.ls()

tree.cd("../")
tree.ls()

3.二叉树

二叉树:度不超过二的树
二叉树的遍历方式:
前序遍历
中序遍历
后序遍历
层序遍历

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# author: Xiang Hai
# wechat: xiaoyou42952

"""
二叉树:度不超过二的树

"""


class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None  # 左孩子
        self.rchild = None  # 右孩子


a = BiTreeNode('A')
b = BiTreeNode('B')
c = BiTreeNode('C')
d = BiTreeNode('D')
e = BiTreeNode('E')
f = BiTreeNode('F')
g = BiTreeNode('G')

e.lchild = a
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f

root = e

print(root.lchild.rchild.data)

"""
二叉树的遍历方式:
    前序遍历
    中序遍历
    后序遍历
    层序遍历
"""


def pre_order(root):
    if root:
        print(root.data, end=',')
        pre_order(root.lchild)
        pre_order(root.rchild)


pre_order(root)

def in_order(root):
    if root:
        in_order(root.lchild)
        print(root.data, end=',')
        in_order(root.rchild)


print()
in_order(root)


def post_order(root):
    if root:
        post_order(root.lchild)
        post_order(root.rchild)
        print(root.data, end=',')


print()
post_order(root)


#利用队列实现
from collections import deque
def level_order(root):
    q = deque()
    if root:
        q.append(root)
    while len(q) > 0:
        node = q.popleft()
        print(node.data, end = ",")
        if node.lchild:
            q.append(node.lchild)
        if node.rchild:
            q.append(node.rchild)

print()
level_order(root)

"""
知道二叉树的前序遍历(或者后序遍历)和中序遍历,可以还原出这个二叉树
"""

知道二叉树的前序遍历(或者后序遍历)和中序遍历,可以还原出这个二叉树

4.二叉搜索树BST

二叉搜索树是一颗二叉树且满足性质:
任意节点上值为key
它的左子树上节点值都比key小
右子树上节点值都比key大
基本操作:
查询 O(logn)
插入 O(logn)
删除:
1.如果要删除的是叶子节点,直接删除
2.如果要删除的节点只有一个孩子,将此节点的父亲与孩子连接,然后删除该节点
如果要删除的节点是根,需要重新更新根节点
3.如果要删除的节点有两个孩子:将其右子树的最小节点删除,并替换当前节点

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# author: Xiang Hai
# wechat: xiaoyou42952
"""
二叉搜索树是一颗二叉树且满足性质:
    任意节点上值为key
    它的左子树上节点值都比key小
    右子树上节点值都比key大
基本操作:
    查询 O(logn)
    插入 O(logn)
    删除:
        1.如果要删除的是叶子节点,直接删除
        2.如果要删除的节点只有一个孩子,将此节点的父亲与孩子连接,然后删除该节点
          如果要删除的节点是根,需要重新更新根节点
        3.如果要删除的节点有两个孩子:将其右子树的最小节点删除,并替换当前节点
"""
class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None  # 左孩子
        self.rchild = None  # 右孩子
        self.parent = None


class BST:
    def __init__(self, li=None):
        self.root = None
        if li:
            for val in li:
                self.insert_no_recur(val)

    def insert(self, node, val):
        if not node:
            node = BiTreeNode(val)
        elif val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parent = node
        elif val > node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parent = node

        return node

    def insert_no_recur(self, val):
        p = self.root
        if not p:  # 空树
            self.root = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                if not p.lchild:
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p
                    return
                else:
                    p = p.lchild
            elif val > p.data:
                if not p.rchild:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p
                    return
                else:
                    p = p.rchild
            else:
                return

    def pre_order(self, root):
        if root:
            print(root.data, end=',')
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def in_order(self,root):
        if root:
            self.in_order(root.lchild)
            print(root.data, end=',')
            self.in_order(root.rchild)

    def post_order(self, root):
        if root:
            self.post_order(root.lchild)
            self.post_order(root.rchild)
            print(root.data, end=',')

    def query(self, node, val):
        if not node:  # 递归终止条件
            return None
        if node.data < val:
            return self.query(node.rchild, val)
        elif node.data > val:
            return self.query(node.lchild, val)
        else:
            return node

    def query_no_recur(self, val):
        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        else:
            return None

    def __remove_node_1(self, node):
        # 1.node是叶子节点
        if not node.parent:  # node是根节点
            self.root = None
        elif node == node.parent.lchild:
            node.parent.lchild = None
        else:
            node.parent.rchild = None

    def __remove_node_21(self, node):
        # 2.node只有一个左孩子
        if not node.parent:  # 根节点
            self.root = node.lchild
            node.lchild.parent = None
        elif node == node.parent.lchild:
            node.parent.lchild = node.lchild
            node.lchild.parent = node.parent
        else:
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    def __remove_node_22(self, node):
        # 3.node只有一个右孩子
        if not node.parent:
            self.root = node.rchild
        elif node == node.parent.lchild:
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent
        else:
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent

    def delete(self, val):
        if self.root:
            node = self.query_no_recur(val)
            if not node: # 不存在
                return False
            if not node.lchild and not node.rchild:
                self.__remove_node_1(node)
            elif not node.rchild:  # 2.1 只有一个左孩子
                self.__remove_node_21(node)
            elif not node.lchild:   #2.2 只有一个右孩子
                self.__remove_node_22(node)
            else:  # node有两个孩子
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data
                # 删除min_node
                if min_node.rchild:
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_1(min_node)




tree = BST([4,6,7,9,2,1,3,5,8])
tree.pre_order(tree.root)
print()
tree.in_order(tree.root)
print()
print(tree.query_no_recur(10))

tree.delete(4)
tree.in_order(tree.root)

"""
平均情况下,二叉搜索树查找的时间复杂度为O(logn)
最坏情况下,二叉树偏斜退化成一条链表,查找时间复杂度O(n)
解决方法:
    随机化插入
    AVL树
"""

平均情况下,二叉搜索树查找的时间复杂度为O(logn)
最坏情况下,二叉树偏斜退化成一条链表,查找时间复杂度O(n)
解决方法:
随机化插入
AVL树

5.自平衡二叉搜索树AVL

AVL树:是一棵自平衡的二叉搜索树
任意节点的左右子树高度差最大为1

如何保持平衡:旋转
插入一个节点后,只有从插入节点到根节点路径上的节点的平衡可能被破坏,
我们需要找出第一个破坏了平衡的节点,称之为K,K的两棵子树高度差为2
不平衡可能有4种情况:(右右左,左左右,左右左右,右左右左)
1.对K的右孩子的右子树插入导致的:左旋
2.对K的左孩子的左子树插入导致的:右旋
3.对K的右孩子的左子树插入导致的:右旋-左旋
4.对K的左孩子的右子树插入导致的:左旋-右旋

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# author: Xiang Hai
# wechat: xiaoyou42952

"""
AVL树:是一棵自平衡的二叉搜索树
    任意节点的左右子树高度差最大为1

如何保持平衡:旋转
    插入一个节点后,只有从插入节点到根节点路径上的节点的平衡可能被破坏,
    我们需要找出第一个破坏了平衡的节点,称之为K,K的两棵子树高度差为2
    不平衡可能有4种情况:(右右左,左左右,左右左右,右左右左)
        1.对K的右孩子的右子树插入导致的:左旋
        2.对K的左孩子的左子树插入导致的:右旋
        3.对K的右孩子的左子树插入导致的:右旋-左旋
        4.对K的左孩子的右子树插入导致的:左旋-右旋
"""
from _027_二叉搜索树 import BiTreeNode, BST

class AVLNode(BiTreeNode):
    def __init__(self, data):
        BiTreeNode.__init__(self, data)
        self.bf = 0  # balance factor = 右子树高度-左子树高度


class AVLTree(BST):
    def __init__(self, li = None):
        BST.__init__(self, li)

    def rotate_left(self, p, c):
        s2 = c.lchild
        p.rchild = s2
        if s2:
            s2.parent = p
        c.lchild = p
        p.parent = c

        p.bf = 0
        c.bf = 0
        return c

    def rotate_right(self, p, c):
        s2 = c.rchild
        p.lchild = s2
        if s2:
            s2.parent = p
        c.rchild = p
        p.parent = c

        p.bf = 0
        c.bf = 0
        return c

    def rotate_right_left(self, p, c):
        # 先右旋
        g = c.lchild
        s3 = g.rchild
        c.lchild = s3
        if s3:
            s3.parent = c
        g.rchild = c
        c.parent = g

        # 再左旋
        s2 = g.lchild
        p.rchild = 2
        if s2:
            s2.parent = p
        g.lchild = p
        p.parent = g

        # 更新bf
        if g.bf > 0:
            p.bf = -1
            c.bf = 0
        elif g.bf < 0:
            p.bf = 0
            c.bf = 1
        else:  # 插入的是g
            p.bf = 0
            c.bf = 0
        g.bf = 0

        return g

    def rotate_left_right(self, p, c):
        g = c.rchild
        s2 = g.lchild
        c.rchild = s2
        if s2:
            s2.parent = c
        g.lchild = c
        c.parent = g

        s3 = g.rchild
        p.lchild = s3
        if s3:
            s3.parent = p
        g.rchild = p
        p.parent = g

        # 更新bf
        if g.bf < 0:
            p.bf = 1
            c.bf = 0
        elif g.bf > 0:
            p.bf = 0
            c.bf = -1
        else:  # 插入的是g
            p.bf = 0
            c.bf = 0
        g.bf = 0

        return g

    def insert_no_recur(self, val):
        # 1. 和BST一样,先插入
        p = self.root
        if not p:  # 空树
            self.root = AVLNode(val)
            return
        while True:
            if val < p.data:
                if not p.lchild:
                    p.lchild = AVLNode(val)
                    p.lchild.parent = p
                    node = p.lchild
                    break
                else:
                    p = p.lchild
            elif val > p.data:
                if not p.rchild:
                    p.rchild = AVLNode(val)
                    p.rchild.parent = p
                    node = p.rchild
                    break
                else:
                    p = p.rchild
            else:  # val == p.data重复
                return

        # 2. 更新balance factor
        while node.parent:  # node的parent不空
            if node == node.parent.lchild:  # 传递是从左子树来的
                # 更新node的parent的bf -= 1
                if node.parent.bf < 0:  # 原来=-1,更新后变成-2,需要旋转了
                    # 看node哪边沉,判断需要做哪种旋转
                    g = node.parent.parent  # 为了连接旋转后的子树
                    x = node.parent  # 旋转前子树的根
                    if node.bf > 0:
                        n = self.rotate_left_right(node.parent, node)
                    else:
                        n = self.rotate_right(node.parent, node)
                elif node.parent.bf > 0:  # 1, 更新后变成0,传递终止
                    node.parent.bf = 0
                    break
                else:  # 0, 更新后变-1
                    node.parent.bf = -1
                    node = node.parent
                    continue
            else:  # 传递是从右子树来的
                # 更新后node的parent的bf += 1
                if node.parent.bf > 0: # 1 -> 2, 需要旋转
                    g = node.parent.parent
                    x = node.parent  # 旋转前子树的根
                    # 看node哪边沉
                    if node.bf < 0:
                        n = self.rotate_right_left(node.parent, node)
                    else:
                        n = self.rotate_left(node.parent, node)
                elif node.parent.bf < 0:  # -1 -> 0, 传递终止
                    node.parent.bf = 0
                    break
                else:  # 0->1
                    node.parent.bf = 1
                    node = node.parent
                    continue

            # 连接旋转后的子树
            n.parent = g
            if g:
                if x == g.lchild:
                    g.lchild = n
                else:
                    g.rchild = n
                break
            else:
                self.root = n
                break

tree = AVLTree([9,8,7,6,5,4,3,2,1])
print()
tree.pre_order(tree.root)
print()
tree.in_order(tree.root)

"""
AVL树的应用--B树
B树是一个自平衡的多路搜索树,常用于数据库的索引,减少访问硬盘的次数
一个节点存放n个值,有n+1个子节点
"""

AVL树的应用–B树
B树是一个自平衡的多路搜索树,常用于数据库的索引,减少访问硬盘的次数
一个节点存放n个值,有n+1个子节点

xiaoyou137
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值