实现算法导论第三版中的二叉搜索树

使用C++实现。为了方便调试，加了一个输出函数。此函数，水平遍历树节点。

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <queue>
#include <iostream>

struct TNode
{
TNode * p; //parent node
TNode * left; //left child node
TNode * right; //right child node
int key; //node value
TNode(int k);
};

TNode::TNode(int k)
:p(0), left(0), right(0),
key(k)
{}

class BinaryTree
{
private:
TNode * root;
public:
BinaryTree();
void Insert(TNode * z);
void Print();
TNode * Search(int k);
TNode * Minimum(int k);
TNode * Successor(int k);
void InorderWalk();
bool Delete(TNode * z);
protected:
void LevelOrder();
TNode * Search(TNode * x, int k);
TNode * Minimum(TNode * x);
void InorderWalk(TNode * x);
void Transplant(TNode * u, TNode * v);
};

BinaryTree::BinaryTree()
:root(0)
{}

void BinaryTree::Insert(TNode * z)
{
assert(z);
TNode * y = 0;
TNode * x = root;

while(x != 0)
{
y = x;

if(z->key < x->key)
x = x->left;
else
x = x->right;
}

z->p = y;
if(0 == y)
root = z;
else if(z->key < y->key)
y->left = z;
else
y->right = z;
}

void BinaryTree::Print()
{
LevelOrder();
std::cout << std::endl;
}

TNode * BinaryTree::Search(int k)
{
return Search(root, k);
}

TNode * BinaryTree::Minimum(int k)
{
TNode * x = Search(k);

if(!x)
return 0;

return Minimum(x);
}

TNode * BinaryTree::Successor(int k)
{
TNode * x = Search(k);
if(!x)
return 0;

if(x->right != 0)
return Minimum(x->right);

TNode * y = x->p;

while(y != 0 && x == y->right)
{
x = y;
y = y->p;
}

return y;

}

void BinaryTree::InorderWalk()
{
InorderWalk(root);
}

bool BinaryTree::Delete(TNode * z)
{
if(!root)
return false;

if(!z)
return false;

if(0 == z->left)
Transplant(z, z->right);
else if(0 == z->right)
Transplant(z, z->left);
else
{
TNode * y = Minimum(z->right); //= successor(z->right)
assert(y);

if(y->p != z) //case d
{
std::cout << "case d" << std::endl;
Transplant(y, y->right);
y->right = z->right;
y->right->p = y;
}

std::cout << "case c" << std::endl;
//y->p == z
Transplant(z, y);
y->left = z->left;
y->left->p = y;
}

return true;
}
void BinaryTree::LevelOrder()
{
if(!root)
return ;

std::queue<TNode *> que;
TNode * t = 0;

que.push(root);

while(!que.empty())
{
t = que.front();
que.pop();

if(0 == t->p)
std::cout<<"R("<<t->key<<")";
else if(t == t->p->left)
std::cout<<"L("<<t->key<<")";
else
std::cout<<"R("<<t->key<<")";

if(t->left != 0)
que.push(t->left);

if(t->right != 0)
que.push(t->right);
}
}

TNode * BinaryTree::Search(TNode * x, int k)
{
while(x != 0 && k != x->key)
k < x->key?(x = x->left):(x = x->right);

return x;
}

TNode * BinaryTree::Minimum(TNode * x)
{
while(x->left != 0)
x = x->left;

return x;
}

void BinaryTree::InorderWalk(TNode * x)
{
if(x)
{
InorderWalk(x->left);
std::cout << x->key << "," << std::endl;
InorderWalk(x->right);
}
}

void BinaryTree::Transplant(TNode * u, TNode * v)
{
if(0 == u->p) //u is root
root = v;
else if(u == u->p->left) //u is left child, let left child of the parent is v
u->p->left = v;
else //u is right child
u->p->right = v;

if(v != 0)
v->p = u->p; //change child's parent
}

int main()
{
BinaryTree tree;

TNode t15(15);
TNode t5(5);
TNode t18(18);
TNode t3(3);
TNode t2(2);
TNode t4(4);
TNode t7(7);
TNode t13(13);
TNode t9(9);
TNode t17(17);
TNode t20(20);
TNode t6(6);

tree.Insert(&t15);
tree.Insert(&t5);
tree.Insert(&t18);
tree.Insert(&t3);
tree.Insert(&t2);
tree.Insert(&t4);
tree.Insert(&t7);
tree.Insert(&t6);
tree.Insert(&t13);
tree.Insert(&t9);
tree.Insert(&t17);
tree.Insert(&t20);

tree.Print();
std::cout << "----find----" << std::endl;

TNode * res = tree.Search(13);
if(!res)
std::cout << "cann't find 13 in the tree" << std::endl;
else
std::cout << "find 13.it's parent key = " << res->p->key << std::endl;

res = tree.Successor(13);
if(!res)
std::cout << "successor operator fail" << std::endl;
else
std::cout << "successor key = " << res->key << std::endl;

std::cout << "\n----inorder walk----" << std::endl;
tree.InorderWalk();

std::cout << "\n-----------delete------------\n";
//tree.Delete(&t7);
//tree.Print();
tree.Print();
tree.Delete(&t5);
tree.Print();

return 0;
}