【算法——Python实现】二叉搜索树

来源：互联网发布：sketch中文版软件编辑：程序博客网时间：2024/06/08 18:14
# _*_ encoding:utf-8 _*_"""二分搜索树"""from random import randintimport timeimport copyimport Queueclass Node(object):    """节点"""    def __init__(self, key, value):        self.key = key        self.value = value        self.left = None        self.right = Noneclass BinarySearchTree(object):    """二叉搜索树"""    def __init__(self):        self.root = None        self.count = 0    def size(self):        return self.count    def isEmpty(self):        return self.count == 0    def insert(self, key, value):        # 插入元素        self.root = self.__insert(self.root, key, value)    def __insert(self, node, key, value):        # 插入元素，向以node为根的二叉树插入元素，返回插入新元素之后的根节点        if not node:            # 递归到底，节点直接赋值            self.count =+ 1            return Node(key, value)        else:            if key == node.key:                # key相同，更新value                node.value = value            elif key < node.key:                node.left = self.__insert(node.left, key, value)            else:                node.right = self.__insert(node.right, key, value)        return node    def contain(self, key):        # 查找元素        return self.__contain(self.root, key)    def __contain(self, node, key):        # 在以node为根节点的二叉树中查找是否有key元素        if not node:            return False        if key == node.key:            return True        elif key < node.key:            return self.__contain(node.left, key)        else:            return self.__contain(node.right, key)    def search(self, key):        # 查找元素        return self.__search(self.root, key)    def __search(self, node, key):        # 在以node为根节点的二叉树中查找是否有key元素        if not node:            return None        if key == node.key:            return node.value        elif key < node.key:            return self.__search(node.left, key)        else:            return self.__search(node.right, key)    def preOrder(self):        # 前序遍历        self.__preOrder(self.root)    def __preOrder(self, node):        # 前序遍历        if not node:            return None        print node.key        self.__preOrder(node.left)        self.__preOrder(node.right)    def inOrder(self):        # 中序遍历        self.__inOrder(self.root)    def __inOrder(self, node):        # 中序遍历        if not node:            return None        self.__inOrder(node.left)        print node.key        self.__inOrder(node.right)    def postOrder(self):        # 后序遍历        self.__postOrder(self.root)    def __postOrder(self, node):        # 后序遍历        if not node:            return None        self.__postOrder(node.left)        self.__postOrder(node.right)        print node.key    def levelOrder(self):        # 层序遍历        q = Queue.Queue()        q.put(self.root)        while not q.empty():            node = q.get()            print node.key            if node.left:                q.put(node.left)            if node.right:                q.put(node.right)    def minimum(self):        # 查找最小值        if self.count != 0:            minNode = self.__minimum(self.root)            return minNode.key    def __minimum(self, node):        # 查找最小值        if not node.left:            return node        return self.__minimum(self.left)    def maximum(self):        # 查找最大值        if self.count != 0:            maxNode = self.__maximum(self.root)            return maxNode.key    def __maximum(self, node):        # 查找最大值        if not node.right:            return node        return self.__maximum(self.right)    def removeMin(self):        # 删除最小值        if self.root:            self.root = self.__removeMin(self.root)    def __removeMin(self, node):        # 删除最小值，删除以node为根的二叉搜索树中最小的节点，返回删除后新的二叉搜索树的根        if not node.left:            rightNode = node.right            self.count -= 1            return rightNode        node.left = self.__removeMin(node.left)        return node    def removeMax(self):        # 删除最大值        if self.root:            self.root = self.__removeMax(self.root)    def __removeMax(self, node):        # 删除最大值，删除以node为根的二叉搜索树中最大的节点，返回删除后新的二叉搜索树的根        if not node.right:            leftNode = node.left            self.count -= 1            return leftNode        node.right = self.__removeMax(node.right)        return node    def remove(self, key):        # 删除节点        self.root = self.__remove(self.root, key)    def __remove(self, node, key):        # 删除节点，删除以node为根的二叉搜索树中key节点，返回删除后新的二叉搜索树的根        if not node:            return None        if key < node.key:            node.left = self.__remove(node.left, key)            return node        elif key > node.key:            node.right = self.__remove(node.right, key)            return node        else:            # key == node.key            if not node.left:                # 没有左孩子                rightNode = node.right                self.count -= 1                return rightNode            if not node.right:                # 没有右孩子                leftNode = node.left                self.count -= 1                return leftNode            if node.left and node.right:                # 找到要删除节点右子树中的最小节点，先删除此节点，然后用此节点替换要删除的节点                successor = self.__minimum(node.right)                successor.right = self.__removeMin(node.right)                successor.left = node.left                return successorif __name__=="__main__":    tree = BinarySearchTree()    tree.insert(5,'five')    tree.insert(7,'seven')    print tree.search(5)
阅读全文
0 0