实现一个搜索二叉树

先来看代码：

BinaryTree.h

#ifndef _BINARY_TREE_
#define _BINARY_TREE_

class BinaryTree
{
private:
	class Node{
	public:
		Node(int);
		int data_;
		Node *left_;
		Node *right_;
	};
	Node *root_;
	int size_;
	void delete_func(Node*);
	void preOrder_func(Node*);
	void inOrder_func(Node*);
	void postOrder_func(Node*);
	Node* getSuccessor(Node *del);
public:
	BinaryTree();
	~BinaryTree();
	bool insert(int data);
	int size();
	Node* find(int data);
	bool deleteNode(int data);
	void preOrder();
	void inOrder();
	void postOrder();
	void displayTree();
};

#endif //_BINARY_TREE_

BinaryTree.cpp

#include <iostream>
#include <stack>
#include "BinaryTree.h"
//Node类的构造函数
BinaryTree::Node::Node(int data):data_(data),left_(0),right_(0){
}
//二叉树的构造函数
BinaryTree::BinaryTree():root_(0),size_(0){
}
//二叉树的析构函数
BinaryTree::~BinaryTree(){
	delete_func(root_);
}
//析构函数要调用的private函数
void BinaryTree::delete_func(Node* node){
	if(node == 0)
		return;
	else{
		delete_func(node->left_);
		delete_func(node->right_);
		delete node;
	}
}
//往二叉树添加元素
bool BinaryTree::insert(int data){
	Node *newNode = new Node(data);
	if(root_ == 0){
		root_ = newNode;
		++size_;
		return true;
	}else{
		Node *parent = root_;
		Node *current = root_;
		bool isleft;
		while(current != 0){
			parent = current;
			if(current->data_ == data)
				return false;
			else if(current->data_ > data){
				isleft = true;
				current = current->left_;
			}else{
				isleft = false;
				current = current->right_;
			}
		}
		if(isleft){
			parent->left_ = newNode;
		}else{
			parent->right_ = newNode;
		}
		++size_;
		return true;
	}
}

//二叉树的大小
int BinaryTree::size(){
	return size_;
}
//前、中、后遍历二叉树的private方法
void BinaryTree::preOrder_func(Node* node){
	if(node == 0)
		return;
	else{
		std::cout << node->data_ << ",";
		preOrder_func(node->left_);
		preOrder_func(node->right_);
	}
}
void BinaryTree::inOrder_func(Node* node){
	if(node == 0)
		return;
	else{
		inOrder_func(node->left_);
		std::cout << node->data_ << ",";
		inOrder_func(node->right_);
	}
}
void BinaryTree::postOrder_func(Node* node){
	if(node == 0)
		return;
	else{
		postOrder_func(node->left_);
		postOrder_func(node->right_);
		std::cout << node->data_ << ",";
	}
}
//前、中、后遍历二叉树
void BinaryTree::preOrder(){
	preOrder_func(root_);
	std::endl(std::cout);
}
void BinaryTree::inOrder(){
	inOrder_func(root_);
	std::endl(std::cout);
}
void BinaryTree::postOrder(){
	postOrder_func(root_);
	std::endl(std::cout);
}
//二叉树的查找方法
BinaryTree::Node *BinaryTree::find(int data){
	Node *current = root_;
	if(root_ == 0){
		return 0;
	}
	while(current->data_ != data){
		if(current->data_ > data)
			current = current->left_;
		else
			current= current->right_;
		if(current == 0)
			return 0;
	}
	return current;
}
//二叉树的删除方法
bool BinaryTree::deleteNode(int data){
	Node* parent = root_;
	Node* current = root_;
	bool isLeft;
	if(root_ == 0){
		return false;
	}
	while(current->data_ != data){
		parent = current;
		if(current->data_ > data){
			current = current->left_;
			isLeft = true;
		}
		else{
			current = current->right_;
			isLeft = false;
		}
		if(current == 0)
			return false;
	}
	if(current->left_ == 0 && current->right_ == 0){
		if(current == root_){
			root_ = 0;
		}else if(isLeft){
			parent->left_ = 0;
		}else{
			parent->right_ = 0;
		}
		delete current;
	}else if(current->left_ == 0){
		if(current == root_){
			root_ = current->right_;
		}else if(isLeft){
			parent->left_ = current->right_;
		}else{
			parent->right_ = current->right_;
		}
		delete current;
	}else if(current->right_ == 0){
		if(current == root_){
			root_ = current->left_;
		}else if(isLeft){
			parent->left_ = current->left_;
		}else{
			parent->right_ = current->left_;
		}
		delete current;
	}else{
		Node *successor = this->getSuccessor(current);
		if(current == root_){
			root_ = successor;
		}else if(isLeft){
			parent->left_ = successor;
		}else{
			parent->right_ = successor;
		}
		successor->left_ = current->left_;
		delete current;
	}
	--this->size_;
	return true;
}
//查找继任节点的private方法
BinaryTree::Node* BinaryTree::getSuccessor(Node *del){
	Node *successorParent = del;
	Node *successor = del;
	Node *current = del->right_;
	while(current != 0){
		successorParent = successor;
		successor = current;
		current = current->left_;
	}
	if(successor != del->right_){
		successorParent->left_ = successor->right_;
		successor->right_ = del->right_;
	}
	return successor;
}
//显示树
void BinaryTree::displayTree(){
	std::stack<Node*> globalStack;
	globalStack.push(root_);
	int nBlanks = 32;
	bool isRowEmpty = false;
	std::cout << ".................................................." << std::endl;

	while(isRowEmpty == false){
		std::stack<Node*> localStack;
		isRowEmpty = true;
		for(int j=0;j<nBlanks;++j){
			std::cout << " ";
		}
		while(globalStack.empty() == false){
			Node *tmp = globalStack.top();
			globalStack.pop();
			
			if(tmp != 0){
				std::cout << tmp->data_;
				localStack.push(tmp->left_);
				localStack.push(tmp->right_);

				if(tmp->left_ != 0 || tmp->right_ != 0)
					isRowEmpty = false;
			}else{
				std::cout << "--";
				localStack.push(0);
				localStack.push(0);
			}
			for(int j=0; j<nBlanks*2 - 2; ++j)
				std::cout << " ";
		}
		std::cout << std::endl;

		nBlanks /= 2;

		while(localStack.empty() == false){
			globalStack.push(localStack.top());
			localStack.pop();
		}
	}
	std::cout << ".................................................." << std::endl;
}

试验代码：

BinaryTree_app.cpp

#include <iostream>
#include "BinaryTree.h"
int main(){
	BinaryTree bt;
	std::cout << bt.size() << std::endl;
	bt.insert(5);
	bt.insert(4);
	bt.insert(6);
	bt.insert(3);
	bt.insert(7);
	bt.insert(2);
	bt.insert(8);
	bt.insert(1);
	std::cout << bt.size() << std::endl;
	bt.displayTree();


	bt.deleteNode(3);
	bt.displayTree();
	return 0;
}

注意：在删除时，如果要删除的节点既有左子节点，又又右子节点，则找此节点的后继结点，后继结点是：所有比此结点大的节点中最小的一个。

在显示节点的方法中，还可以把此方法改造成“非递归方法遍历二叉树”