比较全的二叉查找树(BinarySearchTree)的实现

最新推荐文章于 2021-03-09 13:43:38 发布
最新推荐文章于 2021-03-09 13:43:38 发布
阅读量617 收藏 1
点赞数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
#ifndef BinaryTree_H
#define BinaryTree_H
 
template<typename T>
struct  BinaryNode
{
     T element;
     BinaryNode * left;
     BinaryNode * right;
     BinaryNode( const  T & theElement,BinaryNode *lt = NULL,BinaryNode *rt = NULL):element(theElement),left(lt),right(rt) {}
};
template<typename T>
class  BinarySearchTree
{
public :
     BinarySearchTree();
     BinarySearchTree( const  BinarySearchTree & rhs);
     ~BinarySearchTree();
 
     const  T & findMin() const ;
     const  T & findMax() const ;
     bool  contains( const  T & x) const ;
     bool  isEmpty() const ;
     void  printTree() const ;
 
     void  makeEmpty();
     void  insert( const  T & x);
     void  remove( const  T & x);
 
     const  BinarySearchTree & operator =( const  BinarySearchTree & rhs);
 
     int  countNodes() const ;
     int  countLeaves() const ;
     int  countFull() const ;
 
     bool  check() const ;
     
     //在树上查找k1<=Keys(X)<=k2的值
     void  printRange(T & lower,T & upper,BinaryNode<T>* &root);
 
private :
 
 
     BinaryNode * root;
 
     void  insert( const  T & x,BinaryNode * &t) const
     {
         if (t == NULL)
             t = new  BinaryNode(x);
         else  if (x < t->element)
             insert(x,t->left);
         else  if (x > t->element)
             insert(x,t->right);
         else
             ;
     }
     void  remove( const  T & x,BinaryNode * &t) const
     {
         if (t == NULL)
             return  ;
         if (x < t->element)
             remove(x,t->left);
         else  if (x > t->element)
             remove(x,t->right);
         else  if (t->left != NULL && t->right != NULL)  //Two children
         {
             t->element = findMin(t->right)->element;
             remove(t->element,t->right);
         }
         else
         {
             BinaryNode * oldNode = t;
             t = (t->left != NULL) ? t->left : t->right;
             delete oldNode;
         }
     }
     BinaryNode * findMin(BinaryNode * t) const
     {
         if (t == NULL)
             return  NULL;
         else
         {
             while (t->left != NULL)
                 t = t->left;
             return  t;
         }
     }
     BinaryNode * findMax(BinaryNode * t) const
     {
         if (t == NULL)
             return  NULL;
         else
         {
             while (t->right != NULL)
                 t = t->right;
             return  t;
         }
     }
     bool  contains( const  T & x,BinaryNode *t) const
     {
         if (t == NULL)
             return  false ;
         else  if (x < t->element)
             return  contains(x,t->left);
         else  if (c > t->element)
             return  contains(x,t->right);
         else
             return  true ;
     }
     void  makeEmpty(BinaryNode *t) const
     {
         if (t == NULL)
             ;
         else
         {
             makeEmpty(t->left);
             makeEmpty(t->right);
             delete t;
             t = NULL;
         }
     }
     BinaryNode * clone(BinaryNode * t) const
     {
         if (t == NULL)
             return  NULL;
         else
             return  new  BinaryNode(t->element,clone(t->left),clone(t->right));
     }
     void  printTree(BinaryNode * &t) const
     { //这里采用中缀遍历
         cout << t->element << endl;
         printTree(t->left);
         printTree(t->right);
     }
 
     //统计t中结点的个数
     int  countNodes(BinaryNode * &t) const
     {
         if (t==NULL)
             return  0;
         else
             return  countNodes(t->left)+countNodes(t->right)+1;
     }
     
     //统计t中树叶的片数
     int  countLeaves(BinaryNode * &t) const
     {
         if (t == NULL)
             return  0;
         else  if (t->left == NULL && t->right == NULL)
             return  1;
         else
             return  countLeaves(t->left)+countLeaves(t->right);
     }
 
     //统计t中满结点的个数
     int  countFull(BinaryNode * &t) const
     {
         if (t == NULL)
             return  0;
         int  tIsFull = (t->left != NULL && t->right != NULL) ? 1:0;
         return  tIsFull + countFull(t->left) + countFull(t->right);
     }
 
     //测试一棵二叉树是否在每一个结点都满足查找树的序的性质
     bool  check(BinaryNode * &t) const
     {
         if (t->left == NULL && t->right == NULL)
             return  true ;
         else  if (!(t->element > findMin(t)->element && t->element < findMax(t)->element))
             return  false ;
         check(t->left);
         check(t->right);
     }
};
 
 
#endif

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include "BinaryTree.h"
#include <iostream>
using  namespace  std;
 
template<typename T>
BinarySearchTree<T>::BinarySearchTree()
{
     root = NULL;
}
 
template<typename T>
BinarySearchTree<T>::BinarySearchTree( const  BinarySearchTree & rhs)
{
     root = NULL;
     * this  = rhs;
}
 
template<typename T>
BinarySearchTree<T>::~BinarySearchTree()
{
     makeEmpty();
}
 
template<typename T>
const  T & BinarySearchTree<T>::findMin() const
{
     if (!isEmpty())
         return  findMin(root)->element;
}
 
template<typename T>
const  T & BinarySearchTree<T>::findMax() const
{
     if (!isEmpty())
         return  findMax(root)->element;
}
 
template<typename T>
bool  BinarySearchTree<T>::contains( const  T & x) const
{
     return  contains(x,root);
}
 
template<typename T>
bool  BinarySearchTree<T>::isEmpty() const
{
     return  root == NULL;
}
 
template<typename T>
void  BinarySearchTree<T>::printTree() const
{
     if (isEmpty())
         cout << "Empty tree."  << endl;
     else
         printTree(root);
}
 
template<typename T>
void  BinarySearchTree<T>::makeEmpty()
{
     makeEmpty(root);
}
 
template<typename T>
void  BinarySearchTree<T>::insert( const  T & x)
{
     insert(x,root);
}
 
template<typename T>
void  BinarySearchTree<T>::remove( const  T & x)
{
     remove(x,root);
}
 
 
/* Deep Copy*/
 
template<typename T>
const  BinarySearchTree<T> &BinarySearchTree<T>:: operator =( const  BinarySearchTree<T> & rhs)
{
     if ( this  != &rhs )
     {
         makeEmpty();
         root = clone(rhs.root);
     }
     return  * this ;
}
 
 
template<typename T>
int  BinarySearchTree<T>::countNodes() const
{
     return  countNodes(root);
}
 
template<typename T>
int  BinarySearchTree<T>::countLeaves() const
{
     return  countLeaves(root);
}
 
template<typename T>
int  BinarySearchTree<T>::countFull() const
{
     return  countFull(root);
}
 
template<typename T>
bool  BinarySearchTree<T>::check() const
{
     return  check(root);
}
 
template<typename T>
void  BinarySearchTree<T>::printRange(T & lower,T & upper,BinaryNode<T>* &root)
{
     if (root != NULL)
     {
         if (lower <= t->element)
             printRange(lower,upper,root->left);
         if (lower <= t->element && t->element >= upper)
             cout << t->element << endl;
         if (t->element <= upper)
             printRange(lower,upper,root->right);
     }
}

 

IT熱血青年
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++二叉查找树实现过程详解
12-22
什么是二叉查找树 　在数据结构中，有一个奇葩的东西，说它奇葩，那是因为它重要... 　以下是对于二叉查找树的基本操作定义类，然后慢慢分析是如何实现它们的。 　template 　class BinarySearchTree 　{ 　public
C语言实现二叉查找树（BST）的基本操作
12-22
我们在上一篇博客中讲解了二叉树，这一次我们来实现二叉树的进阶——二叉查找树（Binary Search Tree），又称二插排序树(Binary Sort Tree)。所以简称为BST。二插查找树的定义如下： 　1.若左子树不为空，则左子树...
BinarySearchTree二叉搜索树的实现
dichuangheng8094的博客
11-06 98
BinarySearchTree二叉搜索树的实现 /* 二叉搜索树(Binary Search Tree)，(又:二叉查找树，二叉排序树)它或者是一棵空树，或者是具有下列性质的二叉树: 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值; 若它的右子...
Go语言数据结构和算法-BinarySearchTree(二叉搜索树)
weixin_34221332的博客
09-12 123
Go语言数据结构和算法-BinarySearchTree(二叉搜索树) Insert(val) // 在二叉搜索树中插入一个元素 Search(val) // 在二叉搜索树中搜索一个元素 Parent(val) // 返回当前节点的父节点 Contains(val) // 在二叉搜索中是否包含这个元素 Min() ...
二叉查找树 BinarySearchTree 的实现
11-06 875
<br />header.h<br />template<class type> class BinarySearchTree { private: struct node { type data; node *left; node *right; node(type a,node*lt=NULL,node *rt=NULL){data=a;left=lt;right=rt;} }; node *root; bool find(type x,node *t)
编程练习——二叉查找树（BinarySearchTree）
帐前卒 专栏
08-19 1069
 BinarySearchTree和BinaryTree其实可以使用相同的构造和析构函数，所以继承吧。懒得再写一遍templateclass BinarySearchTree:public BinaryTree{public: BinarySearchTree(T& data):BinaryTree(data) {   } ~BinarySearchTree() {   } void in
决策树算法及实现
02-25
在计算机科学中，树是一种很重要的数据结构，比如我们最为熟悉的二叉查找树（BinarySearchTree），红黑树（Red-BlackTree）等，通过引入树这种数据结构，我们可以很快地缩小问题规模，实现高效的查找。在监督学习中...
BinarySearchTree.h
08-15
实现了二叉查找树的一些基础的功能：查找、删除、添加等。
BinaryTree_BinarySearchTree_AVLTree
03-21
该代码包括了二叉树、二叉查找树、平衡树的Java实现代码
java数据结构——BinarySearchTree（二叉查找树）
不爱学习
03-30 1623
二叉排序树（Binary Sort Tree）又称二叉查找树（Binary Search Tree），亦称二叉搜索树。
剑指offer——二叉搜索树的第k个节点
一个程序媛的成长记录❤
03-09 267
题目描述 给定一棵二叉搜索树，请找出其中的第k小的TreeNode结点。 关于二叉搜索树： 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文
binary_search_tree
瑶子的博客
09-27 281
reference:https://github.com/EchoLLLiu/DataStructure/blob/master/ch04tree/BinarySearchTree.py #-*- coding:utf-8 -*- # @Author:zhangy # @Time:2019-09-27 16:16 #reference:https://github.com/EchoLLLiu/Da...
二叉查找树(binary search tree)
weixin_30933531的博客
07-11 73
二叉查找树的性质：对于树中的每个节点x，它的左子树中所有项的值不大于x的值，它的右子树中所有项的值不小于x的值。 二叉查找树应具有以下操作 　　① 寻找最小项 FIND_MIN 　　② 寻找最大项 FIND_MAX 　　③ 是否包含 CONTAINS 　　④ 树是否为空 IS_EMPTY 　　⑤ 清空树 MAKE_EMPTY 　　⑥ 插入节点 INSERT 　　⑦ 移除节点 RE...
BinarySearchTree
复杂的程序员
04-11 388
#pragma once #include&lt;algorithm&gt; using namespace std; //BinarySearchTree class //construction: zero parameter // /* void insert(x) --&gt;Insert x void remove(x) --&gt;Remove x bool contains(x...
二叉查找树--BinarySearchTree
请你吃王中王博客
03-25 275
一、定义Tree接口public interface Tree&lt;E&gt; extends Iterable&lt;E&gt; { boolean search(E e); boolean insert(E e); boolean delete(E e); void inorder(); //中序遍历 void preorder();//前序遍历 ...
数据结构 - 二叉查找树 Binary Search Tree
爱吃柚子的好奶罐
02-22 569
目录： 一、性质 二、结点定义 三、部分操作 插入:唯一键值和重复键值 删除：普通删除和懒惰删除 四种遍历：先、中、后序、层级 四、进一步思考 一、二叉查找树性质 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 任意节点的左、右子树也分别为二叉查找树； 树中没有键值相等的节点。 二、结点...
二叉树
adityasaber的博客
10-23 3225
暂时先写了这八个方法 二叉树增加成员方法 BinaryTree二叉树类增加以下成员方法，public权限。 （1）成员方法，递归算法 6-1 BinaryTree(T prelist[], T inlist[]) //以先根和中根序列构造二叉树 6-2 BinaryTree create(T inlist[], T postlist[]) ...
二叉查找树java实现
最新发布
06-02
好的，下面是一份基本的二叉查找树的 Java 实现代码： ``` public class BinarySearchTree { private Node root; private class Node { private int key; private Node left; private Node right; public Node(int key) { this.key = key; this.left = null; this.right = null; } } public BinarySearchTree() { root = null; } public void insert(int key) { root = insert(root, key); } private Node insert(Node node, int key) { if (node == null) { node = new Node(key); return node; } if (key < node.key) { node.left = insert(node.left, key); } else if (key > node.key) { node.right = insert(node.right, key); } return node; } public void delete(int key) { root = delete(root, key); } private Node delete(Node node, int key) { if (node == null) { return null; } if (key < node.key) { node.left = delete(node.left, key); } else if (key > node.key) { node.right = delete(node.right, key); } else { if (node.left == null) { return node.right; } else if (node.right == null) { return node.left; } node.key = findMin(node.right).key; node.right = delete(node.right, node.key); } return node; } private Node findMin(Node node) { while (node.left != null) { node = node.left; } return node; } public boolean search(int key) { return search(root, key); } private boolean search(Node node, int key) { if (node == null) { return false; } if (key == node.key) { return true; } else if (key < node.key) { return search(node.left, key); } else { return search(node.right, key); } } public void inorderTraversal() { inorderTraversal(root); } private void inorderTraversal(Node node) { if (node != null) { inorderTraversal(node.left); System.out.print(node.key + " "); inorderTraversal(node.right); } } } ``` 这份代码实现了二叉查找树的基本操作，包括插入、删除、搜索和中序遍历。你可以根据自己的需求进行修改和拓展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值