二叉查找树

1.定义

二叉排序树（Binary Sort Tree）又称二叉查找树。 它或者是一棵空树；或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树；

2.节点结构

2.1 拥有key值（排序）

2.2 拥有value值（实用）

2.3左子树指针

2.4右子树指针

2.5父亲节点指针（删除节点需要处理节点上界）

 

3.优/缺点

假设一个BST是平衡的，那么CRUD一个元素的时间复杂度为 O(logN) 即为树高。那么插入/删除频繁(很多动态数据)的处理性能会很好。

但是插入与删除操作容易让一棵树不平衡：

插入：如果插入数据有序性较好，产生的树将趋近于链表。 如 1,2,3,4,5  全部只有右节点。 只有当插入很均匀的时候可能出现平衡（程序员不可控，后续文章会有平衡树）

删除：二叉查找树一般的删除策略（左右子节点都有的情况）是替换左子树最大节点，或者右子树最小节点。长期使用一种方式也会让树趋近链表。

 

4处理过程

插入：二分处理过程。相等则更新节点/不处理；小则往左走，大则往右走，直到发现一个空节点，创建并添加。添加一对指针关系：父亲指向新节点/新节点指向父亲。

查找：二分处理过程。

查找最大值：二分处理过程，不过一直往右走到底即可。

删除：分情况：1.叶节点删除，只考虑父节点对应子指针。2.只有左/右子树的节点删除，把子树往上“提”一层，类似于双向链表删除，考虑下删除节点是父亲的左节点还是右节点。3.左右子树都存在，找到左子树最大值/右子树最小值，与删除节点进行k,v交换，之后删除找到的节点，即1,2的情况。

 

5.一个粗略的实现

#include <iostream>
using namespace std;


/
//二叉查找树(key,value都是int)
//性质：
//1.按key有序二叉树，如一个节点左小右大（等）==》中序遍历可以顺序输出元素
//2.
struct BST_DATA{
	int key;
	int value;
};

class BinarySearchTreeNode{
public: 
	BinarySearchTreeNode(BST_DATA newdata)
	{
		key=newdata.key;
		value=newdata.value;
		left=NULL;
		right=NULL;
		parent=NULL;
	}
public:
	int key;
	int value;
	BinarySearchTreeNode * left;
	BinarySearchTreeNode * right;
	BinarySearchTreeNode * parent;
};

-----------普通插入，O(logN),树高即可---------------------///
bool binarySearchTreeInsert(BinarySearchTreeNode ** ppNode, BST_DATA newdata,BinarySearchTreeNode *pParentNode)
{
	if(NULL == *ppNode){
		*ppNode= new BinarySearchTreeNode(newdata);
		(*ppNode)->parent=pParentNode;
		return true;
	}

	if((newdata.key == (*ppNode)->key))//相等，不处理或更新，这里选择更新
	{
		(*ppNode)->value=newdata.value;
		return true;
	}
	if((newdata.key < (*ppNode)->key))
	{
		return binarySearchTreeInsert( & ((*ppNode)->left), newdata, *ppNode );
	}
	else
	{
		return	binarySearchTreeInsert( & ((*ppNode)->right), newdata, *ppNode );
	}
}
//处理边界+插入
bool insert(BinarySearchTreeNode ** ppNode, BST_DATA newdata){
	//结构体不存在
	if(NULL==ppNode){return false;}
	//新节点作为根
	if(NULL==*ppNode){
		*ppNode= new BinarySearchTreeNode(newdata);
		return true;
	}
	//插入
	return binarySearchTreeInsert(ppNode, newdata,NULL);
}
///

///-----------遍历，复杂度O(N),N为节点数--/
///-----------前序遍历---------------------///
void pre_scan(BinarySearchTreeNode ** ppNode){
	if(NULL!=ppNode && NULL !=*ppNode){
	//	printf("k%d-v%d#",(*ppNode)->key,(*ppNode)->value);
		printf("%d,",(*ppNode)->key);
		pre_scan(&((*ppNode)->left));
		pre_scan(&((*ppNode)->right));
	}
}
///-----------中序遍历（按key顺序）---------------------///
void in_scan(BinarySearchTreeNode ** ppNode){
	if(NULL!=ppNode && NULL !=*ppNode){
		in_scan(&((*ppNode)->left));
	//	printf("k%d-v%d#",(*ppNode)->key,(*ppNode)->value);
		printf("%d,",(*ppNode)->key);
		in_scan(&((*ppNode)->right));
	}
}


-----------查找(logN)---------------------///
//非递归
//根据data 查找
BinarySearchTreeNode * find_node(BinarySearchTreeNode ** ppNode,BST_DATA newdata)
{
	BinarySearchTreeNode * pHead = * ppNode;
	while(pHead!=NULL){
		if(pHead->key==newdata.key)
		{
			return pHead;
		}else if(pHead->key>newdata.key)
		{
			pHead=pHead->left;
		}else
		{
			pHead=pHead->right;
		}
	}
	return NULL;//未找到
}

//查找最大节点
BinarySearchTreeNode * find_max_node(BinarySearchTreeNode ** ppNode)
{
	BinarySearchTreeNode * pHead = * ppNode;
	while(pHead->right!=NULL){pHead=pHead->right;}
	return pHead;
}


///-----------删除所有O(N)---------------------///
void delete_tree(BinarySearchTreeNode ** ppNode)
{
	if(NULL==ppNode || NULL==*ppNode){return ;}
	delete_tree(&((* ppNode)->left));
	delete_tree(&((* ppNode)->right));
	delete (*ppNode);
}
///-----------删除一个****难点---------------------///
//1.叶子节点删除
//2.只有左子树，或者右子树，上移
//3.左子树，右子树都有***，替换左子树最大值，或者右子树最小值（问题，总是选择左树最大值，会让左树趋近直线，导致不平衡）

bool delete_node_from_tree(BinarySearchTreeNode** ppNode, BST_DATA data)  
{  
	
    if(NULL == ppNode || NULL == *ppNode) {return false;}//边界

	BinarySearchTreeNode *deleteNode = * ppNode;
	BinarySearchTreeNode * l_maxNode;

	//确定删除节点
	if(deleteNode->key==data.key)
	{

		//1.左右都有，换左子树最大值
		if(deleteNode->left!=NULL && deleteNode->right!=NULL)
		{
				l_maxNode = find_max_node(&(deleteNode->left));
				//交换 a=a+b; b=a-b; a=a-b;
				l_maxNode->key = l_maxNode->key + deleteNode->key;
				deleteNode->key = l_maxNode->key - deleteNode->key;
				l_maxNode->key = l_maxNode->key - deleteNode->key;
				l_maxNode->value = l_maxNode->value + deleteNode->value;
				deleteNode->value = l_maxNode->value - deleteNode->value;
				l_maxNode->value = l_maxNode->value - deleteNode->value;
				//处理删除节点下面
				if(l_maxNode->parent->right==l_maxNode){
						l_maxNode->parent->right=l_maxNode->left;
				}else{//max父节点是根
						l_maxNode->parent->left=l_maxNode->left;
				}
				//处理删除节点上面
				if (NULL != l_maxNode->left) { 
					l_maxNode->left->parent = l_maxNode->parent;
				}

				delete l_maxNode;
		}
		else{
			//2.只有左或右，上移
			//2.1只有左子树
			if(deleteNode->left!=NULL)
			{
				if(deleteNode->parent!=NULL)//不是根节点
				{
					//处理删除节点上面
					if(deleteNode->parent->left==deleteNode)//是父亲的左儿子
					{
						deleteNode->parent->left=deleteNode->left;
					}else//右儿子
					{
						deleteNode->parent->right=deleteNode->left;
					}
				}
				//处理删除节点下面
				deleteNode->left->parent = deleteNode->parent;
			}
			//2.2只有右子树
			else if(deleteNode->right!=NULL)
			{
				if(deleteNode->parent!=NULL)
				{
					//处理删除节点上面
					if(deleteNode->parent->left==deleteNode)
					{
						deleteNode->parent->left=deleteNode->right;
					}else
					{
						deleteNode->parent->right=deleteNode->right;
					}
				}
				//处理删除节点下面
				deleteNode->right->parent = deleteNode->parent;
			}
			//3.左右都无
			else
			{
				if(deleteNode->parent!=NULL)//不是根节点
				{
					//处理删除节点上面
					if(deleteNode->parent->left==deleteNode)
					{
						deleteNode->parent->left=NULL;
					}else
					{
						deleteNode->parent->right=NULL;
					}
				}
			}
	
			delete deleteNode;
		}
		return true;
	}
	else if(deleteNode->key<data.key)
	{
		return delete_node_from_tree(&((*ppNode)->right),  data);  
	}
	else
	{
		return delete_node_from_tree(&((*ppNode)->left),  data); 
	}

	return true;
}  

//

int main(void)
{
	int key_array[10] = {12,5,18,2,15,9,19,13,17,3}; //插入顺序随即（手动）
	int value_array[10]={ 1,2, 3,4, 5,6, 7, 8, 9,10};
	BST_DATA bst_data_array[10]={0};
	for(int i=0;i<10;i++)
	{
		bst_data_array[i].key=key_array[i];
		bst_data_array[i].value=value_array[i];
	}

	BinarySearchTreeNode * ppNode=NULL;
	for(int j=0;j<10;j++){
		insert(&ppNode, bst_data_array[j]);
	}


	pre_scan(&ppNode);
	printf("\n");
	in_scan(&ppNode);
	printf("\n");
	
	BST_DATA td;
	td.key=1;
	td.value=2;

	/*
	//测试find_node
	BinarySearchTreeNode * node =find_node(&ppNode,bst_data_array[3]);
	if(NULL!=node){printf("\nx %d\n ",node->key);}
	in_scan(&ppNode);
		printf("\n");
	*/
	/*
	//测试find_max_node
	BinarySearchTreeNode * node1 =	find_max_node(&ppNode);
	if(NULL!=node1){printf("\nx %d\n ",node1->key);}
	in_scan(&ppNode);
		printf("\n");
	*/


	//测试删除delete_node_from_tree
	delete_node_from_tree(&ppNode,bst_data_array[1]);
	pre_scan(&ppNode);
	printf("\n");
	delete_tree(&ppNode);
   return 0;
}