算法10---二叉搜索树

算法10---二叉搜索树

搜索树数据结构支持许多动态集合操作，包括search，minimum，maximum，predecessor，successor，insert和delete等。

 

概念：二叉搜索树。对于任何节点x，其左子树中的关键字最大不超过x.key,其右子树中的关键字最小不低于x.key。其运行实际和树的高度成正比；

 

#include <stdio.h>
#include <stdlib.h>

#ifndef _Tree_H

struct treenode;
typedef  struct treenode *position;
typedef struct treenode *searchtree;



searchtree makeempty(searchtree T);//二叉搜索树置空
position find(searchtree T,int key);//在二叉搜索树内查找key
position find_in_recursion(searchtree T,int key);//递归查找
position findmin(searchtree T);//找二叉搜索树内最小值
position findmax(searchtree T);//找二叉搜索树内最大值
searchtree tree_successor(searchtree T);//二叉搜索树内后继节点
searchtree tree_predecessor(searchtree T);//二叉搜索树内前驱

position insertposition(searchtree T,int key);//用于找到key值的插入点
void insert(searchtree T,int key);//插入值，非递归方法
searchtree insert_recursion(searchtree T,int key);//递归方法插入值
void transplant(searchtree T,position u,position v);//使用节点v代替u
void tree_delete(searchtree T,int key);//

void inorder_tree_work(searchtree T);//中序遍历二叉搜索树


#endif


typedef struct treenode
{
    int key;
    int data;
    searchtree left;
    searchtree right;
    searchtree parent;
}treenode;


//中序遍历
void inorder_tree_work(searchtree T)
{
    if (T!=NULL)
    {
        inorder_tree_work(T->left);
        printf("%d
",T->key);
        inorder_tree_work(T->right);
    }
}


//清空搜索树

searchtree makeempty(searchtree T)
{
    if (T!=NULL)
    {
        makeempty(T->left);
        makeempty(T->right);
        free(T);
    }
    return NULL;
}

//查找，一种方法是递归，一种方法是非递归
//我们先采用递归的方法
position find(searchtree T,int key)
{
    if (T==NULL||key==T->key)
    {
        return T;
    }
    if (key<T->key)
    {
        return find(T->left,key);
    }
    else
        return find(T->right,key);
}


position find_in_recursion(searchtree T,int key)
{
    while (T!=NULL&&key!=T->key)
    {
        if (key<T->key)
        {
            T=T->left;
        }
        else
            T=T->right;
    }
    return T;
}


//找二叉搜索树中的最大值和最小值也有递归和非递归的方法，不过我们在这采用非递归的方法；

position findmin(searchtree T)
{
    while (T->left!=NULL)
    {
        T=T->left;
    }
    return T;
}

position findmax(searchtree T)
{
    while (T->right!=NULL)
    {
        T=T->right;
    }
    return T;
}


//找二叉搜索树的前驱和后驱节点

position tree_successor(position T)
{
    if (T->right!=NULL)
    {
        return findmax(T->right);
    }
    position y;
    y=T->parent;
    while(y!=NULL&&T==y->right)
    {
        T=y;
        y=y->parent;
    }
    return y;
}

position tree_predecessor(position T)
{
    if (T->right!=NULL)
    {
        return findmin(T->left);
    }
    position y;
    y=T->parent;
    while(y!=NULL&&T==y->left)
    {
        T=y;
        y=y->parent;
    }
    return y;
}

//先采用递归的方法

searchtree insert_recursion(searchtree T,int key)
{
    if (T==NULL)
    {
        T=(treenode *)malloc(sizeof(struct treenode));
        if (T==NULL)
        {
            printf("out of space!
");
            return NULL;
        }
        else
        {
            T->key=key;
            T->left=T->right=NULL;
        }
    }
    else if (key<T->key)
    {
        T->left=insert_recursion(T->left,key);
    }
    else
        T->right=insert_recursion(T->right,key);


    return T;

}

position insertposition(searchtree T,int key)
{
    position s;
    position p = T;
    while(p!=NULL)
    {
        s=p;
        if (p->key==key)
        {
            return NULL;
        }
        p=(key<p->key)? p->left:p->right;
    }
    return s;
}

void insert(searchtree T,int key )
{
    position p=insertposition(T,key);
    position y=NULL;
    position x=T;
    while(x!=NULL)
    {
        y=x;
        if (key<x->key)
        {
            x=x->left;
        }
        else
            x=x->right;
    }
    p->parent=y;
    if (y==NULL)
    {
        T=p;
    }
    else if (p->key<y->key)
    {
        y->left=p;
    }
    else
        y->right=p;

}

//二叉搜索树的删除操作
void transplant(searchtree T,position u,position v)//使用节点v代替u
{
    if (u->parent==NULL)
    {
        T=u;
    }
    else if (u==u->parent->left)
    {
        u->parent->left=v;
    }
    else
        u->parent->right=v;
    if (v!=NULL)
    {
        v->parent=u->parent;
    }
}

void tree_delete(searchtree T,int key)//二叉搜索树的删除操作
{
    position p=insertposition(T,key);
    if (p->left==NULL)
        transplant(T,p,p->right);
    else if (p->right==NULL)
        transplant(T,p,p->left);
    else
    {
        position y=findmin(p->right);
        if (y->parent!=p)
        {
            transplant(T,y,y->right);
            y->right=p->right;
            y->right->parent=y;
        }
        transplant(T,p,y);
        y->left=p->left;
        y->left->parent=y;
    }   
}

int main()
{
    return 0;

}