二叉树基础

一、基本操作

代码如下（示例）：

#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
//二叉排序树的存储结构
typedef struct BSTNode
{
    ElemType key; //数据域
    struct BSTNode *lchild,*rchild;
}BSTNode,*BSTree;

/*
 *  1.BST树特点:左子树值<根节点值<右子树节点值
 *  2.注意BST是动态插入的,注意BST树中没有key相等的结点
 *  3.这里只给出一些基本算法,其余算法见二叉树,实现原理都一样
 *  4.BST树的典型应用:用来查找序列
 *      1.当序列为静态时(不可变),一般用顺序结构存储,用二分法查找
 *      2.当序列为动态时(序列可变),一般用BST树存储,用BST的算法查找
 */

//二叉排序树中插入指定节点x    递归
int BST_Insert(BSTree &tree,ElemType x)
{
    if (tree==NULL)     //BST为空,则创建并插入节点
    {
        tree=(BSTNode*)malloc(sizeof(BSTNode));
        tree->key=x;
        return 1;   //1表示插入成功
    }
    if (tree->key == x)
    {
        return 0; //0表示BST中有这个节点
    }
    else
    {
        if (x < tree->key)  //在左子树里面插入
            return BST_Insert(tree->lchild,x);
        else                //否则,在右子树里面插入
            return BST_Insert(tree->rchild,x);
    }
}
//二叉排序树查找指定节点x       非递归算法,时间效率大于递归算法
BSTree BST_Search(BSTree tree,ElemType x)
{
    while (tree!=NULL && tree->key!=x)   //当BST非空 并且 不等时
    {
        if (x < tree->key)
            tree=tree->lchild;
        else
            tree=tree->rchild;
    }
    return tree;   //结果为NULL 或者 找到的结点的地址
}
//二叉排序树查找指定节点x       递归算法   垃圾,一般不用
BSTree BST_Search1(BSTree tree,ElemType x)
{
    if (tree==NULL)        //BST为空
        return NULL;
    if (tree->key == x)   //根节点就是要查找的结点
        return tree;
    else                   //否则去左,右子树中查找
    {
        if (x < tree->key)     //左子树
            return BST_Search1(tree,x);
        else                    //右子树
            return BST_Search1(tree,x);
    }
}
//二叉排序树的创建   给定指定序列
void Create_BST(BSTree &tree,ElemType str[],int length)
{
    tree=NULL;   //初始时,BST为空
    for (int i = 0; i < length; ++i) {
        BST_Insert(tree,str[i]);    //利用动态插入的特性,插入节点
    }
}
//返回某结点的直接后继结点
BSTree NextNode(BSTree tree)
{
    if (tree == NULL && tree->rchild == NULL)
        return NULL;
    else
    {
        tree=tree->rchild;
        while (tree->lchild != NULL)
        {
            tree=tree->lchild;
        }
        return tree;
    }
}
//二叉排序树中删除指定节点x  递归算法
int BST_Delet(BSTree &tree,ElemType x)
{
    BSTree pre=tree;
    if (tree == NULL)   //删除失败!
        return 1;
    if (tree->key == x)   //根节点为待删除节点
    {
        if (tree->lchild == NULL && tree->rchild == NULL)
        {
            free(tree);
            return 0; //删除成功!
        }
        if (tree->lchild != NULL && tree->rchild != NULL)
        {
            BSTree temp = NextNode(tree);
            ElemType t=temp->key;
            BST_Delet(temp,t);
            tree->key=t;
            //修改待删除结点为直接后继
        }
        else
        {
            if (tree->lchild == NULL)
            {
                if (pre->lchild == tree)
                    pre->lchild=tree->rchild;
                else
                    pre->rchild=tree->rchild;
                free(tree);
                return 0;  //删除成功
            }
            else
            {
                if (pre->lchild == tree)
                    pre->lchild=tree->lchild;
                else
                    pre->rchild=tree->lchild;
                free(tree);
                return 0; //删除成功
            }
        }
    }
    else
    {
        BST_Delet(tree->lchild,x);
        BST_Delet(tree->rchild,x);
    }

}


//二叉排序树的后序递归遍历
void PostOrder(BSTree tree)
{
    if (tree)
    {
        PostOrder(tree->lchild);  //先遍历左子树
        PostOrder(tree->rchild);  //再遍历右子树
        printf("%d ",tree->key);   //最后遍历根结点
    }
}
//二叉排序树的中序递归遍历   结果是一个从小到大的序列
void InOrder(BSTree tree)
{
    if (tree)
    {
        InOrder(tree->lchild);
        printf("%d ",tree->key);
        InOrder(tree->rchild);
    }
}
//二叉排序树的先序递归遍历
void PreOrder(BSTree tree)
{
    if (tree)
    {
        printf("%d ",tree->key);
        PreOrder(tree->lchild);
        PreOrder(tree->rchild);
    }
}
//销毁二叉排序树  递归算法
void Destory_BST(BSTree &tree)
{
    if (tree)    //LNR删除
    {
        Destory_BST(tree->lchild);   //先删除左子树
        Destory_BST(tree->rchild);   //在删除右子树
        free(tree);                    //最后删除根节点
    }
}
int main()
{
    BSTree tree;
    int str[6]={45,24,53,45,12,24};
    Create_BST(tree,str,6);
    int flag = BST_Delet(tree,45);
    printf("%d\n",flag);
    PreOrder(tree);
    Destory_BST(tree);
    return 0;
}

---

二、总结

明天,持续更新!