C++算法（一）之二叉查找树
【理论支持】
算法导论第十二章，二叉查找树
【应用】
二叉查找树是一种很常用的数据结构，太经典，必掌握！它支持很多种动态集合操作.
可用作字典，用作优先队列.
基本操作的时间和树高度成正比，时间复杂度为Θ(lgn)
【我们要实现的操作】
search 查找
minMum 返回最小值
maxMum 返回最大值
predecessor 返回结点x的前驱
successor 返回结点x的后继
insert 插入结点x
delete 删除结点x
【学到的C++基础知识点】
（一）const T& data() const; 定义模版时写的，前后两个const有什么区别，各有什么作用？
（1）前面的const修饰T&
修饰的目的是，虽然返回的是T的引用，但是返回值不能作为<左值>，也就是对于返回值只能读，不能写
（2）后面那个const说明在data()函数内部，不能以任何方式直接或间接的修改成员变量
就是说只能读成员变量而不能写...（get from baidu zhidao）
（二）泛型怎么用？
例如：
template <class T>
struct BinaryNode
{
T element;
BinaryNode *left;
BinaryNode *right;
BinaryNode *parent;
BinaryNode(const T& _element,
BinaryNode *_left,
BinaryNode *_right,
BinaryNode *_parent):
element(_element),
left(_left),
right(_right),
parent(_parent)
{
}
};然后这么使用：BinaryNode<int>* node;
在定义函数的时候，这么使用：
template class<T>
const T& CBinarySearchTree<T>::findMinNum() const
{
BinaryNode<T>* res = findMinNum(m_Root);
return res == NULL?NULL:res->element;
}（三）内存怎么管理
因为不断往树中插入结点，需要insert，自然而然就需要申请内存，怎么申请呢？申请的内存如何释放呢？
（1）申请内存
我们用（二）中的struct BinaryNode来举例，要申请一个BinaryNode的内存空间：用到了构造函数（struct和class都有构造函数）
template class<T>
void CBinarySearchTree<T>::insert(const T& z)
{
//初始化新结点，内存处理...
BinaryNode<T>* newNode = new BinaryNode<T>(z,NULL,NULL,NULL);
//.....
}
（2）释放内存
在CBinarySearchTree类的析构函数中，增加一个public: makeEmpty()和private:makeEmpty(BinaryNode<T>* &m_Root)的函数...
为什么是两个呢，我们设置m_Root是private的，那么在public:makeEmpty()就无法使用m_Root这个变量，只能在private函数中，
增加一个重载的makeEmpty(BinaryNode<T>* &m_Root)，然后在makeEmpty()中调用makeEmpty(BinaryNode<T>* &m_Root)...
这机制有点意思：保护了数据~
public:
virtual ~CBinarySearchTree()
{
//内存怎么处理呢？？
makeEmpty();
}
void makeEmpty()
{
makeEmpty(m_Root);
}
private:
void makeEmpty(BinaryNode<T>* &m_Root)
{
if (m_Root)
{
makeEmpty(m_Root->left);
makeEmpty(m_Root->right);
delete t;
}
m_Root = NULL;
}
【C++ 代码】
#ifndef CBINARYSEARCHTREE_H
#define CBINARYSEARCHTREE_H
#include <iostream>
#define ORDER_MODE_PREV 0
#define ORDER_MODE_MID 1
#define ORDER_MODE_POST 2
//结点node
template <class T>
struct BinaryNode
{
T element;
BinaryNode *left;
BinaryNode *right;
BinaryNode *parent;
BinaryNode(const T& _element,
BinaryNode *_left,
BinaryNode *_right,
BinaryNode *_parent):
element(_element),
left(_left),
right(_right),
parent(_parent)
{
}
};
template <class T>
class CBinarySearchTree
{
public:
CBinarySearchTree()
{
m_Root = NULL;
}
virtual ~CBinarySearchTree()
{
//内存怎么处理呢？？
makeEmpty();
}
void makeEmpty()
{
makeEmpty(m_Root);
}
void insert(const T& z)
{
//初始化新结点，内存处理...
BinaryNode<T>* newNode = new BinaryNode<T>(z,NULL,NULL,NULL);
//x指向准备插入结点，y指向插入结点的父亲
BinaryNode<T>* y = NULL;
BinaryNode<T>* x = m_Root;
while(x != NULL)
{
y = x;
if(z < x->element)
x = x->left;
else
x = x->right;
}
newNode->parent = y;
//边界条件：树为空
if(y != NULL)
{
if(z < y->element)
y->left = newNode;
else
y->right = newNode;
}
else
m_Root = newNode;
}
void remove(const T& z)
{
remove(z, m_Root);
}
//if return NULL ：returning reference to temporary...
//how to do it?
const T& findMinNum() const
{
BinaryNode<T>* res = findMinNum(m_Root);
return res == NULL?NULL:res->element;
}
const T& findMaxNum() const
{
BinaryNode<T>* res = findMaxNum(m_Root);
return res == NULL?NULL:res->element;
}
const T& successor(T &x) const
{
BinaryNode<T>* res = successor(x,m_Root);
return res == NULL?NULL:res->element;
}
const T& predecessor(T &x) const
{
BinaryNode<T>* res = predecessor(x,m_Root);
return res == NULL?NULL:res->element;
}
//选择输出顺序，这个真心强大，学习了！
void printTree(int eOrderMode = ORDER_MODE_MID)
{
if (ORDER_MODE_PREV == eOrderMode)
printTreeInPrev(m_Root);
else if (ORDER_MODE_MID == eOrderMode)
printTreeInMid(m_Root);
else if (ORDER_MODE_POST == eOrderMode)
printTreeInPost(m_Root);
else
;
}
const T& search(T &x) const
{
const BinaryNode<T>* res = search(x,m_Root);
return res == NULL?NULL:res->element;
}
private:
void makeEmpty(BinaryNode<T>* &t)
{
if (t)
{
makeEmpty(t->left);
makeEmpty(t->right);
delete t;
}
t = NULL;
}
const BinaryNode<T>* search(const T value,const BinaryNode<T>* x) const
{
if(x == NULL || value == x->element)
return x;
if(value < x->element )
return search(value,x->left);
else
return search(value,x->right);
}
void printTreeInPrev(BinaryNode<T>* x) const
{
if(x == NULL)
return;
std::cout<<x->element<<" ";
printTreeInPrev(x->left);
printTreeInPrev(x->right);
}
void printTreeInMid(BinaryNode<T>* x) const
{
if(x == NULL)
return;
printTreeInMid(x->left);
std::cout<<x->element<<" ";
printTreeInMid(x->right);
}
void printTreeInPost(BinaryNode<T>* x) const
{
if(x == NULL)
return;
printTreeInPost(x->left);
printTreeInPost(x->right);
std::cout<<x->element<<" ";
}
void remove(const T& value, BinaryNode<T>* z)
{
if(z == NULL)
return;
if(value < z->element)
remove(value,z->left);
else if(value > z->element)
remove(value,z->right);
else if(value == z->element)
{
//根据z的孩子数目，我们要删除的结点y，不一样
//当没孩子或者只有一个孩子，y就是z本身
//两个孩子，y就是z的后继
BinaryNode<T>* y = NULL;
if(z->left != NULL && z->right != NULL)
y = successor(z->element,z);
else
y = z;
//x为孩子结点，从左孩子起，没有就为右孩子，再没有就NULL
BinaryNode<T>* x = NULL;
if(y->left != NULL)
x = y->left;
else
x = y->right;
//删除y结点就是把y孩子（x结点）接到y->parent上
if(x != NULL)
x->parent = y->parent;
//边界条件：y为root结点，那么y->parent就是NULL啦。
if(y->parent != NULL)
{
if(y == y->parent->left)
{
y->parent->left = x;
}
else if(y == y->parent->right)
{
y->parent->right = x;
}
}
else
{
m_Root = x;
}
if(y != z)
{
z->element = y->element;
}
//算法导论就没内存概念吗？
delete y;
}
else
;
}
BinaryNode<T>* findMinNum( BinaryNode<T>* x) const
{
while(x->left != NULL)
x = x->left;
return x;
}
BinaryNode<T>* findMaxNum( BinaryNode<T>* x) const
{
while(x->right != NULL)
x = x->right;
return x;
}
BinaryNode<T>* successor(const T value,const BinaryNode<T>* x) const
{
if(x == NULL)
return NULL;
if(value < x->element)
successor(value,x->left);
else if(value > x->element)
successor(value,x->right);
else
{
//如果有右孩子，直接返回大于自己的最小的元素
if(x->right != NULL)
return findMinNum(x->right);
//找到"父结点为祖父结点的左孩子"的那个祖父结点
BinaryNode<T>* y = NULL;
y = x->parent;
while(y != NULL && x == y->right)//找到x为y左孩子为止
{
x = y;
y = y->parent;
}
return y;
}
return NULL;
}
BinaryNode<T>* predecessor(const T value, const BinaryNode<T>* x)const
{
if(x == NULL)
return NULL;
if(value < x->element)
predecessor(value,x->left);
else if(value > x->element)
predecessor(value,x->right);
else
{
//如果有左孩子，直接返回小于自己的最大的元素
if(x->left != NULL)
return findMaxNum(x->left);
//找到"父结点为祖父结点的右孩子"的那个祖父结点
BinaryNode<T>* y = NULL;
y = x->parent;
while(y != NULL && x == y->left)//找到x为y左孩子为止
{
x = y;
y = y->parent;
}
return y;
}
return NULL;
}
protected:
private:
BinaryNode<T>* m_Root;
};
#endif // CBINARYSEARCHTREE_H
【C++测试代码】
#include <iostream>
#include "CBinarySearchTree.h"
#include "stdlib.h"
using namespace std;
int main()
{
CBinarySearchTree<int> bst;
//test for insert
bst.insert(1);
bst.insert(2);
bst.insert(3);
bst.insert(4);
bst.insert(5);
//test for printTree 有三种模式，分别为0,1,2
cout<<"prev order: ";
bst.printTree(ORDER_MODE_PREV);
cout<<endl;
cout<<"min order: ";
bst.printTree(ORDER_MODE_MID);
cout<<endl;
cout<<"post order: ";
bst.printTree(ORDER_MODE_POST);
cout<<endl;
//test for findMaxNum()
cout<<"Max number: "<<bst.findMaxNum()<<endl;
//test for findMinNum()
cout<<"Min number: "<<bst.findMinNum()<<endl;
//teft for successor()
for(int i = 1 ; i <= 5 ;i++)
cout<<"node "<<i<<" successor: "<<bst.successor(i)<<endl;
//test for predecessor()
for(int i = 1 ; i <= 5 ;i++)
cout<<"node "<<i<<" predecessor: "<<bst.predecessor(i)<<endl;
//test for search()
for(int i = 1 ; i <= 5 ;i++)
cout<<"node "<<i<<" search: "<<bst.search(i)<<endl;
//test for remove()
for(int i = 0 ; i < 5 ;i++)
{
bst.remove(i+1);
cout<<"after delete "<<i+1<<": ";
bst.printTree(ORDER_MODE_MID);
cout<<endl;
}
return 0;
}
【C++ 测试结果】
prev order: 1 2 3 4 5 min order: 1 2 3 4 5 post order: 5 4 3 2 1 Max number: 5 Min number: 1 node 1 successor: 2 node 2 successor: 0 node 3 successor: 0 node 4 successor: 0 node 5 successor: 0 node 1 predecessor: 0 node 2 predecessor: 0 node 3 predecessor: 0 node 4 predecessor: 0 node 5 predecessor: 0 node 1 search: 1 node 2 search: 2 node 3 search: 3 node 4 search: 4 node 5 search: 5 after delete 1: 2 3 4 5 after delete 2: 3 4 5 after delete 3: 4 5 after delete 4: 5 after delete 5: Process returned 0 (0x0) execution time : 0.546 s Press any key to continue.