首页 > 资讯 > 后端开发 > Python >python实现二叉搜索树的四种方法

284

分享到

python实现二叉搜索树的四种方法

python 二叉搜索树 2023-05-15 11:05:20 284人浏览薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

目录树的介绍二叉搜索树列举几种python中几种常见的实现方式：1.使用类和递归函数实现2.使用列表实现3.使用字典实现4.使用堆栈实现树的介绍树不同于链表或哈希表，是一种非线性数

树的介绍

树不同于链表或哈希表，是一种非线性数据结构，树分为二叉树、二叉搜索树、B树、B+树、红黑树等等。

树是一种数据结构，它是由n个有限节点组成的一个具有层次关系的集合。用图片来表示的话，可以看到它很像一棵倒挂着的树。因此我们将这类数据结构统称为树，树根在上面，树叶在下面。一般的树具有以下特点：

每个节点有0个或者多个子节点
没有父节点的节点被称为根节点
每个非根节点有且只有一个父节点
每个子结点都可以分为多个不相交的子树

二叉树的定义是：每个节点最多有两个子节点。即每个节点只能有以下四种情况：

左子树和右子树均为空
只存在左子树
只存在右子树
左子树和右子树均存在

二叉搜索树

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

列举几种Python中几种常见的实现方式：

1.使用类和递归函数实现

通过定义一个节点类，包含节点值、左右子节点等属性，然后通过递归函数实现插入、查找、删除等操作。代码示例如下：

class node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

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

    def insert(self, value):
        if self.root is None:
            self.root = Node(value)
        else:
            self._insert(value, self.root)

    def _insert(self, value, node):
        if value < node.data:
            if node.left is None:
                node.left = Node(value)
            else:
                self._insert(value, node.left)
        elif value > node.data:
            if node.right is None:
                node.right = Node(value)
            else:
                self._insert(value, node.right)

    def search(self, value):
        if self.root is None:
            return False
        else:
            return self._search(value, self.root)

    def _search(self, value, node):
        if node is None:
            return False
        elif node.data == value:
            return True
        elif value < node.data:
            return self._search(value, node.left)
        else:
            return self._search(value, node.right)

    def delete(self, value):
        if self.root is None:
            return False
        else:
            self.root = self._delete(value, self.root)

    def _delete(self, value, node):
        if node is None:
            return node
        elif value < node.data:
            node.left = self._delete(value, node.left)
        elif value > node.data:
            node.right = self._delete(value, node.right)
        else:
            if node.left is None and node.right is None:
                del node
                return None
            elif node.left is None:
                temp = node.right
                del node
                return temp
            elif node.right is None:
                temp = node.left
                del node
                return temp
            else:
                temp = self._find_min(node.right)
                node.data = temp.data
                node.right = self._delete(temp.data, node.right)
        return node

    def _find_min(self, node):
        while node.left is not None:
            node = node.left
        return node

2.使用列表实现

通过使用一个列表来存储二叉搜索树的元素，然后通过列表中元素的位置关系来实现插入、查找、删除等操作。代码示例如下：

class BST:
    def __init__(self):
        self.values = []

    def insert(self, value):
        if len(self.values) == 0:
            self.values.append(value)
        else:
            self._insert(value, 0)

    def _insert(self, value, index):
        if value < self.values[index]:
            left_child_index = 2 * index + 1
            if left_child_index >= len(self.values):
                self.values.extend([None] * (left_child_index - len(self.values) + 1))
            if self.values[left_child_index] is None:
                self.values[left_child_index] = value
            else:
                self._insert(value, left_child_index)
        else:
            right_child_index = 2 * index + 2
            if right_child_index >= len(self.values):
                self.values.extend([None] * (right_child_index - len(self.values) + 1))
            if self.values[right_child_index] is None:
                self.values[right_child_index] = value
            else:
                self._insert(value, right_child_index)

    def search(self, value):
        if value in self.values:
            return True
        else:
            return False

    def delete(self, value):
        if value not in self.values:
            return False
        else:
            index = self.values.index(value)
            self._delete(index)
            return True

    def _delete(self, index):
        left_child_index = 2 * index + 1
        right_child_index = 2 * index + 2
        if left_child_index < len(self.values) and self.values[left_child_index] is not None:
            self._delete(left_child_index)
        if right_child_index < len(self.values) and self.values[right_child_index] is not None:
            self

3.使用字典实现

其中字典的键表示节点值，字典的值是一个包含左右子节点的字典。代码示例如下：

def insert(tree, value):
    if not tree:
        return {value: {}}
    elif value < list(tree.keys())[0]:
        tree[list(tree.keys())[0]] = insert(tree[list(tree.keys())[0]], value)
    else:
        tree[list(tree.keys())[0]][value] = {}
    return tree

def search(tree, value):
    if not tree:
        return False
    elif list(tree.keys())[0] == value:
        return True
    elif value < list(tree.keys())[0]:
        return search(tree[list(tree.keys())[0]], value)
    else:
        return search(tree[list(tree.keys())[0]].get(value), value)

def delete(tree, value):
    if not search(tree, value):
        return False
    else:
        if list(tree.keys())[0] == value:
            if not tree[list(tree.keys())[0]]:
                del tree[list(tree.keys())[0]]
            elif len(tree[list(tree.keys())[0]]) == 1:
                tree[list(tree.keys())[0]] = list(tree[list(tree.keys())[0]].values())[0]
            else:
                min_key = min(list(tree[list(tree.keys())[0]+1].keys()))
                tree[min_key] = tree[list(tree.keys())[0]+1][min_key]
                tree[min_key][list(tree.keys())[0]] = tree[list(tree.keys())[0]]
                del tree[list(tree.keys())[0]]
        elif value < list(tree.keys())[0]:
            tree[list(tree.keys())[0]] = delete(tree[list(tree.keys())[0]], value)
        else:
            tree[list(tree.keys())[0]][value] = delete(tree[list(tree.keys())[0]].get(value), value)
    return tree

由于字典是无序的，因此该实现方式可能会导致二叉搜索树不平衡，影响插入、查找和删除操作的效率。

4.使用堆栈实现

使用堆栈（Stack）可以实现一种简单的二叉搜索树，可以通过迭代方式实现插入、查找、删除等操作。具体实现过程如下：

定义一个节点类，包含节点值、左右子节点等属性。
定义一个堆栈，初始时将根节点入栈。
当栈不为空时，取出栈顶元素，并对其进行操作：如果要插入的值小于当前节点值，则将要插入的值作为左子节点插入，并将左子节点入栈；如果要插入的值大于当前节点值，则将要插入的值作为右子节点插入，并将右子节点入栈；如果要查找或删除的值等于当前节点值，则返回或删除该节点。
操作完成后，继续从堆栈中取出下一个节点进行操作，直到堆栈为空。

需要注意的是，在这种实现方式中，由于使用了堆栈来存储遍历树的过程，因此可能会导致内存占用较高。另外，由于堆栈的特性，这种实现方式只能支持深度优先遍历（Depth-First Search，DFS），不能支持广度优先遍历（Breadth-First Search，BFS）。

以下是伪代码示例：

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

def insert(root, value):
    if not root:
        return Node(value)
    stack = [root]
    while stack:
        node = stack.pop()
        if value < node.data:
            if node.left is None:
                node.left = Node(value)
                break
            else:
                stack.append(node.left)
        elif value > node.data:
            if node.right is None:
                node.right = Node(value)
                break
            else:
                stack.append(node.right)

def search(root, value):
    stack = [root]
    while stack:
        node = stack.pop()
        if node.data == value:
            return True
        elif value < node.data and node.left:
            stack.append(node.left)
        elif value > node.data and node.right:
            stack.append(node.right)
    return False

def delete(root, value):
    if root is None:
        return None
    if value < root.data:
        root.left = delete(root.left, value)
    elif value > root.data:
        root.right = delete(root.right, value)
    else:
        if root.left is None:
            temp = root.right
            del root
            return temp
        elif root.right is None:
            temp = root.left
            del root
            return temp
        else:
            temp = root.right
            while temp.left is not None:
                temp = temp.left
            root.data = temp.data
            root.right = delete(root.right, temp.data)
    return root

以上是四种在Python中实现二叉搜索树的方法，在具体使用过程中还是需要合理选择，尽量以运行速度快、内存占用少为出发点，更多相关python 二叉搜索树内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: python实现二叉搜索树的四种方法

本文链接: https://www.lsjlt.com/news/208921.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

回答

如何调试操作系统的错误？
操作系统

2023-11-15发布

回答

操作系统中的I/O系统是如何实现的？
操作系统

2023-11-15发布

回答

如何实现操作系统的内存管理？
操作系统

2023-11-15发布

回答

什么是虚拟内存，它对操作系统有什么影响？
操作系统

2023-11-15发布

回答

ASP中的MVC架构和WebForms架构有什么区别和使用场景？
ASP.NET

2023-11-15发布

回答

ASP中的数据验证和数据校验有什么不同？
ASP.NET

2023-11-15发布

回答

ASP中的ADO对象和DAO对象有什么区别和使用方法？
ASP.NET

2023-11-15发布

回答

Node.js中的包管理器NPM是什么？如何使用它进行依赖管理？
node.js

2023-11-15发布

回答

Vue.js中的动态组件是什么？如何使用它来动态渲染组件？
VUE

2023-11-15发布

回答

如何使用Vue.js实现懒加载和预加载？
VUE

2023-11-15发布

python实现二叉搜索树的四种方法

目录

树的介绍

二叉搜索树

列举几种Python中几种常见的实现方式：

1.使用类和递归函数实现

2.使用列表实现

3.使用字典实现

4.使用堆栈实现

本篇文章演示代码以及资料文档资料下载

python实现二叉搜索树的四种方法

Python实现二叉搜索树

python实现二叉搜索树的方法有哪些

Python二叉搜索树与双向链表转换实现方法

利用java实现二叉搜索树

Java二叉搜索树与数组查找的方法

如何利用JavaScript实现二叉搜索树

C++实现LeetCode(98.验证二叉搜索树)

C++实现LeetCode(99.复原二叉搜索树)

怎么利用JavaScript实现二叉搜索树

C++实现验证二叉搜索树代码

C++如何实现验证二叉搜索树

【C++】平衡二叉搜索树的模拟实现

C++实现LeetCode(96.独一无二的二叉搜索树)

Java二叉树的四种遍历方式详解

C++实现LeetCode(95.独一无二的二叉搜索树之二)

C++实现LeetCode(173.二叉搜索树迭代器)

如何通过代码实现二叉搜索树

C++使用LeetCode实现独一无二的二叉搜索树

C++数据结构之搜索二叉树的实现

python分析数据的方法是什么

如何使用Python实现抽奖小程序

python copy函数的作用是什么

python进程池创建队列的方法是什么

python字符串处理与应用的方法有哪些

python全局变量如何定义

python如何读取文件夹下所有文件

python keyerror错误怎么解决

python如何提取字符串的数字

python中怎么将回车作为输入内容