双链表实现树结构

'''
树
目录结构
可以递归定义的数据结构

'''


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

    def __repr__(self):
        return self.name


n = Node('hello')
n2 = Node("world")
n.children.append(n2)
n2.parent = n


# 类似双链表

# 模拟操作系统
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):
        return 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
                return
        raise ValueError("invalid dir")


tree = FileSystemTree()
tree.mkdir('var/')
tree.mkdir('bin/')
tree.mkdir('usr/')

tree.cd('bin/')
tree.mkdir('python/')

tree.cd('../')
print(tree.ls())

二叉树

# 二叉树
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)
print("\n")


# 二叉树的遍历

# 前序遍历
def pre_order(root):
    if root:
        print(root.data, end=',')
        pre_order(root.lchild)
        pre_order(root.rchild)


# pre_order(root)

'''
二叉搜索树
二叉搜索树是一颗二叉树且满足性质：设X是二叉树的一个节点。如果y是x左子树的一个节点，那么y.key<=x.key；
如果y是x右子树的一个节点，那么y.key>=x.key

二叉搜索树的操作：
查询
插入
删除


效率：
平均情况下：时间复杂度为o(lgn)
最坏情况下，二叉搜索树可能非常偏斜(向右偏斜)

解决方案：
随机化插入
'''

**

AVL树

**

'''
AVL树：一颗自平衡的二叉树
AVl树的性质：
    根的左右子树的高度之差的绝对值不能超过1
    根的左右子树都是平衡二叉树  
AVL树 -- 插入
    插入一个节点可能会破坏AVL树的平衡，可以通过旋转操作来进行修正
    插入一个节点后只有从插入节点到根节点的路径上的节点的平衡可能被改变。我们需要找出第一个破坏了平衡条件的节点，称之为k.k的两颗子树的高度差为2
    
    
    不平衡的出现可能有4种情况

        左旋
        不平衡是由于对k的右孩子的右子树插入导致的
        
        右旋
        不平衡是由于对k的左孩子的左子树插入导致的
        
        右旋-左旋
        不平衡是由于对k的右孩子的左子树插入导致的
        
        左旋-右旋
        不平衡是由于对k的左孩子的右子树插入导致的
        
    
'''


class BSTTreeNode:
    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_ret(val)

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

        return node

    def insert_no_ret(self, val):
        p = self.root
        if not p:  # 空树
            self.root = BSTTreeNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:  # 左孩子不存在
                    p.lchild = BSTTreeNode(val)
                    p.lchild.parent = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:  # 右孩子不存在
                    p.rchild = BSTTreeNode(val)
                    p.rchild.parent = p
                    return
            else:
                return

    # 查询
    # 递归查询
    def query(self, node, val):
        if not node:
            return True
        if node.data < val:
            return self.query(node.lchild, val)
        elif node.data > val:
            return self.query(node.rchild, val)
        else:
            return node

    # 非递归
    def query_no_rec(self, val):
        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        return None

    # 前序遍历
    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 __remove_node_1(self, node):
        # 情况1:node是叶子结点
        if not node.parent:
            self.root = None
        if node == node.parent.lchild:  # node是它父亲的左孩子
            node.parent.lchild = None
            node.parent = None
        else:  # 右孩子
            node.parent.rchild = None
            node.parent = None

    def __remove_node_21(self, node):
        # 情况2 1：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):
        # 情况2 2：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_rec(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:
                # 3.两个孩子都有
                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(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("\n----------------")
tree.in_order(tree.root)
print("\n----------------")
tree.post_order(tree.root)
print("\n----------------")
print(tree.query_no_rec(4).data)
tree.delete(4)
print("\n------------------")
tree.in_order(tree.root)

'''
AVL树的插入实现

'''


class AVTNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None
        self.parent = None
        self.bf = 0


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

    # 左旋
    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.lchild = s2
        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.df = 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.rchild = 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:
            p.bf = 0
            c.bf = 0
        g.bf = 0

        return g

    def insert_no_rec(self, val):
        pass