平衡二叉树图书管理系统

平衡二叉树图书管理系统是一种基于平衡二叉树数据结构的图书管理系统。它可以实现图书信息的插入、查找、删除和显示等功能，同时保证了平衡二叉树的平衡性，提高了系统的效率和稳定性。

具体实现方法如下：

1.定义图书信息结构体，包括图书编号、图书名称、作者、出版社、价格等信息。

2.定义平衡二叉树结构体，包括节点指针、左右子树指针、平衡因子等信息。

3.实现平衡二叉树的基本操作，包括左旋、右旋、左右旋、右左旋等操作，以保证平衡二叉树的平衡性。

4.实现图书信息的插入、查找、删除和显示等操作，其中插入操作需要先将图书信息插入到平衡二叉树中，然后再将图书信息保存到文件中；查找操作需要先在平衡二叉树中查找图书信息，然后再从文件中读取图书信息；删除操作需要先在平衡二叉树中删除图书信息，然后再从文件中删除图书信息；显示操作需要遍历平衡二叉树，输出所有图书信息。

5.实现文件读写操作，包括将图书信息保存到文件中、从文件中读取图书信息、从文件中删除图书信息等操作。

以下是一个简单的平衡二叉树图书管理系统的Python实现：

import pickle

class Book:
    def __init__(self, id, name, author, publisher, price):
        self.id = id
        self.name = name
        self.author = author
        self.publisher = publisher
        self.price = price

class AVLNode:
    def __init__(self, book):
        self.book = book
        self.left = None
        self.right = None
        self.height = 1

class AVLTree:
    def __init__(self):
        self.root = None

    def height(self, node):
        if node is None:
            return 0
        return node.height

    def balance_factor(self, node):
        if node is None:
            return 0
        return self.height(node.left) - self.height(node.right)

    def left_rotate(self, node):
        right_child = node.right
        node.right = right_child.left
        right_child.left = node
        node.height = 1 + max(self.height(node.left), self.height(node.right))
        right_child.height = 1 + max(self.height(right_child.left), self.height(right_child.right))
        return right_child

    def right_rotate(self, node):
        left_child = node.left
        node.left = left_child.right
        left_child.right = node
        node.height = 1 + max(self.height(node.left), self.height(node.right))
        left_child.height = 1 + max(self.height(left_child.left), self.height(left_child.right))
        return left_child

    def insert(self, book):
        def _insert(node, book):
            if node is None:
                return AVLNode(book)
            if book.id < node.book.id:
                node.left = _insert(node.left, book)
            else:
                node.right = _insert(node.right, book)
            node.height = 1 + max(self.height(node.left), self.height(node.right))
            balance = self.balance_factor(node)
            if balance > 1 and book.id < node.left.book.id:
                return self.right_rotate(node)
            if balance < -1 and book.id > node.right.book.id:
                return self.left_rotate(node)
            if balance > 1 and book.id > node.left.book.id:
                node.left = self.left_rotate(node.left)
                return self.right_rotate(node)
            if balance < -1 and book.id < node.right.book.id:
                node.right = self.right_rotate(node.right)
                return self.left_rotate(node)
            return node

        self.root = _insert(self.root, book)

    def search(self, id):
        def _search(node, id):
            if node is None:
                return None
            if id == node.book.id:
                return node.book
            elif id < node.book.id:
                return _search(node.left, id)
            else:
                return _search(node.right, id)

        return _search(self.root, id)

    def delete(self, id):
        def _delete(node, id):
            if node is None:
                return None
            if id < node.book.id:
                node.left = _delete(node.left, id)
            elif id > node.book.id:
                node.right = _delete(node.right, id)
            else:
                if node.left is None:
                    return node.right
                elif node.right is None:
                    return node.left
                else:
                    min_node = node.right
                    while min_node.left is not None:
                        min_node = min_node.left
                    node.book = min_node.book
                    node.right = _delete(node.right, min_node.book.id)
            node.height = 1 + max(self.height(node.left), self.height(node.right))
            balance = self.balance_factor(node)
            if balance > 1 and self.balance_factor(node.left) >= 0:
                return self.right_rotate(node)
            if balance < -1 and self.balance_factor(node.right) <= 0:
                return self.left_rotate(node)
            if balance > 1 and self.balance_factor(node.left) < 0:
                node.left = self.left_rotate(node.left)
                return self.right_rotate(node)
            if balance < -1 and self.balance_factor(node.right) > 0:
                node.right = self.right_rotate(node.right)
                return self.left_rotate(node)
            return node

        self.root = _delete(self.root, id)

    def traverse(self):
        def _traverse(node):
            if node is not None:
                _traverse(node.left)
                print("ID: %d, Name: %s, Author: %s, Publisher: %s, Price: %.2f" % (node.book.id, node.book.name, node.book.author, node.book.publisher, node.book.price))
                _traverse(node.right)

        _traverse(self.root)

    def save_to_file(self, filename):
        with open(filename, 'wb') as f:
            pickle.dump(self.root, f)

    def load_from_file(self, filename):
        with open(filename, 'rb') as f:
            self.root = pickle.load(f)

if __name__ == '__main__':
    tree = AVLTree()
    tree.insert(Book(1001, 'Python入门', '张三', '清华大学出版社', 29.99))
    tree.insert(Book(1002, 'Java入门', '李四', '人民邮电出版社', 39.99))
    tree.insert(Book(1003, 'C++入门', '王五', '机械工业出版社', 49.99))
    tree.insert(Book(1004, '数据结构与算法', '赵六', '电子工业出版社', 59.99))
    tree.traverse()
    tree.save_to_file('books.dat')
    tree.delete(1003)
    tree.traverse()
    tree.load_from_file('books.dat')
    tree.traverse()