二叉树 C++实现

二叉树 C++实现

支持插入、删除、查找操作

实现二叉树的前、中、后序遍历（包括递归和非递归）

#include <climits>
#include <iostream>
#include <stack>


#ifndef BINARY_SEARCH_TREE
#define BINARY_SEARCH_TREE

const int INF = INT_MAX;
using namespace std;

struct Node
{
	int value;
	Node *left_child;
	Node *right_child;
};

Node *get_node();

class BinarySearchTree{
private:
	Node *root;

	void remove_current_node(Node *current, Node* parent);
	void traversal_inorder_helper(Node *tree);
	void traversal_preorder_helper(Node *tree);
	void traversal_postorder_helper(Node *tree);

public:
	BinarySearchTree();
	bool insert(int);
	bool remove(int);
	bool search(int);
	void traversal_inorder_recursive();
	void traversal_inorder_iterative();
	void traversal_preorder_recursive();
	void traversal_preorder_iterative();
	void traversal_postorder_recursive();
	void traversal_postorder_iterative();
};

#endif

Node *get_node()
{
	Node *newNode = new Node();
	newNode->left_child = newNode->right_child = NULL;

	return newNode;
}

BinarySearchTree::BinarySearchTree()
{
	root = get_node();
	root->value = INF;
}

bool BinarySearchTree::insert(int value){
	if(root->value == INF)
	{
		root->value = value;
		return true;
	}

	Node *current = root;
	Node *newNode = get_node();

	if(newNode == NULL)
		return false;

	while(true)
	{
		if(value <= current->value)
		{
			if(current->left_child == NULL)
			{
				current->left_child = newNode;
				current->left_child->value = value;
				return true;
			}
			else
			{
				current = current->left_child;
			}
		}
		else
		{
			if(current->right_child == NULL)
			{
				current->right_child = newNode;
				current->right_child->value = value;
				return true;
			}
			else
			{
				current = current->right_child;
			}
		}
	}

}


bool BinarySearchTree::remove(int value)
{
	if(root->value == INF){
		return false;
	}

	Node *current = root;
	Node *parent = NULL;

	while(true)
	{
		if(value == current->value)
		{
			remove_current_node(current, parent);
		}
		else
		{
			parent = current;

			if(current->value < value)
			{
				current = current->right_child;
			}
			else
			{
				current = current->left_child;
			}

			if(current == NULL)
			{
				return false;
			}
		}
	}
}



void BinarySearchTree::remove_current_node(Node *current, Node *parent)
{
	Node *toBeDeleted;
	Node *successor;
	Node *successorParent = NULL;

	if(current->right_child == NULL and current->left_child == NULL)
	{
		if(parent == NULL){
			current->value = INF;
		}
		else
		{
			if(parent->left_child == current)
				parent->left_child = NULL;
			else
				parent->right_child = NULL;

			delete current;
		}
	}
	else if(current->right_child == NULL)
	{
		toBeDeleted = current->left_child;
		current->value = current->left_child->value;
		current->right_child = current->left_child->right_child;
		current->left_child = current->left_child->left_child;

		delete toBeDeleted;
	}
	else
	{
		successor = current->right_child;
		successorParent = NULL;

		while(successor->left_child != NULL)
		{
			successorParent = successor;
			successor = successor->left_child;
		}

		if(successorParent == NULL)
		{
			current->right_child = successor->right_child;
		}
		else
		{
			successorParent->left_child = successor->right_child;
		}

		current->value = successor->value;
		delete successor;
	}
}


bool BinarySearchTree::search(int value)
{
	Node *current = root;

	while(true)
	{
		if(value < current->value)
		{
			if(current->left_child == NULL)
			{
				return false;
			}
			else
			{
				current = current->left_child;
			}
		}
		else if(value > current->value)
		{
			if(current->right_child == NULL)
			{
				return false;
			}
			else
			{
				current = current->right_child;
			}
		}
		else
		{
			return true;
		}
	}
}


void BinarySearchTree::traversal_inorder_helper(Node *tree)
{
	if(tree == NULL or tree->value == INF)
		return ;

	traversal_inorder_helper(tree->left_child);
	cout << tree->value <<endl;
	traversal_inorder_helper(tree->right_child);
}

void BinarySearchTree::traversal_inorder_recursive()
{
	traversal_inorder_helper(root);
}

void BinarySearchTree::traversal_inorder_iterative()
{
	if(root->value == INF)
		return;

	stack<Node *> traversal;
	Node *current = root;
	bool complete = false;

	while(!complete)
	{
		if(current != NULL)
		{
			traversal.push(current);
			current = current->left_child;
		}
		else if(!traversal.empty())
		{
			current = traversal.top();
			traversal.pop();
			cout << current->value << endl;
			current = current->right_child;
		}
		else
		{
			complete = true;
		}

	}
}


void BinarySearchTree::traversal_preorder_helper(Node *tree)
{
	if(tree == NULL or tree->value == INF)
	{
		return ;
	}

	cout << tree->value << endl;
	traversal_preorder_helper(tree->left_child);
	traversal_preorder_helper(tree->right_child);
}

void BinarySearchTree::traversal_preorder_recursive()
{
	traversal_preorder_helper(root);
}

void BinarySearchTree::traversal_preorder_iterative()
{
	if(root->value == INF)
	{
		return ;
	}

	stack<Node *> traversal;
	Node *current;

	traversal.push(root);

	while(!traversal.empty()){
		current = traversal.top();
		traversal.pop();
		cout << current->value << endl;

		if(current->right_child != NULL)
		{
			traversal.push(current->right_child);
		}

		if(current->left_child != NULL)
		{
			traversal.push(current->left_child);
		}
	}
}

void BinarySearchTree::traversal_postorder_helper(Node *tree)
{
	if(tree == NULL or tree->value == INF)
	{
		return;
	}
	else
	{
		traversal_postorder_helper(tree->left_child);
		traversal_postorder_helper(tree->right_child);
		cout << tree->value << endl;
	}
}


void BinarySearchTree::traversal_postorder_recursive()
{
	traversal_postorder_helper(root);
}


void BinarySearchTree::traversal_postorder_iterative()
{
	if(root->value == INF)
	{
		return ;
	}

	stack<Node *> traversal;
	Node *current = root;

	do
	{
		while(current)
		{
			if(current->right_child)
				traversal.push(current->right_child);
			traversal.push(current);

			current = current->left_child;
		}

		current = traversal.top();
		traversal.pop();

		if(current->right_child and traversal.empty() == false and traversal.top() == current->right_child)
		{
			traversal.pop();
			traversal.push(current);
			current = current->right_child;
		}
		else
		{
			cout << current->value << endl;
			current = NULL;
		}
	}while( !traversal.empty());

}

int main()
{
	BinarySearchTree tree;

	tree.insert(10);
	tree.insert(14);
	tree.insert(12);
	tree.insert(5);

	cout << "In Order Traversal: \n";
    tree.traversal_inorder_recursive();

    cout << "Pre Order Traversal: \n";
    tree.traversal_preorder_recursive();

    cout << "Post Order Traversal: \n";
    tree.traversal_postorder_recursive();

    cout << "Searching 10 : ";
    if(tree.search(10))
        cout << "Found!\n";
    else
        cout << "Not found!\n";

    cout << "Removing 10\n";
    tree.remove(10);

    cout << "In Order Traversal: \n";
    tree.traversal_inorder_iterative();

    cout << "Pre Order Traversal: \n";
    tree.traversal_preorder_iterative();

    cout << "Post Order Traversal: \n";
    tree.traversal_postorder_iterative();

    cout << "Searching 10 : ";
    if(tree.search(10))
        cout << "Found!\n";
    else
        cout << "Not found!\n";

	return 0;
}