二叉排序树（C与Python分别实现）

最新推荐文章于 2022-01-12 17:29:01 发布
最新推荐文章于 2022-01-12 17:29:01 发布
阅读量2.8k 收藏 4
点赞数
分类专栏： c/c++ python 文章标签： 二叉排序树 二叉查找树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wanglx_/article/details/40662583
版权

1.      什么是二叉排序树？

二叉排序树是一种特殊的二叉树，可以是一棵空树，也可以是具有下列性质的二叉树：

1.      若左子树不为空，那么左子树所有结点的值都小于它的根结点的值。

2.      若右子树不为空，那么右子树所有结点的值都大于它的根节点的值。

3.      它的左右子树也分别是二叉排序树。

二叉排序树又称二叉查找树，是一种动态查找表，所谓动态查找表是指除了查询检索操作以外，还可以进行插入、删除操作的结构；与之相对应的就是静态查找表，只能进行查询检索操作。

2.      二叉排序树的操作

对于二叉排序树的实现就是对查找、插入、删除操作的实现，因为要进行插入删除操作，所以要用链表结构来实现，操作介绍如下：

1.   查找key：从根结点出发，若key大于根结点则向根结点的右侧走，跟这个根结点的右结点比较，若key小于根结点则向根结点的左侧走，跟这个根结点做结点比较，该根结点的左右子树分别都是二叉排序树，所以重复上面的步骤，直到找到key，或者到NULL（叶子结点的子结点为空）。

2.   插入key：跟查找key步骤相同，找到key时返回，不进行插入，未找到时，在最后一个查找叶子结点下插入key值，若key大于该叶子结点的值则插入该叶子结点的右侧，作为该叶子结点的右子树，否则作为左子树。

3.   删除key：跟查找key步骤相同，若查找最终为NULL（未找到），则返回，若在结点p处找到key，则进行一下判断：

    a.      若p为叶子结点，先找到p的父节点q，若p为q的左子树，则将q的左子树指针至NULL，若p为q的右子树，则将q的右子树指针至NULL，删除p

    b.      若p的左子树不为空，右子树为空，则找到p的父节点q，若p是q的左子树，则将q的左子树指针指向p的左子树，若p是q的右子树，则将q的右子树指针指向p的左子树，删除p

    c.      若p的右子树不为空，左子树为空，则找到p的父节点q，若p是q的左子树，则将q的左子树指针指向p的右子树，若p是q的右子树，则将q的右子树指针指向p的右子树，删除p

    d.      若p的左右子树都不为空，则找到p的父节点q，将p的左子树作为p右子树的最左结点的子结点，然判断p是q的右子树还是q的左子树，若p是q的左子树，则将q的左子树指针指向p的右子树，若p是q的右子树，则将q的右子树指针指向p的右子树，删除p

3.      二叉排序树代码实现：

C代码

注意：下面的查找操作使用的是递归方式实现，既然是递归就有递归深度的问题，太深容易造成堆栈溢出，在我电脑上最多可以进行10357次递归；可用循环替代递归。

#include <stdio.h>
typedef struct  TNode
{
	int nKey;
	struct TNode* lchild;
	struct TNode* rchild;
	struct TNode* parent;
}TNode;
//++++++++++++++++++++++++++查找检索操作++++++++++++++++++++++++++/
bool SearchBST(TNode* BST,int key,TNode* &pSearch,TNode* &pParent)
{
	if ( !BST )
	{
		pSearch = pParent;
		return false;
	}
	if ( BST->nKey == key )
	{
		pSearch = BST;
		pParent = pSearch->parent;
		return true;
	}
	else if ( BST->nKey>key )
	{
		pParent = BST;
		return SearchBST(BST->lchild,key,pSearch,pParent);
	}
	else
	{
		pParent = BST;
		return SearchBST(BST->rchild,key,pSearch,pParent);
	}
	return false;
}
//++++++++++++++++++++++++++结点插入操作++++++++++++++++++++++++++/
bool InsertNode(TNode* &BST,int key,TNode* &pSearch)
{
	TNode* pParent = NULL;
	if ( SearchBST(BST,key,pSearch,pParent) )
		return false;
	TNode* pNode = new TNode;
	pNode->nKey = key;
	pNode->parent = pParent;
	pNode->lchild = NULL;
	pNode->rchild = NULL;
	if ( !pParent )
		BST = pNode;
	else if ( key>pParent->nKey )
		pParent->rchild = pNode;
	else 
		pParent->lchild = pNode;
	pSearch = pNode;
	return true;
}
//++++++++++++++++++++++++++删除结点操作++++++++++++++++++++++++++/
bool DeleteNode(TNode* BST,int key)
{
	TNode* pSearch = NULL;
	TNode* pParent = NULL;
	if ( !SearchBST(BST,key,pSearch,pParent) )
		return false;
	if ( NULL!=pSearch->lchild && NULL!=pSearch->rchild )
	{
		TNode *pTmp = pSearch->rchild;
		while(pTmp->lchild) pTmp = pTmp->lchild;
		pTmp->lchild = pSearch->lchild;
		pSearch->lchild->parent = pTmp->lchild;
		if ( pParent->lchild == pSearch )
			pParent->lchild = pSearch->rchild;
		else
			pParent->rchild = pSearch->rchild;
		pSearch->rchild->parent=pParent;
	}
	else if ( NULL!=pSearch->lchild )
	{
		if( pParent->lchild == pSearch )
			pParent->lchild = pSearch->lchild;
		else
			pParent->rchild = pSearch->lchild;
	}
	else if ( NULL!=pSearch->rchild )
	{
		if ( pParent->lchild == pSearch )
			pParent->lchild = pSearch->rchild;
		else
			pParent->rchild = pSearch->rchild;
	}
	else
	{
		if( pParent->lchild == pSearch )
			pParent->lchild = NULL;
		else
			pParent->rchild = NULL;
	}
	delete pSearch;
	pSearch = NULL;
	return true;
}
//++++++++++++++++++++++++++释放内存操作++++++++++++++++++++++++++/
void DeleteBST(TNode* BST)
{
	if( !BST )return;
	if ( !BST->lchild && !BST->rchild )
	{
		if( !BST->parent && BST->parent->lchild == BST )
			BST->parent->lchild = NULL;
		else if( !BST->parent && BST->parent->rchild == BST ) 
			BST->parent->rchild = NULL;
		delete BST;
		BST = NULL;
		return;
	}
	DeleteBST(BST->lchild);
	DeleteBST(BST->rchild);	
}
//++++++++++++++++++++++++++main测试++++++++++++++++++++++++++/
int main(int argc, char* argv[])
{
	TNode* BST = NULL;
	TNode* pNode = NULL;
	TNode* pParent = NULL;
	int nCount = 10358;
	for ( int i=0;i<nCount;i++ )
	{
		if( InsertNode(BST,i,pNode) )
			printf("插入%d成功\n",i);
	}
	if ( SearchBST(BST,nCount-1,pNode,pParent) )
	{
		printf("查找成功\n");
	}
	DeleteNode(BST,1);
	if ( !SearchBST(BST,1,pNode,pParent) )
	{
		printf("查找失败");
	}
	DeleteBST(BST);
	getchar();
	return 0;
}

Python代码

第一次学习Python，代码中肯定有许多不足之处，希望指正，暂时实现如下：

#BST.py
_Debug = False
#+++++++++++++++++++++struct realized by class+++++++++++++++++++++#
class TNode:
    def __init__(self,key,left,right,parent):
        self.key=key
        self.lchild=left
        self.rchild=right
        self.parent=parent
class PTNode:
    def __init__(self,TNode):
        self.TNode=TNode
#+++++++++++++++++++++++++search operation+++++++++++++++++++++++++#
def SearchBST(BST,key,search,parent):
    if None==BST or None==BST.key:
        return False
    if key==BST.key:
        parent.TNode=BST.parent
        search.TNode=BST
        return True
    elif key<BST.key:
        parent.TNode=BST
        return SearchBST(BST.lchild,key,search,parent)
    else:
        parent.TNode=BST
        return SearchBST(BST.rchild,key,search,parent)
    return False
#+++++++++++++++++++++++++Insert operation+++++++++++++++++++++++++#
def InsertNode(BST,key,search):
    Pparent=PTNode(BST)
    Psearch=PTNode(BST)
    if _Debug==True:
        import pdb
        pdb.set_trace()
    if SearchBST(BST,key,Psearch,Pparent):
       return False
    parent=Pparent.TNode
    search=Psearch.TNode
    Node=TNode(key,None,None,None)
    if None==parent or None==parent.key:
        BST=Node
        return True
    if key>parent.key:
        parent.rchild=Node
    else:
        parent.lchild=Node
    Node.parent=parent
    search=Node
    return True
#+++++++++++++++++++++++++Delete operation+++++++++++++++++++++++++#
def DeleteNode(BST,key):
    Pparent=PTNode(BST)
    Psearch=PTNode(BST)
    if False==SearchBST(BST,key,Psearch,Pparent):
        return False
    parent=Pparent.TNode
    search=Psearch.TNode
    if None!=search.lchild and None!=search.rchild:
        tmp=search
        while(None!=tmp.lchild):
            tmp=tmp.lchild
        tmp.lchild=search.lchild
        if None!=parent and search==parent.lchild:

            parent.lchild=search.rchild
            search.rchild.parent=parent
        elif None!=parent and search==parent.rchild:
            parent.rchild=search.rchild
            search.rchild.parent=parent

    elif None!=search.lchild:
        if None!=parent and search==parent.lchild:
            parent.lchild=search.lchild
            search.lchild.parent=parent
        elif None!=parent and search==parent.rchild:
            parent.rchild=search.lchild
            search.lchild.parent=parent
    elif None!=search.rchild:
        if None!=parent and search==parent.lchild:
            parent.lchild=search.rchild
            search.rchild.parent=parent
        elif None!=parent and search==parent.rchild:
            parent.rchild=search.rchild
            search.rchild.parent=parent
    else:
        parent.lchild=None
        parent.rchild=None
    del search
    search=None
    return True
#+++++++++++++++++++++++++Release operation+++++++++++++++++++++++++#
def DeleteBST(BST):
    if None!=BST:
        if None==BST.lchild and None==BST.rchild:
            tmp=BST.parent
            if tmp!=None and tmp.lchild==BST:
                tmp.lchild=None
            elif tmp!=None and tmp.rchild==BST:
                tmp.rhicld=None
            del BST
            BST=None
            return
        DeleteBST(BST.lchild)
        DeleteBST(BST.rchild)
    
#+++++++++++++++++++++++++Print  operation+++++++++++++++++++++++++#
def PrintBST(BST):
    if None==BST:
        return
    print BST.key
    PrintBST(BST.lchild)
    PrintBST(BST.rchild)
#++++++++++++++++++++++++++Test operation++++++++++++++++++++++++++#
if __name__=='__main__':
    BST=TNode(0,None,None,None)
    Pparent=PTNode(BST)
    Psearch=PTNode(BST)
    for i in range(1,4):
        if False==InsertNode(BST,i,Psearch.TNode):
            print 'Insert Number %d Failed.'%(i)
    print 'print BST:'
    PrintBST(BST)
    if True==SearchBST(BST,1,Psearch,Pparent):
        print 'Find 1 in BST Sucess.'
    if True==DeleteNode(BST,1):
            print 'Delete 1 Success.'
    if False==SearchBST(BST,1,Psearch,Pparent):
        print 'Find 1 in BST Failed.'

    DeleteBST(BST)
    print 'Done'

4.      二叉排序树的查找复杂度

最坏复杂度为O(n),最好为O(1)

参考：《数据结构（C语言版）》严蔚敏 吴为民

 

 

wanglx2012
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉排序树详解
云杉木屋
04-01 2万+
摘要：本篇笔记专门介绍二叉排序树，重点讲解了二叉排序树的特性，以及二叉排序树各方面的基本实现。
二叉排序树
清风
04-30 5280
二叉排序树 1.定义 二叉排序树(BST)，又称为二叉树搜索树和二叉查找树。 定义： 如果它的左子树非空，则左子树中的所有结点的值都小于根节点的值 反之，若右子树非空，则右子树上所有的结点的值都大于等于根节点的值 其左右子树本身也是二叉排序树 二叉排序树 该二叉树的中序遍历的结果一定是有序的，如上的中序遍历的结果为3,12,24,37,45,53,61,78,90,99 2.二叉排序树的操作 二叉排序树有关的一些操作可以包含search查找，minimum查找最小值，maxi
Python实现二叉排序树
Wangtuo1115的博客
06-15 1608
一、什么是二叉排序树？ 二叉排序树要么是一棵空二叉树，要么是具有如下特点的二叉树： 二叉排序树中，如果其根结点有左子树，那么左子树上所有节点的值都小于根结点的值； 二叉排序树中，如果其根结点有右子树，那么右子树上所有节点的值都大于根结点的值； 二叉排序树的左右子树也要求都是二叉排序树。 如下图所示： 二、二叉排序树的Python实现 二叉排序树的插入 插入： 从根结点开始逐个与关键字进行比较，小于根结点去左边，大于根结点去右边，碰到子树为空的情况指向关键字。 二叉排序树的查找 查找： 对比节点的值和关
python实现二叉排序树
EMIvv的博客
01-12 1032
#二叉排序树 class BTree(): def __init__(self,data): self.left = None self.right = None if type(data) == list: self.data = data[0] for d in data[1:]: self.insert(d) else: sel
python 二叉排序树
随风奔跑的专栏
04-24 2165
#! /usr/bin/env python class BTNode: def __init__(self, data, left, right): self.data = data self.left = left self.right = right class BTree: def __init__(self, root
数据结构（二叉平衡排序树）课程设计报告
10-25
数据结构是计算机科学中的核心概念，它涉及到如何高效地存储...通过这次课程设计，你不仅将深入理解二叉平衡排序树的原理，还将锻炼到实际问题的解决能力和编程技巧，为未来在数据结构与算法领域的发展打下坚实的基础。
python和C语言实现：一些经典算法的集合
11-21
本资源集合专注于"Python"与"C语言"这两种不同风格的编程语言，用于实现一系列经典算法。这些算法和数据结构是计算机科学的基础，也是解决复杂问题的核心工具。下面将详细讨论涉及的知识点。 首先，我们来看"Python...
binary_search_tree.zip
07-06
在`main.cpp`中，通常会包含二叉排序树的基本操作的实现，如插入、删除、查找等。以下是这些操作的基本概念： - **插入操作**：当向二叉排序树插入新节点时，根据节点的键与当前节点的比较，决定将其插入到左子树...
Python算法与设计模式面试题汇总！.docx
06-12
Python算法与设计模式是编程面试中的重要组成部分，对于求职者来说，掌握这些知识不仅可以提升面试成功率，也是在实际工作中解决问题的基础。以下是一些常见的Python算法与设计模式面试问题的详细解答： 1. **顺序...
数据结构和算法：使用C ++ STL，Python，Lisp的实现
02-01
数据结构与算法 在阅读《破解编码面试》这本书时，我一直在实现本书中的一些基本概念，并将其上载到此回购中以供参考。样题结帐***问题-解决方案***。 我试图提供C ++ STL，Python和Lisp的解决方案。 以下是一些重要...
学习笔记-用二叉排序树实现字典类（Python实现）
Bebr的博客
06-17 1990
二叉排序树，又称二叉查找树，或二叉搜索树。二叉排序树或者为空，或者具有以下性质：如果其左子树不空，那么其左子树上所有结点的值均小于其根结点的值。如果其右子树不空，那么其右子树上所有结点的值均大于其根结点的值。非空的左子树或右子树也是二叉排序树。如果对二叉排序树做中序遍历，将得到一个递增序列。下图是数据集[36,65,18,7,60,89,43,57,96,52,74]所生成的两棵二叉排序树。可见，...
二叉排序树（二叉搜索树，二叉查找树）的（python）实现
time_money的博客
11-04 729
二叉排序树，又叫做二叉搜索树或者二叉查找树，它具有以下性质： 若左子树不为空，则左子树上所有节点的值均小于或等于它的根节点的值。 若右子树不为空，则右子树上所有节点的值均大于或等于它的根节点的值。 左、右子树也分别为二叉搜索树。 构建二叉查找树及其操作 class BSTNode: """ 定义一个二叉树节点类。 以讨论算法为主，忽略了一些诸如对数据类型进行判断的问题。 """ def __init__(self, data): """
二叉排序树的查找、插入、创建、结点删除python实现（大话数据结构版本）
lincoco49的博客
03-20 1276
定义结点 首先定义一个二叉链表结点结构的定义 class Node(object): """节点定义，包括数据项、左孩子、右孩子""" def __init__(self, data): self.data = data self.lchild = None self.rchild = None 查找 def search...
python实现二叉搜索树
qq_41386300的博客
04-23 647
1. 定义 二叉搜索树(Binary Search Tree)，又名二叉排序树(Binary Sort Tree)。 二叉搜索树是具有有以下性质的二叉树： （1）若左子树不为空，则左子树上所有节点的值均小于或等于它的根节点的值。 （2）若右子树不为空，则右子树上所有节点的值均大于或等于它的根节点的值。 （3）左、右子树也分别为二叉搜索树。 2. 相关操作 2.1 插入 从根节点开始，若插入的值...
二叉树和排序二叉树 python实现
qq_41209110的博客
04-06 184
class Node: def __init__(self,item): self.item = item self.left = None self.right = None class Tree: def __init__(self): self.root = None def addNode(self,i...
Python 实现二叉搜索树（BST）
Herishwater的博客
07-30 5176
前言 二叉搜索树（Binary Search Tree）是一种特殊的二叉树，支持多种动态集合操作，如 Search、Insert、Delete、Minimum 和 Maximum 等。 二叉查找树要么是一棵空树，要么是一棵具有如下性质的非空二叉树： 若左子树非空，则左子树上的所有结点的关键字值均小于根结点的关键字值。 若右子树非空，则右子树上的所有结点的关键字值均大于根结点的关键字值。 左、右子...
二叉排序树链表实现
freepenix 的学习之路
09-10 1351
二叉排序数的（递归）定义：1、若左子树非空，则左子树所有节点的值均小于它的根节点；2、若右子树非空，则右子树所有节点的值均大于于它的根节点；3、左右子树也分别为二叉排序树。 如图： 链表实现（比较简单）： #include #include typedef struct node { int data; struct node * lchild; str
Python 构造二叉搜索树
z649431508的博客
09-09 983
本文采用Python语言编写数据结构之二叉搜索树，主要实现二叉树的构造，插入数据，删除数据，以及二叉树的中序遍历，先序遍历，和后序遍历。
实现读入一串字符创建一棵二叉排序树，然后分别实现：二叉排序树的查找；二叉排序树的插入；二叉排序树的删除等操作
最新发布
11-28
以下是实现读入一串字符创建一棵二叉排序树，然后分别实现二叉排序树的查找、插入、删除等操作的Python代码： ```python # 定义二叉排序树的节点类 class TreeNode: def __init__(self, val): self.val = val self.left = None self.right = None # 定义二叉排序树类 class BST: def __init__(self): self.root = None # 插入节点 def insert(self, val): if not self.root: self.root = TreeNode(val) return cur = self.root while cur: if val < cur.val: if not cur.left: cur.left = TreeNode(val) return cur = cur.left else: if not cur.right: cur.right = TreeNode(val) return cur = cur.right # 查找节点 def search(self, val): cur = self.root while cur: if cur.val == val: return True elif cur.val > val: cur = cur.left else: cur = cur.right return False # 删除节点 def delete(self, val): def find_min(root): while root.left: root = root.left return root def delete_node(root, val): if not root: return None if root.val == val: if not root.left and not root.right: return None if not root.left: return root.right if not root.right: return root.left min_node = find_min(root.right) root.val = min_node.val root.right = delete_node(root.right, min_node.val) elif root.val > val: root.left = delete_node(root.left, val) else: root.right = delete_node(root.right, val) return root self.root = delete_node(self.root, val) # 读入一串字符 s = input() # 创建二叉排序树 bst = BST() for c in s: bst.insert(c) # 查找节点 print(bst.search('a')) # 插入节点 bst.insert('b') # 删除节点 bst.delete('a') ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值