/******************************************
数据结构:
BST(Binary Search Tree),二叉查找树;
性质:
若结点的左子树不空,则左子树上所有结点的值均小于它的根结点的值;
若结点的右子树不空,则右子树上所有结点的值均大于它的根结点的值;
该结点的左、右子树也分别为二叉查找树;
遍历:
对于一个已知的二叉查找树,从小到大输出其节点的值;
只需对其进行二叉树的中序遍历即可;
即递归地先输出其左子树,再输出其本身,然后输出其右子树;
遍历的时间复杂度为O(n);
查找:
对于一个已知的二叉查找树x;
在其中查找特定的值k,函数Search返回指向值为k的节点指针;
若找不到则返回0,算法时间复杂度为O(h),h为树的高度;
理想情况下时间复杂度为lgn;
最大值和最小值:
要查找二叉查找树中具有最小值的元素;
只要从根节点开始,沿着左子树找到最左边的节点就可以了;
反之沿着右子树查找则可以求最大值;
插入:
从根节点开始插入;
如果要插入的值小于等于当前节点的值,在当前节点的左子树中插入;
如果要插入的值大于当前节点的值,在当前节点的右子树中插入;
如果当前节点为空节点,在此建立新的节点,该节点的值为要插入的值,左右子树为空,插入成功;
删除:
如果该没有子女,直接删除;
如果该结点只有一个子女,则删除它,将其子女的父亲改为它的父亲;
如果该结点有两个子女,先用其后继替换该节点,其后继的数据一并加在其后;
*******************************************/
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<climits>
#include<algorithm>
using namespace std;
const int N = 100000;
int key[N], l[N], r[N], p[N];
int u, node;
int Search(int x, int k)//查询
{
if(x == 0 || k == key[x])
return x;
if(k < key[x])
return Search(l[x], k);
else
return Search(r[x], k);
}
int Iterative_Search(int x, int k)//非递归版本的查询
{
while(x != 0 && k != key[x])
if(k < key[x])
x = l[x];
else
x = r[x];
return x;
}
int Minimum(int x)
{
while(l[x] != 0)
x = l[x];
return x;
}
int Maximum(int x)
{
while(r[x] != 0)
x = r[x];
return x;
}
int Successor(int x)
{
if(r[x] != 0)
return Minimum(r[x]);
int y = p[x];
while(y != 0 && x == r[y])
{
x = y;
y = p[y];
}
return y;
}
int Predecessor(int x)
{
if(l[x] != 0)
return Maximum(l[x]);
int y = p[x];
while(y != 0 && x == l[y])
{
x = y;
y = p[y];
}
return y;
}
void Insert(int &T, int v)//插入结点
{
if(T == 0)
key[T = ++node] = v;
else if(v <= key[T])
{
p[l[T]] = T;
Insert(l[T], v);
}
else
{
p[r[T]] = T;
Insert(r[T], v);
}
}
void Iterative_Insert(int T, int v)//非递归版本插入结点
{
int y = 0;
int x = T;
int z = ++node;
key[z] = v;
while(x != 0)
{
y = x;
if(key[z] < key[x])
x = l[x];
else
x = r[x];
}
p[z] = y;
if(y == 0)
key[T] = z;
else if(key[z] < key[y])
l[y] = z;
else
r[y] = z;
}
void Transplant(int T, int u, int v)//移植过程;
//把一棵子树u归并到另一棵子树v中,u的父亲变为v的父亲,u的父亲就有了v作为其孩子。
{
if(p[u] == 0)
T = v;
else if(u == l[p[u]])
l[p[u]] = v;
else
r[p[u]] = v;
if(v != 0)
p[v] = p[u];
}
void Delete(int T, int z)//删除结点
{
if(l[z] == 0)
Transplant(T, z, r[z]);
else if(r[z] == 0)
Transplant(T, z, l[z]);
else
{
int y = Minimum(r[z]);
if(p[y] != z)
{
Transplant(T, y, r[y]);
r[y] = r[z];
p[r[y]] = y;
}
Transplant(T, z, y);
l[y] = l[z];
p[l[y]] = y;
}
}
int main()
{
int n;
scanf("%d",&n);
for(int i=0; i<n; i++)
{
int k;
scanf("%d",&k);
Insert(u, k);
}
Delete(u, Search(u, 1));
printf("%d\n",Search(u,2));
printf("%d\n",Maximum(u));
return 0;
}
BST(Binary Search Tree 二叉查找树模版)
最新推荐文章于 2022-03-05 17:53:44 发布