Mark 一个类...一个很简单的二叉查找树...

#ifndef BINARYSEARCHTREE_H_INCLUDED
#define BINARYSEARCHTREE_H_INCLUDED

/**
* File BinarySearchTree.h
* the Header file of binary search tree
**/
#include <stack>
#include <utility>

using namespace std;

template <typename Entry>
class BinarySearchTree
{
public:
BinarySearchTree()
{
this->root = NULL;
this->size = 0;
}

BinarySearchTree(const BinarySearchTree& rhs)
{
this->root = NULL;
this->size = rhs.size;
root = clone(rhs.root);
}

~BinarySearchTree()
{
clear();
}

const BinarySearchTree& operator=(const BinarySearchTree& rhs)
{
if (this != &rhs)
{
clear();
root = clone(rhs.root);
this->size = rhs.size;
}
return *this;
}

/**
* return the size of the binary search tree
*/
int getSize()
{
return this->size;
}

/**
* if the tree is empty, return tree
**/
bool empty() const
{
return root == NULL;
}

/**
* insert x into the tree
* if x is alrealdy in the tree, then the method is undefined
**/
void insert(const Entry& x)
{
insert(root, x);
}

/**
* remove x from the tree
* if the x is not in the tree, then the method is undefined
**/
void remove(const Entry& x)
{
search_remove(root, x);
}

/**
* clear all nodes in the tree
**/
void clear()
{
clear(root);
}

/**
* search x in the tree
* if x is not in the tree, return -1, else return 1
**/
int search(Entry x)
{
BinaryNode* node = recursiveSearch(root, x);
if (node != NULL)
return 0;
else if (node == NULL)
{
return -1;
}
return 0;
}

/**
* preorder traversal
**/
void preorder(void(*visit)(Entry& ))
{
recursivePreorder(root, visit);
}

/**
* inorder traversal
**/
void inorder(void (*visit)(Entry& ))
{
recursiveInorder(root, visit);
}

/**
* inorder traversal
*/
void postorder(void (*visit)(Entry& ))
{
recursivePostorder(root, visit);
}

/**
* preorder not recursive
**/
void NRpreorder(void (*visit)(Entry& ))
{
NRpreorder(root, visit);
}

/**
* inorder not recursive
**/
void NRinorder(void (*visit)(Entry& ))
{
NRinorder(root, visit);
}

/**
* postorder not recursive
**/
void NRpostorder(void (*visit)(Entry& ))
{
NRpostorder(root, visit);
}

private:
struct BinaryNode
{
Entry data;
BinaryNode* left;
BinaryNode* right;

BinaryNode()
{
left = NULL;
right = NULL;
}

BinaryNode(const Entry& data, BinaryNode* left = NULL, BinaryNode* right = NULL)
{
this->data = data;
this->left = NULL;
this->right = NULL;
}
};

BinaryNode* root;
int size;

BinaryNode* recursiveSearch(BinaryNode* & subRoot, Entry& x)
{
if (subRoot == NULL || subRoot->data == x)
return subRoot;
if (x > subRoot->data)
return recursiveSearch(subRoot->right, x);
else if (x < subRoot->data)
return recursiveSearch(subRoot->left, x);
}

void insert(BinaryNode* & subRoot, const Entry& x)
{
if (subRoot == NULL)
{
subRoot = new BinaryNode(x);
size++;
}
else if (x > subRoot->data)
{
insert(subRoot->right, x);
}
else if (x < subRoot->data)
{
insert(subRoot->left, x);
}
else
{
; // do nothing, the entry is duplicate;
}
}

void search_remove(BinaryNode* & subRoot, const Entry& x)
{
if (subRoot == NULL)
return; // the remove value is not found
if (x > subRoot->data)
search_remove(subRoot->right, x);
else if (x < subRoot->data)
search_remove(subRoot->left, x);
else if (x == subRoot->data)
remove(subRoot, x);
}

void remove(BinaryNode* & subRoot, const Entry& x)
{
if (subRoot == NULL)
return; // the value x is not found

BinaryNode* toDelete = subRoot;

if (subRoot->right == NULL)
{
subRoot = subRoot->left;
}
else if (subRoot->left == NULL)
{
subRoot = subRoot->right;
}
else
{
toDelete = subRoot->left;
BinaryNode* parent = subRoot;
while (toDelete->right != NULL)
{
parent = toDelete;
toDelete = toDelete->right;
}

subRoot->data = toDelete->data;

if (parent == subRoot)
{
subRoot->left = toDelete->left;
}
else
{
parent->right = toDelete->left;
}
}
delete toDelete;
toDelete = NULL;
size--;
}

void clear(BinaryNode* & subRoot)
{

if (subRoot != NULL)
{
// 一直爬到树的底部进行删除
clear(subRoot->left);
clear(subRoot->right);
delete subRoot;
}
subRoot = NULL;
}

// copy the whole tree
BinaryNode* clone(BinaryNode* subRoot) const
{
if (subRoot == NULL)
return NULL;
else
{
return new BinaryNode(subRoot->data, clone(subRoot->left), clone(subRoot->right));
}
}

BinaryNode* findMin(BinaryNode* subRoot) const
{
if (subRoot == NULL)
return NULL;
else if (subRoot->left == NULL)
return subRoot;
else
return findMin(subRoot->left);
}

BinaryNode* findMax(BinaryNode* subRoot) const
{
if (subRoot != NULL)
{
while (subRoot->right != NULL)
subRoot = subRoot->right;
}
return subRoot;
}

void recursivePreorder(BinaryNode* subRoot, void (*visit)(Entry& ))
{
if (subRoot != NULL)
{
(*visit)(subRoot->data);
recursivePreorder(subRoot->left, visit);
recursivePreorder(subRoot->right, visit);
}
}

void recursiveInorder(BinaryNode* subRoot, void (*visit)(Entry& ))
{
if (subRoot != NULL)
{
recursiveInorder(subRoot->left, visit);
(*visit)(subRoot->data);
recursiveInorder(subRoot->right, visit);
}
}

void recursivePostorder(BinaryNode* subRoot, void (*visit)(Entry& ))
{
if (subRoot !=
4000
NULL)
{
recursivePostorder(subRoot->left, visit);
recursivePostorder(subRoot->right, visit);
(*visit)(subRoot->data);
}
}

void NRpreorder(BinaryNode* subRoot, void (*visit)(Entry& ))
{
stack<BinaryNode* > nodeStack;

while (subRoot != NULL || !nodeStack.empty())
{
if (subRoot != NULL)
{
(*visit)(subRoot->data);
nodeStack.push(subRoot);
subRoot = subRoot->next;
}
else
{
BinaryNode* topNode = nodeStack.top();
nodeStack.pop();
subRoot = topNode->right;
}
}
}

void NRinorder(BinaryNode* subRoot, void (*visit)(Entry& ))
{
stack<BinaryNode* > nodeStack;

while (subRoot != NULL || !nodeStack.empty())
{
if (subRoot != NULL)
{
nodeStack.push(subRoot);
subRoot = subRoot->left;
}
else
{
BinaryNode* topNode = nodeStack.top();
nodeStack.pop();
(*visit)(topNode);
subRoot = topNode->right;
}
}
}

void NRpostorder(BinaryNode* subRoot, void (*visit)(Entry& ))
{
stack<pair<BinaryNode*, bool> > nodeStack; // node pointer, flag

while (subRoot != NULL || !nodeStack.empty())
{
if (subRoot != NULL)
{
nodeStack.push(make_pair(subRoot, false));
subRoot = subRoot->left;
}
else
{
pair<BinaryNode*, bool> topPair = nodeStack.top();
BinaryNode* topNode = topPair.first;
nodeStack.pop();
if (topPair.second == true)
{
(*visit)(topNode->data);
//topPair.second = true;
//nodeStack.pop();
}
else
{
topPair.second = true;
nodeStack.push(topPair);
subRoot = topNode->right;
}
}
}
}

};

#endif // BINARYSEARCHTREE_H_INCLUDED