binary search tree搜索二叉树BST

目录

dynamic sets动态集合

data structer数据结构

---

dynamic sets动态集合

data structer数据结构

• 有关键值、卫星信息、指向两个左右孩子和父母的指针的元素
• 支持七个查询操作：搜索某个元素，找最小值，找最大值，插入元素，删除元素，操作失败，操作成功
• 性质：x的左子值<=x的值<=x的右子值，key[leftsubtree(x)]<=key[x]<=key[rightsubtree(x)]

algorithms（注意算法和代码不同）

1.搜索元素并返回键值

时间复杂度为o(h)，h为搜索二叉树的深度

//第一个方法
Typeofelement TreeSearch(int x, int k)
{
    if(x==NULL||k==key[x])     return x;
    if(k<key[x])     return TreeSearch(left[x], k);
    else     return TreeSearch(right[x],k);
}
//第二个方法
Typeofelement Treesearch(x,k)
{
    while(x!=NULL&&k!=key[x])
    {
        if(k<key[x])     x=left[x];
        else     x=right[x];
    }
    return x;
}

2.插入新元素

在插入新元素的同时需要注意保持搜索二叉树的性质，即x的左子值<=x的值<=x的右子值。从根部找起，要插入的值小于要比较的值则往左，否则往右。时间复杂度为o(h)，h为搜索二叉树的深度

算法步骤：

        1）搜索到可以插入元素的位置NULL

        2）在该NULL位置插入元素

Typeofelemnet TreeInsert(T,z)//wanne insert z element
{
    y=NULL, x=T.root;
    while(x!=NULL)
    {
        y=x;//the current node is recorded by y
        if(z.key<x.key)    x=x.left;//need to turn left
        else    x=x.right;//need to turn right
    }
    z.p=y;//the parent of z is y
    if(y==NULL)    T.root=z;//the tree is empty
    else
    {
        if(z.key<y.key)    y.left=z;//the value of z is smaller 
                                    //than the value of parent y
        else    y.right=z;//the value of z is bigger
    }
}

3.排序

类似快速排序，时间复杂度为o(nlogn)，但是搜索二叉树的排序劣于快速排序，因为快速排序使用常数进行比较，在固定位置上排序并且不需要建立结构体

void quick_sort(int *num, int l, int r)
{
	//如果小于等于1个数据元素·直接返回结束快排函数 r为数组元素总个数
	if(l+1>=r)
    {
		return ;
	}
	int first=l, last=r-1, key=num[first] ;
	while(first < last)
    {
		while(first<last&&num[last]>=key){
			--last;
		}
		//如果值小于 key分界值 交换 
		num[first]=num[last];
		while(first<last&&num[first]<key){
			++first;
		}
		//如果值大于key分界值 交换 
		num[last]=num[first];
	}
	num[first]=key;
	//递归左右部分进行快排 
	quick_sort(num, l, first);
	quick_sort(num, first+1 ,r);
}

4.求最大值的元素

Typeofelement TreeMaximun(x)
{
    while(x.right!=NULL)    x=x.right;//when the right kid of x is NULL, x is the answer
    return x;
}

5.递归求树的高度

理论解释：Tree为树的结构类型，递归时有三种情况：递归到树空并返回高度0；递归到叶结点返回高度1；递归计算所有子树的高度，取较大值加1（1代表根节点）

int Height(Tree T)
{
    if(Isempty(T)) return 0;//父母结点不为空
    else if(Isleaf(T)) return 1;//递归到叶结点，返回1
         else
         {
            int h=0,k;
            for(Tree p=Firstchild(T);p!=NULL;p=Nextsibling(T.p)) //循环递归到空结点
                                                                //则终止这一循环              
                 if((k=Height(p))>h) h=k;//递归到更高的高度，更新高度的记录h 
                
            return h+1;
         }
}

6.递归求树的结点个数

理论解释：Tree为树的结构类型，递归时有两种情况:递归到树空返回结点个数0；递归到所有子树的结点个数，累加然后加1（1代表根结点个数）

int Nodes(Tree T)//传入父母结点
{
    if(Isempty(T) return 0;
    else//父母结点不为空
    {
        int sum=0;
        for(Tree p=Firstchild(T);p!=NULL;p=Nextsibling(T,p)) sum+=Nodes(P);
        //先不将父母结点算进sum，先往下递归看子结点是否也非空
    return sum+1;//1代表这一层的父母结点
    }
}

7.递归求树的叶结点个数

理论解释：Tree为树的结构类型，递归时有三种情况：递归到树空返回0；递归到叶结点返回1；递归计算所有子树的叶结点个数并累加返回结果

int Leave(Tree T)
{
    if(Isempty(T)) return 0;//递归到空树返回0
    else
    {    if(Isleaf(T)) return 1;递归到叶结点，返回1
         else 
            {
                int sum=0;
                for(Tree p=Firstchild(T);p!=NULL;p=Nextsibling(T)) sum+=Leave(p);
                        //用递归这一个父母结点的子结点所统辖的叶结点个数
                return sum;//只计算叶结点，所以只返回sum，不需加上父母结点数量（数量为1）
            }
    }