搜索二叉树的增删查改

最新推荐文章于 2022-06-27 17:03:55 发布
最新推荐文章于 2022-06-27 17:03:55 发布
阅读量626 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 搜索二叉树 二叉树的增加 删除 修改 查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Silence723/article/details/51801056
版权
    首先我简单介绍一下搜索二叉树的概念及有关性质，纯属个人观点，如有错误，欢迎不吝赐教。
1、搜索二叉树的概念：根结点的左子树都小于它，它的右子树都大于它，且它的左子树与右子树都是搜素二叉树。
2、二叉搜索树（搜索二叉树）：搜索二叉树即是排序二叉树，中序遍历它的结果是有序的（升序）。
  1. 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。
  2. 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。
  3. 右子树上所有节点的关键码（key）都大于根节点的关键码（key）。
  4. 左右子树都是二叉搜索树。
搜索二叉树的非递归插入：
     思想：
代码如下：
//非递归插入
           bool Insert( const K & key , const V & value )
          {
                    if (_root == NULL )
                   {
                             _root = new Node ( key , value );
                              return true ;
                   }

                    Node * parent = NULL ;
                    Node * cur = _root;
                    while (cur)
                   {
                              if (cur->_key < key )
                             {
                                      parent = cur;
                                      cur = cur->_right;
                             }
                              else if (cur->_key > key )
                             {
                                      parent = cur;
                                      cur = cur->_left;
                             }
                              else
                             {
                                       return false ;
                             }
                   }

                    if (parent->_key < key )
                             parent->_right = new Node ( key , value );
                    else
                             parent->_left = new Node ( key , value );

                    return true ;
          }
递归插入算法如下：
//递归插入
           bool InsertR( const K & key , const V & value )
          {
                    return _InsertR(_root, key , value );
          }

           bool _InsertR( Node *& root , const K & key , const V & value )
          {
                    if ( root == NULL )
                   {
                              root = new Node ( key , value );
                              return true ;
                   }

                    if ( root ->_key > key )
                              return _InsertR( root ->_left, key , value );
                    else if ( root ->_key < key )
                              return _InsertR( root ->_right, key , value );
                    else
                              return false ;
          }
查找指定节点（非递归方法）：
Node * Find( const K & key )
          {
                    Node * cur = _root;
                    while (cur)
                   {
                              if (cur->_key < key )
                             {
                                      cur = cur->_right;
                             }
                              else if (cur->_key > key )
                             {
                                      cur = cur->_left;
                             }
                              else
                             {
                                       return cur;
                             }
                   }

                    return NULL ;
          }
递归方法查找指定的节点：
Node * Find( const K & key )
          {
                    Node * cur = _root;
                    while (cur)
                   {
                              if (cur->_key < key )
                             {
                                      cur = cur->_right;
                             }
                              else if (cur->_key > key )
                             {
                                      cur = cur->_left;
                             }
                              else
                             {
                                       return cur;
                             }
                   }

                    return NULL ;
          }
删除指定节点（非递归方法）：


//删除指定节点
           bool Remove( const K & key )
          {
                    Node * parent = NULL ;
                    Node * cur = _root;
                    //cur不为空
                    while (cur)
                   {
                              if (cur->_key < key )
                             {
                                      parent = cur;
                                      cur = cur->_right;
                             }
                              else if (cur->_key > key )
                             {
                                      parent = cur;
                                      cur = cur->_left;
                             }
                              else
                             {
                                       break ; //相等时直接break掉
                             }
                   }
                    //cur为空时，没有找到指定删除的节点，返回false
                    if (cur == NULL )
                   {
                              return false ;
                   }
                    //cur的左子树为空
                    if (cur->_left == NULL )
                   {
                              //parent==NULL，说明cur是根节点，要删除cur（由上步可知cur的左子树为空），所以要删除cur，只需要让_root指向cur->right即可。
                              if (parent == NULL )
                             {
                                      _root = cur->_right;
                             }
                              else
                             {
                                       if (parent->_left == cur)
                                                parent->_left = cur->_right;
                                       else
                                                parent->_right = cur->_right;
                             }

                              delete cur;
                   }
                    else if (cur->_right == NULL )
                   {
                              if (parent == NULL )
                             {
                                      _root = cur->_left;
                             }
                              else
                             {
                                       if (parent->_left == cur)
                                                parent->_left = cur->_left;
                                       else
                                                parent->_right = cur->_left;
                             }

                              delete cur;
                   }
                    else
                   {
                              // 找右子树里面的最左结点
                             parent = cur;
                              Node * subLeft = cur->_right;
                              while (subLeft->_left)
                             {
                                      parent = subLeft;
                                      subLeft = subLeft->_left;
                             }

                             cur->_key = subLeft->_key;
                             cur->_value = subLeft->_value;

                              if (parent->_left == subLeft)
                                      parent->_left = subLeft->_right;
                              else
                                      parent->_right = subLeft->_right;

                              delete subLeft;
                   }

                    return true ;
          }
递归删除：
//递归删除
           bool RemoveR( const K & key )
          {
                    return _RemoveR(_root, key );
          }

           bool _RemoveR( Node *& root , const K & key )
          {
                    if ( root == NULL )
                              return false ;

                    if ( root ->_key > key )
                   {
                              return _RemoveR( root ->_left, key );
                   }
                    else if ( root ->_key < key )
                   {
                              return _RemoveR( root ->_right, key );
                   }
                    else
                   {
                              if ( root ->_left == NULL )
                             {
                                       root = root ->_right;
                             }
                              else if ( root ->_right == NULL )
                             {
                                       root = root ->_left;
                             }
                              else
                             {
                             }
                   }

                    return true ;
          }

附录（具体代码实现如下）：
#pragma once
#include<iostream>
#include<string>
template<class K,class V>
//构造搜索化二叉树结构体
struct BSTreeNode
{
K _key;
V _value;
BSTreeNode<K, V> *_left;
BSTreeNode<K, V> *_right;


//构造函数
BSTreeNode(const K& key,const V& value)
:_key(key)
,_value(value)
,_left(NULL)
,_right(NULL)
{}
};


template<class K, class V>
class BSTree
{
typedef BSTreeNode<K, V> Node;
public:
BSTree()
:_root(NULL)
{}
//非递归插入
bool Insert(const K& key, const V& value)
{
if (_root == NULL)
{
_root = new Node(key, value);
return true;
}


Node* parent = NULL;
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}


if (parent->_key < key)
parent->_right = new Node(key, value);
else
parent->_left = new Node(key, value);


return true;
}
//递归插入
bool InsertR(const K& key, const V& value)
{
return _InsertR(_root, key, value);
}


bool _InsertR(Node*& root, const K& key, const V& value)
{
if (root == NULL)
{
root = new Node(key, value);
return true;
}


if (root->_key > key)
return _InsertR(root->_left, key, value);
else if (root->_key < key)
return _InsertR(root->_right, key, value);
else
return false;
}


Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
cur = cur->_right;
}
else if (cur->_key > key)
{
cur = cur->_left;
}
else
{
return cur;
}
}


return NULL;
}


Node* FindR(const K& key)
{
return _FindR(key);
}


Node* _FindR(Node* root, const K& key)
{
if (root == NULL)
{
return NULL;
}


if (root->_key < key)
{
return _FindR(root->_right, key);
}
else if (root->_key > key)
{
return _FindR(root->_left, key);
}
else
{
return root;
}
}
//删除指定节点
bool Remove(const K& key)
{
Node* parent = NULL;
Node* cur = _root;
//cur不为空
while (cur)
{
if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else
{
break;//相等时直接break掉
}
}
//cur为空时，没有找到指定删除的节点，返回false
if (cur == NULL)
{
return false;
}
//cur的左子树为空
if (cur->_left == NULL)
{
//parent==NULL，说明cur是根节点，要删除cur（由上步可知cur的左子树为空），所以要删除cur，只需要让_root指向cur->right即可。
if (parent == NULL)
{
_root = cur->_right;
}
else
{
if (parent->_left == cur)
parent->_left = cur->_right;
else
parent->_right = cur->_right;
}


delete cur;
}
else if (cur->_right == NULL)
{
if (parent == NULL)
{
_root = cur->_left;
}
else
{
if (parent->_left == cur)
parent->_left = cur->_left;
else
parent->_right = cur->_left;
}


delete cur;
}
else
{
// 找右子树里面的最左结点
parent = cur;
Node* subLeft = cur->_right;
while (subLeft->_left)
{
parent = subLeft;
subLeft = subLeft->_left;
}


cur->_key = subLeft->_key;
cur->_value = subLeft->_value;


if (parent->_left == subLeft)
parent->_left = subLeft->_right;
else
parent->_right = subLeft->_right;


delete subLeft;
}


return true;
}
//递归删除
bool RemoveR(const K& key)
{
return _RemoveR(_root, key);
}


bool _RemoveR(Node*& root, const K& key)
{
if (root == NULL)
return false;


if (root->_key > key)
{
return _RemoveR(root->_left, key);
}
else if (root->_key < key)
{
return _RemoveR(root->_right, key);
}
else
{
if (root->_left == NULL)
{
root = root->_right;
}
else if (root->_right == NULL)
{
root = root->_left;
}
else
{
}
}


return true;
}
//中序遍历
void InOrder()
{
_InOrder(_root);
cout << endl;
}


void _InOrder(Node* root)
{
if (root == NULL)
return;
        }

protected:
Node* _root;
};


void TestTree()
{
BSTree<int, int> t;
int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
{
t.Insert(a[i], i);
}
t.InOrder();


cout << "IsBlance?" << t.IsBlanceTree() << endl;


t.Remove(8);
t.Remove(7);
t.Remove(2);
t.Remove(1);


t.InOrder();


t.Remove(0);
t.Remove(1);
t.Remove(2);
t.Remove(3);
t.Remove(4);
t.Remove(5);
t.Remove(6);
t.Remove(7);
t.Remove(8);
t.Remove(9);


t.InOrder();
}


void TestDict()
{
BSTree<string, string> dict;
dict.Insert("Tree", "树");
dict.Insert("Sort", "哈希");
dict.Insert("Hash", "排序");
dict.InOrder();


BSTreeNode<string, string>* ret = dict.Find("Sort");
ret->_value = "排序";


ret = dict.Find("Hash");
ret->_value = "哈希";


dict.InOrder();
}
Silence723
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构--------二叉树的增删查改
qq_37807989的博客
06-25 374
public class Node { public Node right; public Node left; public int data; public Node(int data) { this.data = data; } public Node() { } } /** * 二叉树方法: * ...
数据结构之树
xiaotai1234的博客
10-17 438
数据结构之树 一、二叉树 1.为什么需要树这种数据结构 2.树的常用术语 3.二叉树的概念 二、二叉树遍历 1.前中后序遍历 2.二叉树查找节点 3.二叉树删除节点 package com.atguigu.tree; public class BinaryTreeDemo { public static void main(String[] args) { //先需要创建一颗二叉树 BinaryTree binaryTree = new BinaryTree(); //创
数据结构之二叉搜索树的增删查改（图解，代码6000多字总结）
冷萃美式的博客
08-16 689
文章目录一：概念1.用处2.定义3. 性质4.遍历伪代码5.基本操作5.1 查找5.2 最小关键字5.3 最大关键字5.4 插入5.5 删除 一：概念 1.用处  二叉搜索树既可以作为一个字典又可以作为一个优先队列 2.定义  顾名思义，二叉搜索树是一颗具有一定性质的二叉树。 可以使用一个链表来表示，其中的每一个节点都是一个对象，除了key和卫星数据之外，么一个节点还包含属性left,right，parent。如果对应的节点不存在的时候，则相应属性的值为nil。 根节点是整棵树中唯一一个父指针为nil的节点
二叉树(一)| 二叉树的基本操作(增删改查)解析(java实现)
KevinBrain的博客
07-08 635
二叉树节点的存储结构 首先定义二叉树结构的节点存储结构： public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } 插入节点 过程分析： 每次插入节点需要明确知道被插入的父节点以及被插入节点的位置(左右)。 如果为空树，则直接当前节点作为根节点。 如果不为空树： 如果新节点值比当前节点值大，则往...
二叉排序树增删改查
wdquan19851029的专栏
06-27 310
二叉排序树(BST--Binary Sort Tree)，要求任何一个非叶子节点，左子节点的值小于当前节点的值，右子节点的值大于当前节点的值。如果有相等的值，可以将其放在左子节点或者右子节点。 优点是既能快速查找，又能快速增删 其它数据结构的劣势： 数组（未排序）：查找速度慢（相对于二叉排序树） 数组（已排序）：可以使用二分查找、查找速度快，缺点：为了保证数组有序，在插入新数据，找到插入位置时，后面的数据需要整体迁移，速度慢。 链表：查找很慢，增删很快 package com.bruce....
自己写的单链表的增删查改
最新发布
01-23
在这个项目中，我们关注的是自己编写的单链表实现，包括增、删、查、改这四个基本操作。这些操作是单链表操作的核心，也是理解和掌握链表数据结构的关键。 首先，我们来了解一下单链表的基本概念。单链表由一系列...
简单的单向链表，二叉树学习，附带工程源码，可直接运行
02-24
链表的主要操作有增、删、查、改。在单向链表中，插入操作通常涉及找到插入位置然后修改前后节点的指针；删除操作需要找到待删除节点并调整相邻节点的指针；查找操作则需遍历链表直至找到目标；修改操作则直接对找到...
二叉树创建及其基本操作C++.zip
07-07
**增删查改节点**： 1. **增加**：在二叉树中插入新节点，首先需要找到插入位置，通常是找到一个合适的位置让新节点成为现有节点的左子节点或右子节点。 2. **删除**：删除节点涉及到三种情况：没有子节点（叶子节点...
C++学生管理系统(二叉树)
02-06
2. **教师管理**：教师信息的增删查改与学生类似，只是需要考虑教师的教学科目。教师节点可以关联一个或多个课程节点，表示教授的课程。 3. **课程管理**：课程信息的维护，包括开设课程、取消课程和查询课程信息。...
java下非递归实现平衡二叉树
09-11
平衡二叉树的一个常见类型是AVL树，本文将深入探讨如何在Java下非递归地实现AVL树，并介绍其增删查改的基本操作。 **AVL树的特性：** 1. 左右子树高度差不超过1。 2. 对于任意节点，其左子树和右子树的高度最大差别...
实现二叉树的增删改查基本操作的c++程序
07-29
很好很强大的程序，实现二叉树的增删改查等基本操作，操作简单，程序结构清晰
二叉树查找增删改查
baixiaoshi的专栏
07-09 2994
#include <stdio.h> #include <string.h> #include <stdlib.h> #ifndef __Tree_H struct TreeNode; typedef struct TreeNode *Position; typedef struct TreeNode *SearchTree ; struct TreeNode { int num ; };
二叉树实现增删改查以及线索化二叉树详解
qq_53324833的博客
11-09 277
为什么需要树 二叉树介绍 二叉树遍历节点思路分析及代码实现 代码实现： package 树; public class BinaryTreeDemo { public static void main(String[] args) { //测试 //创建节点 HeroNode root = new HeroNode(1,"宋江"); //宋江作为根节点传入树中建树 HeroNode n2 = new HeroNode(2
二叉树排序树的增删查改超详细讲解
eggplant_的博客
10-08 1340
首先我们先了解下什么是二叉树：    在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。     简单来说就是一个节点有最多有两个孩子左孩子右孩子，最少可以没有孩子，叫做叶子节点，这样组成的数就叫做二叉树 像这样的树：  1、插入 当插入一列数的...
二叉树的基本操作（增、删、改、查） C/C++
AModestBoy的博客
05-21 3347
#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;time.h&gt;#define MaxSize 1024typedef int TElemType;typedef struct BstNode{ int data;//数据域 BstNode *Left;//指针域 BstNode *Right;}Bs...
浅谈数据结构之：二叉树与二叉树的增删改查
qq_41903105的博客
11-29 248
本文纯自己的一些独到感受和理解，长期努力完善和总结~ ————————————分割线———————————— 一、数据结构是什么？ 数据结构是指互相之间存在着一种或多种关系的数据元素的集合。且数据结构和数据元素之间存在逻辑关系，数据在计算机上的存储方式和在数据上定义的运算，可以归纳为三个方面：数据的逻辑结构、数据的存储结构和数据的运算。 二、二叉树是什么？ 二叉树是有限...
【二叉搜索树】增删改查功能代码实现
weixin_50563955的博客
06-27 409
二叉树的遍历规则，插入和删除，原理讲解和代码实现，全是干货，慢慢消化
二叉搜索树的插入、查找、删除的递归与非递归实现
小心眼儿猫的博客
05-16 1549
二叉搜索树： 1、要么为一个空树 2、要么不是一个空树 2.1、如果有左子树，对于该树中的每一个节点来说，该节点的左子树上的所有节点都要比该节点小 2.2、如果有右子树，对于该树中的每一个节点来说，该节点的右子树上的所有节点都要比该节点大 下面我们采用递归方法以及非递归方法来实现一下对于二叉搜索树的插入、查找以及删除操作。 1、基本操作：这里的基本操作思路简单，且在...
二叉树的增删改查
b766224的博客
10-05 241
package erTree; import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.List;import java.util.Stack; public class erTree {public static void main(Strin...
java二叉树的增删查改
07-28
二叉树的增删查改是二叉树操作中常见的操作，下面我分别介绍一下。 1. 增加节点： 在二叉树中增加一个节点，需要遵循以下规则： - 如果树为空，新节点成为根节点。 - 如果树不为空，从根节点开始，比较新节点的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值