一、定义和性质:
1、定义
二叉查找树(Binary Search Tree),又被称为二叉搜索树。
它是特殊的二叉树:
对于二叉树,假设x为二叉树中的任意一个结点,x节点包含关键字key,节点x的key值记为key[x]。如果y是x的左子树中的一个结点,则key[y] <= key[x];如果y是x的右子树的一个结点,则key[y] >= key[x]。那么,这棵树就是二叉查找树。
2、性质
二叉搜索树或者是一棵空树,或者是具有下列性质的二叉树:
1、每个结点都有一个作为搜索依据的关键码(key),所有结点的关键码互不相同。
2、左子树(如果非空)上所有结点的关键码都小于根结点的关键码。
3、右子树(如果非空)上所有结点的关键码都大于根结点的关键码。
4、左子树和右子树也是二叉搜索树。
5、结点左子树上所有关键码小于结点关键码;
6、右子树上所有关键码大于结点关键码;
7、若从根结点到某个叶结点有一条路径,路径左边的结点的关键码不一定小于路径上的结点的关键码。
8、如果对一棵二叉搜索树进行中序遍历,可以按从小到大的顺序,将各结点关键码排列起来,所以也称二叉搜索树为二叉排序树。
二、二叉搜索树的实现
#include <iostream>
using namespace std;
struct BST_Node
{
BST_Node *left;
BST_Node *right;
BST_Node *parent;
int key;
};
//中序遍历,按顺序输出
void InOrder_Tree_Walk(BST_Node *x)
{
if (x != NULL)
{
InOrder_Tree_Walk(x->left);
cout << x->key << " ";
InOrder_Tree_Walk(x->right);
}
}
//递归查找
BST_Node *D_Tree_Search(BST_Node *x, int k)
{
if ((x == NULL) || (k == x->key))
return x;
if (k < x->key)
return D_Tree_Search(x->left, k);
else
return D_Tree_Search(x->right, k);
}
//迭代查找
BST_Node *Iterative_Tree_Search(BST_Node *x, int k)
{
while ((x != NULL) && (k != x->key))
{
if (k < x->key)
x = x->left;
else
x = x->right;
}
return x;
}
//迭代法求最小值
BST_Node *Iterative_Tree_Minimum(BST_Node *x)
{
while (x->left != NULL)
x = x->left;
return x;
}
//递归法求最小值
BST_Node *D_Tree_Minimum(BST_Node *x)
{
if (x->left == NULL)
return x;
else
return D_Tree_Minimum(x->left);
}
//迭代法求最大值
BST_Node *Iterative_Tree_Maximum(BST_Node *x)
{
while (x->right != NULL)
x = x->right;
return x;
}
//递归法求最大值
BST_Node *D_Tree_Maximum(BST_Node *x)
{
if (x->right == NULL)
return x;
else
return D_Tree_Maximum(x->right);
}
BST_Node *Tree_Successor(BST_Node *Root, int k)
{
BST_Node *x = D_Tree_Search(Root, k);
if (x->right != NULL)
return Iterative_Tree_Minimum(x->right);
else
{
BST_Node *y = x->parent;
while ((y != NULL) && (x == y->right))//y==NULL 返回根节点的双亲,表示无后继节点
{ //x != y->right 表示前面一串节点是当前y的左孩子
x = y; //此时的y是后继
y = y->parent;
}
return y;
}
}
BST_Node *Tree_Predecessor(BST_Node *Root , int k)
{
BST_Node *x = D_Tree_Search(Root, k);
if (x->left != NULL)//若左孩子非空,左孩子的最大值就是前驱
return Iterative_Tree_Maximum(x->left);
else//若左孩子为空
{
BST_Node *y = x->parent; //依次向上找到整体作为左子树的双亲节点,即为前驱
while ((y != NULL) && (x == y->left))
{
x = y;
y = y->parent;
}
return y;
}
}
//迭代法插入
BST_Node *Iterative_Tree_Insert(BST_Node *Root, int k)
{
BST_Node *z = new BST_Node;
z->key = k;
z->left = z->right = z->parent = NULL;
BST_Node *y = NULL;
BST_Node *x = Root;
while (x != NULL)//x,y两个指针向下移动,直到x为NULL,这个NULL占据位就是z要放置的地方
{
y = x;//当前x节点存到y,遍历指针y作为x的双亲
if (z->key < x->key)
x = x->left;
else
x = x->right;
}
z->parent = y;//将y作为z的双亲
if (y == NULL)//此时二叉树为空
Root = z;
else if (z->key < y->key)//如果z关键字小于z的双亲y的关键字,则z作为y的左孩子
y->left = z; //否则作为右孩子
else
y->right = z;
return Root;
}
//递归法插入
BST_Node *D_Tree_Insert(BST_Node *Root, int k)
{
if (!Root)
{//若原树为空,生成并返回一个节点的二叉搜索树
Root->key = k;
Root->left = NULL;
Root->right = NULL;
}
else //开始找要插入元素的位置
{
if (k <= Root->key)//递归插入左子树
Root->left = D_Tree_Insert(Root->left, k);
else //递归插入右子树
Root->right = D_Tree_Insert(Root->right, k);
}
return Root;
}
//有数组A[]建立二叉搜索树
BST_Node *Establish_Tree(int *A, int Length)
{
BST_Node *Root = NULL;
for (int i = 0; i < Length; ++i)
Root = Iterative_Tree_Insert(Root, A[i]);
return Root;
}
//一棵子树替代另一棵子树
void Transplant(BST_Node *Root, BST_Node *u, BST_Node *v)
{
if (u->parent == NULL)//u为根节点
Root = v;
else if (u = u->parent->left)//u是左子树
u->parent->left = v;
else
u->parent->right = v; //u是右子树
if (v != NULL) //更新双亲节点,左右子树节点待更新
v->parent = u->parent;
}
//删除节点
BST_Node *Tree_Delete(BST_Node *Root, int k)
{
BST_Node *z = D_Tree_Search(Root, k);
if (z->left == NULL)
Transplant(Root, z, z->right);
else if (z->right == NULL)
Transplant(Root, z, z->left);
else
{
//寻找z节点后继节点
BST_Node *y = Iterative_Tree_Minimum(z->right);
if (y->parent != z)//右孩子不是z的后继
{
Transplant(Root, y, y->right);//将后继的右孩子替代后继,并更新y节点的右孩子
y->right = z->right;
y->right->parent = y;
}
Transplant(Root, z, y);//用y替代z,并更新y的左孩子
y->left = z->left;
y->left->parent = y;
}
return Root;
}
int main()
{
int A[] = { 3, 10, 2, 5, 9, 7, 4, 1, 6, 8 };
int Length = sizeof(A) / sizeof(A[0]);
BST_Node *Root;
Root = Establish_Tree(A, Length);
cout << "中序遍历输出所有节点值:";
InOrder_Tree_Walk(Root);
cout << endl;
cout << "4的后继是:" << Tree_Successor(Root, 4)->key << endl;
cout << "7的前驱是:" << Tree_Predecessor(Root, 7)->key << endl;
cout << "迭代法的最小值是:" << Iterative_Tree_Minimum(Root)->key << endl;
cout << "递归法的最小值是:" << D_Tree_Minimum(Root)->key << endl;
cout << "迭代法的最大值是:" << Iterative_Tree_Maximum(Root)->key << endl;
cout << "递归法的最大值是:" << D_Tree_Maximum(Root)->key << endl;
cout << "迭代法插入4:";
Root = Iterative_Tree_Insert(Root, 4);
cout << "中序遍历输出所有节点值:";
InOrder_Tree_Walk(Root);
cout << endl;
cout << "递归法插入8:";
Root = D_Tree_Insert(Root, 8);
cout << "中序遍历输出所有节点值:";
InOrder_Tree_Walk(Root);
cout << endl;
cout << "删除5:";
Root = Tree_Delete(Root, 5);
cout << "中序遍历输出所有节点值:";
InOrder_Tree_Walk(Root);
cout << endl;
system("pause");
return 0;
}
版权声明:本文为博主原创文章,未经博主允许不得转载。