二叉查找树的基本操作

#include <iostream>
using namespace std;

#define MAXSIZE 8


class Node {
public:
	Node(int key) {
		m_key = key;
		init();
	}

	void init()
	{
		m_left = NULL;
		m_right = NULL;
		m_p = NULL;
	}

	~Node() {}

public:
	int m_key;
	Node* m_left;
	Node* m_right;
	Node* m_p;
};


void InsertNode(Node** T, int k)
{
//	t -> point of currenty node; y ->point of parent of t
	Node** t = T;
	Node* y = NULL;
	while (*t) {
		if ((*t)->m_key >= k) {
			y = *t;
			t = &((*t)->m_left);
		}
		else if ((*t)->m_key < k) {
			y = *t;
			t = &((*t)->m_right);
		}
	}
	*t = new Node(k);
	(*t)->m_p = y;
}

void DestoryTree(Node** T)
{
	if (*T) {
		DestoryTree(&(*T)->m_left);
		DestoryTree(&(*T)->m_right);
		delete *T;
		*T = NULL;
	}
}

Node* BuildTree(int* A, int size)
{
	if (size <= 0) return NULL;
	Node* root = NULL;
	for (int i = 0; i < size; ++i)
	{
		InsertNode(&root, A[i]);
	}
	return root;
}

void InorderTreeWalk(Node* T)
{
	if (T) {
		InorderTreeWalk(T->m_left);
		cout << T->m_key << " ";
		InorderTreeWalk(T->m_right);
	}
}

void PostorderTreeWalk(Node* T)
{
	if (T) {
		InorderTreeWalk(T->m_right);
		InorderTreeWalk(T->m_left);
		cout << T->m_key << " ";
	}
}

Node* TreeSearch(Node* T, int k)
{
	if (!T || k == T->m_key) 
		return T;
	else if (k < T->m_key) 
		return TreeSearch(T->m_left, k);
	else 
		return TreeSearch(T->m_right, k);
}

Node* InteractiveTreeSearch(Node* T, int k)
{
	while (T && k != T->m_key) {
		if (k < T->m_key)
			T = T->m_left;
		else
			T = T->m_right;
	}
	return T;
}

Node* Maximum(Node* T)
{
	if (!T) return NULL;
	while (T->m_right) {
		T = T->m_right;
	}
	return T;
}

Node* Minimum(Node* T)
{
	if (!T) return NULL;
	while (T->m_left) {
		T = T->m_left;
	}
	return T;
}

Node* TreeSuccessor(Node* T)
{
	if (!T) return NULL;
	if(T->m_right) {
		return Minimum(T->m_right);
	}
	Node* x = T;
	Node* y = T->m_p;
	if (y && x == y->m_right) {
		x = y;
		y = y->m_p;
	}
	return y;
}

Node* TreePresuccessor(Node* T)
{
	if (!T) return NULL;
	if (T->m_left) {
		return Maximum(T->m_left);
	}
	Node* x = T;
	Node* y = T->m_p;
	if (y && x == y->m_left) {
		x = y;
		y = y->m_p;
	}
	return y;
}

Node* TreeInsert(Node* root, Node* z)
{
	Node* x = root;
	Node* y = NULL;
	while (x) {
		y = x;
		if (z->m_key > x->m_key) {
			x = x->m_right;
		}
		else
			x = x->m_left;
	}
	z->m_p = y;
	if (y == NULL) {
		// empty tree
		root = z;
	}
	else {
		if (z->m_key < y->m_key) {
			y->m_left = z;
		}
		else
			y->m_right = z;
	}
	return root;
}

Node* TreeDelete(Node* T, Node* z)
{
	Node* y;
	Node* x;
	if (!z->m_left || !z->m_right) {
		y = z;
	}
	else
		y = TreeSuccessor(z);

	if (y->m_left)
		x = y->m_left;
	else
		x = y->m_right;

	if (x)
		x->m_p = y->m_p;

	if (!y->m_p) {
		if (x) x->m_p = NULL;
		return x;
	}
	else {
		if (y == y->m_p->m_left) {
			y->m_p->m_left = x;
		}
		else
			y->m_p->m_right = x;
	}
	if (y != z) {
		z->m_key = y->m_key;
	}
	return T;
}

int main()
{
	Node* root = NULL;
	int a[MAXSIZE] = { 12,5,18,2,9,15,19,17};
	root = BuildTree(a, MAXSIZE);
	InorderTreeWalk(root);
	cout << endl;

	Node* max = Maximum(root);
	if (max)
		cout << "Max:"<< max->m_key << endl;

	Node* min = Minimum(root);
	if (min)
		cout << "Min:"<< min->m_key << endl;

	Node* succ = TreeSuccessor(root->m_left->m_right->m_right);
	if (succ) cout << succ->m_key << endl;
	Node* presucc = TreePresuccessor(root->m_left->m_right->m_right);
	if (presucc) cout << presucc->m_key << endl;

	Node* z = new Node(7);
	root = TreeInsert(root, z);
	InorderTreeWalk(root);
	cout << endl;

	Node* zz = root->m_right->m_left;
	root = TreeDelete(root, zz);
	InorderTreeWalk(root);
	cout << endl;
	DestoryTree(&root);
	return 0;
}