二叉搜索树

#include "stdafx.h"
#include 

using namespace std;

struct Node
{
	int value;
	Node* left;
	Node* right;
};

bool insert(Node* p, int value);
bool deleteCore(Node*& p, int value);

//插入
//如果二叉排序树中不含有此元素，则插入并返回true，否则返回false
//root为引用类型，使得当root为空时对root的修改对调用者可见
bool insertBST(Node*& root, int value)
{
	if(root == NULL)
	{
		Node* node = new Node();
		node->value = value;
		node->left = NULL;
		node->right = NULL;
		root = node;
		return true;
	}
	return insert(root,value);
}

bool insert(Node* p, int value)
{
	if(value == p->value)
	{
		return false;
	}
	if(value < p->value)
	{
		if(p->left == NULL)
		{
			Node* node = new Node();
			node->value = value;
			node->left = NULL;
			node->right = NULL;
			p->left = node;
			return true;
		}
		return insert(p->left, value);
	}
	if(value > p->value)
	{
		if(p->right == NULL)
		{
			Node* node = new Node();
			node->value = value;
			node->left = NULL;
			node->right = NULL;
			p->right = node;
			return true;
		}
		return insert(p->right, value);
	}
}

//创建搜索二叉树
Node* createBST(int* a, int n)
{
	if(a==NULL || n<=0)
		return NULL;
	Node* root = NULL;
	for(int i=0;ivalue)
	{
		return deleteCore(root,value);
	}
	if(value < root->value)
	{
		return deleteBST(root->left, value);
	}
	if(value > root->value)
	{
		return deleteBST(root->right, value);
	}
}

//p为引用类型
bool deleteCore(Node*& p, int value)
{
	Node* q = NULL;
	if(p->right == NULL)
	{
		q = p;
		p = p ->left;
		delete q;
	}else if(p->left == NULL)
	{
		q = p;
		p = p->right;
		delete q;
	}else
	{
		q = p;
		Node* s = q->left;//转左
		if(s->right == NULL)
		{
			p->value = s->value;
			p->left = s->left;
		}else
		{
			//s指向被删结点的前驱
			while(s->right != NULL)
			{
				q = s;
				s = s->right;
			}
			p->value = s->value;
			q->right = s->left;
		}
		delete s;
	}
	return true;
}

//先序遍历
void preOrderTraverse(Node* root)
{
	if(root == NULL)
		return;
	cout<value<<" ";
	preOrderTraverse(root->left);
	preOrderTraverse(root->right);
}

//中序遍历
void inOrderTraverse(Node* root)
{
	if(root == NULL)
		return;
	inOrderTraverse(root->left);
	cout<value<<" ";
	inOrderTraverse(root->right);
}

int main()
{
	int a[] = {2,5,9,4,3,8,1};
	Node* root = createBST(a, 7);
	preOrderTraverse(root);
	cout<