二叉查找树-优化版,使用了指针引用



  1 //与上一次实现不同,这里使用了大量的指针引用,
  2 //因此节省了一个指向父节点的指针
  3 #include<iostream>
  4 #include<vector>
  5 #include<ctime>
  6 #include<cstdlib>
  7
  8 using namespace std;
  9
 10 template<class T>
 11 class BinarySearchTree
 12 {
 13     private:
 14         struct Node
 15         {
 16             T data;
 17             Node *left;
 18             Node *right;
 19             Node(T val)
 20             {
 21                 data = val;
 22                 left = NULL;
 23                 right = NULL;
 24             }
 25
 26             private:
 27             Node()
 28             {
 29             }
 30         };
 31         Node *root;
 32         int size;
 33
 34     public:
 35         BinarySearchTree()
 36         {
 37             root = NULL;
 38             size = 0;
 39         }
 40         ~BinarySearchTree()
 41         {
 42             clear(root);
 43             root = NULL;
 44             size = 0;
 45         }
 46         Node*& findMin(Node *&node) const
 47         {
 48             if(node->left == NULL)
 49                 return node;
 50             else
 51                 return findMin(node->left);
 52         }
 53         T max(Node *node) const
 54         {
 55             if(node->right == NULL)
 56                 return node->data;
 57             else
 58                 return max(node->right);
 59         }
 60
 61         Node *& insert(Node *& node,T val)
 62         {
 63             if(node == NULL)
 64             {
 65                 node = new Node(val);
 66                 size++;
 67                 return node;
 68             }
 69             if(val > node->data)
 70                 return insert(node->right,val);
 71             else if(val < node->data)
 72                 return insert(node->left,val);
 73             else
 74                 return node;
 75         }
 76
 77         bool contain(Node *& node,T val) const
 78         {
 79             if(node == NULL)
 80                 return false;
 81
 82             if(val > node->data)
 83                 return contain(node->right,val);
 84             else if(val < node->data)
 85                 return contain(node->left,val);
 86             else
 87                 return true;
 88         }
 89
 90         void remove(Node* &node,T val)
 91         {
 92             if(node == NULL)
 93             {
 94                 cout<<"remove() error!\n";
 95                 return;
 96             }
 97             if(val > node->data)
 98                 remove(node->right,val);
 99             else if(val < node->data)
100                 remove(node->left,val);
101             else if(val == node->data)
102             {
103                 if(node->left == NULL && node->right == NULL)
104                 {
105                     delete node;
106                     node = NULL;
107                 }
108                 else if(node->left == NULL && node->right != NULL)
109                 {
110                     Node *p = node;
111                     node = node->right;
112                     delete p;
113                     size--;
114                 }
115                 else if(node->left != NULL && node->right == NULL)
116                 {
117                     Node *p = node;
118                     node = node->left;
119                     delete p;
120                     size--;
121                 }
122                 else if(node->left != NULL && node->right != NULL)
123                 {
124                     Node* &p = findMin(node->right);
125                        node->data = p->data;
126                     p = p->right;
127                     delete p;
128                     size--;
129                 }
130             }
131         }
132         void clear(Node* &node)
133         {
134             if(node->left != NULL)
135                 clear(node->left);
136             if(node->right != NULL)
137                 clear(node->right);
138
139             delete node;
140             node = NULL;
141         }
142         void print(Node *node)
143         {
144             if(node == NULL)
145                 return;
146             cout<<node->data<< " ";
147             if(node->left != NULL)
148                 print(node->left);
149             if(node->right != NULL)
150                 print(node->right);
151         }
152         void insert(T val)
153         {
154             insert(root,val);
155         }
156         void remove(T val)
157         {
158             remove(root,val);
159         }
160         void print()
161         {
162             print(root);
163             cout<<"\n";
164         }
165 };
166
167 int main()
168 {
169     BinarySearchTree<int> tree;
170     tree.insert(10);
171     tree.insert(1);
172     tree.insert(11);
173     tree.insert(9);
174     tree.insert(8);
175     tree.print();
176     cout<<"\n\n";
177     tree.remove(9);
178     tree.print();
179
180     return 0;
181 }

				
时间: 2024-08-24 04:21:30

二叉查找树-优化版,使用了指针引用的相关文章

C#注册表操作类--完整优化版

using System; using System.Collections.Generic; using System.Text; using Microsoft.Win32; namespace Register { public class RegisterHelper { /// <summary> /// 注册表基项静态域 /// /// 主要包括: ///1.Registry.ClassesRoot 对应于 HKEY_CLASSES_ROOT 主键 ///2.Registry.Cu

排序-计数-优化版

计数排序优化版:引用:https://www.cnblogs.com/xiaochuan94/p/11198610.html基础版能够解决一般的情况,但是它有一个缺陷,那就是存在空间浪费的问题.比如一组数据{101,109,108,102,110,107,103},其中最大值为110,按照基础版的思路,我们需要创建一个长度为111的计数数组,但是我们可以发现,它前面的[0,100]的空间完全浪费了,那怎样优化呢?将数组长度定为max-min+1,即不仅要找出最大值,还要找出最小值,根据两者的差来

JSON的put方法是一个指针引用

JSON的put方法是一个指针引用; import org.json.simple.JSONObject; JSONObject a=new JSONObject(); a.put("date","2015-11-08");a.put("time","15:48:28"); a.toJSONString() --> {"date":"2015-11-08","time&q

POJ-2533最长上升子序列(DP+二分)(优化版)

Longest Ordered Subsequence Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 41944   Accepted: 18453 Description A numeric sequence of ai is ordered if a1 < a2 < ... < aN. Let the subsequence of the given numeric sequence (a1, a2, ...

等式转换(熟悉一下链表,指针引用)

1 /***************************************************************************** 2 *输入一个正整数X,在下面的等式左边的数字之间添加 + 号或者 - 号,使得等式成立. 3 *1 2 3 4 5 6 7 8 9 = X 4 *比如: 5 *12 - 34 + 5 - 67 + 89 = 5 6 *1 + 23 + 4 - 5 + 6 - 7 - 8 - 9 = 5 7 *请编写程序,统计满足输入整数的所有整数个数

flask 大型教程项目优化版(1):Hello World

Hello World 作者背景 作者是一个使用多种语言开发复杂程序并且拥有十多年经验的软件工程师.作者第一次学习 Python 是在为一个 C++ 库创建绑定的时候. 除了 Python,作者曾经用 PHP, Ruby, Smalltalk 甚至 C++ 写过 web 应用.在所有这些中,Python/Flask 组合是作者认为最为自由的一种. 应用程序简介 作为本教程的一部分–我要开发的应用程序是一个极具特色的微博服务器,我称之为 microblog . 我会随着应用程序的不断地进展将涉及到

编程题:字符串的指针引用。用指针法实现。功能:将字符串str2复制连接到str1

#include<stdio.h> void main() { char *s1,*s2, str1[30]="beijing",str2[10]="China"; for(s1=str1;*s1!='\0';s1++); for(s2=str2;*s2!='\0';) *s1++=*s2++; *s1='\0'; printf("%s\n",str1); } 编程题:字符串的指针引用.用指针法实现.功能:将字符串str2复制连接到s

优化版的冒泡排序

;优化版的冒泡排序,最好的情况为线性阶 ,最坏的情况为平方阶 ;算法的最好情况,如一个拍好序列的数组那么做排序,那么就会有几行代码不会产生交换的情况 最坏的情况是全部都交换 ;code /* 此冒泡最好情况被优化为线性阶 最坏就是平方阶 */ void bubble(int arr[3],int n) { int bChange=1,i=0,j=0; for(i=0;i<n&&bChange==1;++i)//n次 { bChange=0; for(j=0;j<n;++j)//

浅谈运用指针引用字符串

一.字符串的引用方式 1.如果字符串存放在字符数组中可以用数组名和下标引用 char string[10] = "Hello word"; printf("%s",string); 2.用字符指针变量指向字符串常量,用字符指针引用字符串 char *strp = "Hello word"; printf("%s",strp); //系统将字符串常量以字符数组形式保存在内存中,字符串末尾系统自动加了一个'\0'.再将字符数组的首