二叉查找树的各种操作源码

/**
 * @brief Binary Search Tree 
 * @author An
 * @data  2013.6.1                                                                  
**/
#include <iostream>
#include <stack>
// start from 0
// #define Left( x )  ( 2 * x + 1 )
// #define Right( x )  ( 2 * x + 2 )
// #define Parent( x )  ( ( x - 1 ) / 2 )
using namespace std;

typedef struct Node
{
	int data;
	Node *lchild;
	Node *rchild;
	Node *parent;
}*BiTree;

void CreateBiTree( BiTree &T, int *array )
{
	static int i = -1;
	++i;
	if ( array[ i ] == 0 )
	{
		T = NULL;
	}
	else
	{
		T->data = array[ i ];
		T->lchild = new Node;
		T->rchild = new Node;
		T->lchild->parent = T;
		T->rchild->parent = T;
		CreateBiTree( T->lchild, array );
		CreateBiTree( T->rchild, array );
	}
}

// recursive in order traverse
void InOrderTraverse( BiTree T )
{
	if ( T != NULL )
	{
		InOrderTraverse( T->lchild );
		cout << T->data << " ";
		InOrderTraverse( T->rchild );
	}
}

// non-recursive in order traverse
void InOrderTraverse_( BiTree T )
{
	stack<Node*> stk;
	Node *p = T;
	while ( p != NULL || !stk.empty() )
	{
		while ( p != NULL )
		{
			stk.push( p );
			p = p->lchild;
		}
		if ( !stk.empty() )
		{
			p = stk.top();
			stk.pop();
			cout << p->data << " ";
			p = p->rchild;
		}
	}
}

// recursive search a key
Node* TreeSearch( BiTree T, int k )
{
	if ( T == NULL || T->data == k )
		return T;
	if ( T->data < k )
		return TreeSearch( T->rchild, k );
	else
		return TreeSearch( T->lchild, k );
}

// iterative search a key
Node* TreeSearchIterative( BiTree T, int k )
{
	Node *p = T;
	while ( p != NULL && k != p->data )
	{
		if ( p->data < k )
			p = p->rchild;
		else
			p = p->lchild;
	}
	return p;
}

// minimum element
Node* TreeMinimum( BiTree T )
{
	Node *p = T;
	while ( p->lchild != NULL )
	{
		p = p->lchild;
	}
	return p;
}

// Maximum element
Node* TreeMaximum( BiTree T )
{
	Node *p = T;
	while ( p->rchild != NULL )
		p = p->rchild;
	return p;
}

// successor
Node* TreeSuccessor( Node *x )
{
	if ( x->rchild != NULL )
		return TreeMinimum( x->rchild );
	while ( x != x->parent->lchild )
	{
		x = x->parent;
	}
	return x->parent;
}

// predecessor
Node* TreePredecessor( Node *x )
{
	if ( x->lchild != NULL )
		return TreeMaximum( x->lchild );
	while ( x != x->parent->rchild )
		x = x->parent;
	return x->parent;
}

// Tree insert
void TreeInsert( BiTree &T, Node *x )
{
	Node *pre = NULL;
	Node *p = T;
	while ( p != NULL )
	{
		pre = p;
		if ( x->data < p->data )
			p = p->lchild;
		else
			p = p->rchild;
	}
	x->parent = pre;
	if ( pre == NULL )
		T = x;
	else if ( x->data < pre->data )
		pre->lchild = x;
	else
		pre->rchild = x;
}

// Tree insert recursive
void TreeInsert_( BiTree &T, Node *x )
{
	static Node *pre = NULL;
	if ( T == NULL )
	{
		T = x;
		x->parent = pre;
	}
	else if ( x->data < T->data )
	{
		pre = T;
		TreeInsert_( T->lchild, x );
	}
	else
	{
		pre = T;
		TreeInsert_( T->rchild, x );
	}
}

// Tree delete
void TreeDelete( BiTree &T, Node *x )
{
	// 若x最多只有一个子女，则x赋给tmp；否则，x的后继赋给tmp
	Node *tmp = NULL;
	if ( x->lchild == NULL || x->rchild == NULL )
		tmp = x;
	else
		tmp = TreeSuccessor( x );
	// tmpSucc为它的非空子女，若无子女则为空
	Node *tmpSucc = NULL;
	if ( tmp->lchild != NULL )
		tmpSucc = tmp->lchild;
	else
		tmpSucc = tmp->rchild;
	// 删除tmp, 修改父指针和子指针
	if ( tmpSucc != NULL )
		tmpSucc->parent = tmp->parent;
	if ( tmp->parent == NULL )
		T = tmpSucc;
	else if ( tmp == tmp->parent->lchild )
		tmp->parent->lchild = tmpSucc;
	else
		tmp->parent->rchild = tmpSucc;
	// 若删除的是x的后继，将x的后继替换x
	if ( tmp != x )
		x->data = tmp->data;
	delete tmp;
}

int main()
{
	// PreOrder create tree, 0 indicate NULL
	int array[] = { 10, 4, 1, 0, 0, 5, 0, 0, 17, 16, 0, 0, 21, 0, 0 };
	BiTree T = new Node;

	// Test create tree and in order traverse
	CreateBiTree( T, array );
	InOrderTraverse( T );
	cout << endl;

	// Test search a element
	Node *p1 = new Node;
	Node *p2 = new Node;
	p1 = TreeSearch( T, 5 );
	p2 = TreeSearchIterative( T, 5 );
	cout << p1->data << " " << p2->data << endl;

	// Test tree minimum and maximum
	p1 = TreeMinimum( T );
	p2 = TreeMaximum( T );
	cout << p1->data << " " << p2->data << endl;

	// Test successor and predecessor
	p1 = TreeSearch( T, 5 ); 
	p2 = TreeSearchIterative( T, 5 );
	p1 = TreeSuccessor( p1 );
	p2 = TreePredecessor( p1 );
	cout << p1->data << " " << p2->data << endl;

	// Test Insert
	Node *elem = new Node;
	elem->data = 6;
	elem->lchild = NULL;
	elem->rchild = NULL;
	TreeInsert_( T, elem );
	InOrderTraverse_( T );
	cout << endl;

	// Test Delete
	Node *p = TreeSearch( T, 17 );
	TreeDelete( T, p );
	InOrderTraverse_( T );
	cout << endl;


	return 0;
}