面经 常见数据结构的算法 - 二叉查找树

二叉查找树有以下特点：

（1）若它的左子树不为空，则左子树上所有结点的值都小于根结点的值；

（2）若它的右子树不为空，则右子树所有结点的值均大于它的根结点的值；

（3）左右子树分别为二叉查找树；

#ifndef _BST_
#define _BST_


#include "Head.h"



struct ST_BST
{
	int val;
	ST_BST *left;
	ST_BST * right;
};

class BST
{
public:
	BST(){};
	~BST(){};

	void begin();

	//create bst
	ST_BST * createBst(int val);

	//insert
	ST_BST* Insert(int val, ST_BST* node);

	ST_BST* deletes(ST_BST* node, int data);

	ST_BST* find_min_elem(ST_BST* node);

protected:


private:
	ST_BST *root;

};

#include "BST.h"

void BST::begin()
{	
	root = NULL;
	//root = createBst(1);
	root = Insert(2, root);
	root = Insert(33, root);
	root = Insert(45, root);
	root = Insert(32, root);
	root = Insert(26, root);

	root = deletes(root,26);
	int a = 0;

}
ST_BST* BST::createBst(int val)
{
	
	ST_BST* node = (ST_BST*)malloc(sizeof(ST_BST));
	if (node == NULL)
	{
		return NULL;
	}
	memset(node, 0, sizeof(ST_BST));

	node->val = val;
	root = node;
	
	return root;
}

ST_BST* BST::Insert(int val, ST_BST* node)
{
	ST_BST* temp = node;
	if (temp == NULL)
	{
		temp = (ST_BST*)malloc(sizeof(ST_BST));
		if (temp == NULL)
		{
			return NULL;
		}
		memset(temp, 0, sizeof(ST_BST));
		temp->val = val;
	}
	
	if (val < temp->val)
	{
		//LEFT
		temp->left = Insert(val, temp->left);
	}
	else if(val > temp->val)
	{
		//RIGHT
		temp->right = Insert(val, temp->right);
	}
	else
	{
		//find the same elem
	}

	return temp;
}
//在右子树中查找最小的一个数。来替换要删除的节点
ST_BST* BST::find_min_elem(ST_BST* node)
{
	if (node == NULL)
	{
		return NULL;
	}
	if (node->left == NULL)
	{
		return node;
	}
	return find_min_elem(node->left);
}

ST_BST* BST::deletes(ST_BST* node, int data)
{
	if (node == NULL)
	{
		return node;
	}

	if (data < node->val)
	{
		node->left = deletes(node->left, data);
	}
	else if (data > node->val)
	{
		node->right = deletes(node->right, data);
	}
	else if ((node->left != NULL) && (node->right != NULL))
	{
		node->val = find_min_elem(node->right)->val;
		node->right = deletes(node->right, node->val);
	}
	else
	{
		node = (node->left != NULL)? node->left : node->right;
	}

	return node;

}