二叉排序树的插入和删除（严9.35、9.36和9.37）

Description

假设二叉排序树以后继线索链表作存储结构，编写程序，满足以下要求：
输出该二叉排序树中所有大于a小于b的关键字；
在二叉排序树中插入一个关键字；
在二叉排序树中删除一个关键字。

Input

第一行按先序输入二叉排序树各结点（结点值大于0），其中-1表示取消建立子树结点；第二行输入要求1中a、b，用空格隔开；第三行输入要求2中要插入的关键字；第四行输入要求3中要删除的关键字。

Output

按照中序序列，分三行输出要求1、要求2和要求3的结果。

• Sample Input 

  12 8 4 -1 -1 10 -1 -1 16 13 -1 -1 18 -1 -1
  10 17
  6
  12

• Sample Output

  12 13 16
  4 6 8 10 12 13 16 18
  4 8 10 13 16 18

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

typedef struct BinNode{
    int data;
    struct BinNode *lchild;
    struct BinNode *rchild;
}BinNode,*BinTree;

void CreateBinTree(BinTree *tree)
{
    int ch;
    scanf("%d",&ch);

    if(ch == -1)
    {
        (*tree) = NULL;
    }
    else
    {
        *tree = (BinTree)malloc(sizeof(BinNode));
        (*tree)->data = ch;
        CreateBinTree(&((*tree)->lchild));
        CreateBinTree(&((*tree)->rchild));
    }
}

void Search(BinTree T,int m,int n)
{
    if(T)
    {
        Search(T->lchild,m,n);
        if(T->data > m&& T->data < n)printf("%d ",T->data);
        Search(T->rchild,m,n);
    }
}

void Inorder(BinTree T)
{
    if(T)
    {
        Inorder(T->lchild);
        printf("%d ",T->data);
        Inorder(T->rchild);
    }
}
void Insert(BinTree *T,int key)
{
    if(!(*T))
    {
        (*T) = (BinTree)malloc(sizeof(BinNode));
        (*T)->data = key;
        (*T)->lchild = (*T)->rchild = NULL;
        return;
    }
    if(key == (*T)->data )
        return;
    if(key > (*T)->data )
        Insert( &((*T)->rchild), key );
    else
        Insert( &((*T)->lchild), key );
}

bool Delete(BinTree *T)
{
    BinTree L;
    if (!(*T)->lchild && !(*T)->rchild)
        *T = NULL;
    else if (!(*T)->lchild)
        *T = (*T)->rchild;
    else if (!(*T)->rchild)
        *T = (*T)->lchild;
    else
    {
        L = (*T)->lchild;
        while (L->rchild)
            L = L->rchild;
        L->rchild = (*T)->rchild;
        *T = (*T)->lchild;
    }
    return true;
}
bool DeleteBST(BinTree *T, int key)
{
    if (!*T)
        return false;
    else if (key == (*T)->data)
    {
        Delete(T);
        return true;
    }
    else if (key < (*T)->data)
    {
        return DeleteBST(&((*T)->lchild), key);
    }
    else
    {
        return DeleteBST(&((*T)->rchild), key);
    }
}

int main(){
    BinTree T = NULL;
    CreateBinTree(&T);
    int m,n,w,k;
    scanf("%d %d",&m,&n);
    scanf("%d",&w);
    scanf("%d",&k);
    Search(T,m,n);
    printf("\n");
    Insert(&T,w);
    Inorder(T);
    printf("\n");
    DeleteBST(&T,w);
    DeleteBST(&T,k);
    Inorder(T);
    printf("\n");
    return 0;
}

删除节点的情况有点复杂QAQ

删除的另一种情况:

BinTree Delete( BinTree BST, ElementType X ) 
{ 
    Position Tmp; 
 
    if( !BST ) 
        printf("要删除的元素未找到"); 
    else {
        if( X < BST->Data ) 
            BST->Left = Delete( BST->Left, X );   /* 从左子树递归删除 */
        else if( X > BST->Data ) 
            BST->Right = Delete( BST->Right, X ); /* 从右子树递归删除 */
        else { /* BST就是要删除的结点 */
            /* 如果被删除结点有左右两个子结点 */ 
            if( BST->Left && BST->Right ) {
                /* 从右子树中找最小的元素填充删除结点 */
                Tmp = FindMin( BST->Right );
                BST->Data = Tmp->Data;
                /* 从右子树中删除最小元素 */
                BST->Right = Delete( BST->Right, BST->Data );
            }
            else { /* 被删除结点有一个或无子结点 */
                Tmp = BST; 
                if( !BST->Left )       /* 只有右孩子或无子结点 */
                    BST = BST->Right; 
                else                   /* 只有左孩子 */
                    BST = BST->Left;
                free( Tmp );
            }
        }
    }
    return BST;
}