数据结构——二叉搜索树的C语言实现

1.什么是二叉搜索树？

2.二叉搜索树的操作

3.二叉搜索树的C语言实现

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

#define ElementType int
typedef struct TreeNode *BinTree;
typedef BinTree Position;
struct TreeNode{
        ElementType Data;
        BinTree Left;
        BinTree Right;
};

//1.初始化
BinTree MakeEmpty()
{
        BinTree BT;
        BT=(BinTree)malloc(sizeof(struct TreeNode));
        BT->Left=NULL;
        BT->Right=NULL;
        return BT;
}

//2.查找某值，返回元素的结点指针
Position Find(ElementType X,BinTree BST)
{
        while(BST){
                if(X>BST->Data){
                        BST=BST->Right;
                }
                else if(X<BST->Data){
                        BST=BST->Left;
                }
                else{
                        return BST;
                }
        }
        return NULL;
}

//3.查找最小值所在的结点指针
Position FindMin(BinTree BST)
{
        while(BST->Left){
                BST=BST->Left;
        }
        return BST;
}

//4.查找最大值所在的结点指针
Position FindMax(BinTree BST)
{
        while(BST->Right){
                BST=BST->Right;
        }
        return BST;
}

//5.插入
BinTree Insert(ElementType X,BinTree BST)
{
        if(!BST){
                BST=(BinTree)malloc(sizeof(struct TreeNode));
                BST->Data=X;
                BST->Left=BST->Right=NULL;
        }
        else{
                if(X<BST->Data){
                        BST->Left=Insert(X,BST->Left);
                }
                else if(X>BST->Data){
                        BST->Right=Insert(X,BST->Right);
                }
        }
        return BST;
}

//6.删除
BinTree Delete(ElementType X,BinTree BST)
{
        Position Tmp;
        if(!BST){
                printf("要删除的元素未找到\n");
        }
        else if(X<BST->Data){
                BST->Left=Delete(X,BST->Left);
        }
        else if(X>BST->Data){
                BST->Right=Delete(X,BST->Right);
        }
        else{
                if(BST->Left&&BST->Right){
                        Tmp=FindMin(BST->Right);
                        BST->Data=Tmp->Data;
                        BST->Right=Delete(BST->Data,BST->Right);
                }
                else{
                        Tmp=BST;
                        if(!BST->Left){
                                BST=BST->Right;
                        }
                        else if(!BST->Right){
                                BST=BST->Left;
                        }
                        free(Tmp);
                }
        }
        return BST;
}
int main()
{
        int i;
        BinTree BST[6];
        for(i=0;i<6;i++){
                BST[i]=MakeEmpty();
        }
        BST[0]->Data=18;
        BST[0]->Left=BST[1];
        BST[0]->Right=BST[2];

        BST[1]->Data=10;
        BST[1]->Left=BST[3];
        BST[1]->Right=BST[4];

        BST[2]->Data=20;
        BST[2]->Right=BST[5];

        BST[3]->Data=7;
        BST[4]->Data=15;
        BST[5]->Data=22;
        printf("%d  %d\n",BST[0]->Data,BST[0]->Left->Data);

        Position BST1;
        BST1=Find(22,BST[0]);
        printf("%d\n",BST1->Data);


        Position BST2;
        BST2=FindMin(BST[0]);
        printf("MIN=%d\n",BST2->Data);

        Position BST3;
        BST3=FindMax(BST[0]);
        printf("MAX=%d\n",BST3->Data);

        BST[0]=Insert(19,BST[0]);
        printf("%d\n",BST[0]->Right->Left->Data);

        return 0;
}