本題題目來源是：

老實說，寫二叉樹的基本操作寫的我心慌意亂，主要原因是總感覺遞迴學的不夠深入。
在昨天與前天再次沉思遞迴的奧祕後，我感覺到了力量。
然而還是不夠自信，於是在網上找別人的寫法，粗粗讀了幾篇，具體的操作都很簡單，但是別人寫的我卻死活走不通，我想，是時候自己動手造青蛙學習而不是看著青蛙了。

於是，有了下面這個冗長的各種遞迴寫法的程式碼：
如果過段時間我還看得懂，我就來寫程式碼的解釋，今天下午的兩個小時都寫這個了。。
但是，很爽~

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

typedef int ElementType;
typedef struct TNode *
 
Position;
typedef Position BinTree;
struct TNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};
// 實現二叉樹的五種操作

BinTree Insert( BinTree BST, ElementType X );
BinTree Delete( BinTree BST, ElementType X );
Position Find( BinTree BST, ElementType X );
Position FindMin( BinTree BST );
Position FindMax( BinTree BST );
BinTree SubTreeInsert(BinTree BST, ElementType X);
Position LocateParent(BinTree BST, ElementType X);
BinTree DeleteNode(BinTree BST, Position parent
 
, Position node);
void PreorderTraversal(BinTree BT ) /* 先序遍歷*/
{
    if(BT != NULL)
    {
        printf("%d  ",BT->Data );
        PreorderTraversal(BT->Left); //遍歷左子樹
        PreorderTraversal(BT->Right); //遍歷右子樹
    }
}
void InorderTraversal( BinTree BT )/* 中序遍歷*/
{
    if(BT)
    {
        InorderTraversal(BT->
 
Left);
        printf("%d ",BT->Data );
        InorderTraversal(BT->Right);
    }
}
//測試程式
int main()
{
    BinTree BST, MinP, MaxP, Tmp;
    ElementType X;
    int N, i;

    BST = NULL;
    scanf("%d", &N);
    for ( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Insert(BST, X);
    }
    printf("Preorder:"); PreorderTraversal(BST); printf("\n");
    MinP = FindMin(BST);
    MaxP = FindMax(BST);
    scanf("%d", &N);
    for( i=0; i<N; i++ ) {
        scanf("%d", &X);
        Tmp = Find(BST, X);
        if (Tmp == NULL) printf("%d is not found\n", X);
        else {
            printf("%d is found\n", Tmp->Data);
            if (Tmp==MinP) printf("%d is the smallest key\n", Tmp->Data);
            if (Tmp==MaxP) printf("%d is the largest key\n", Tmp->Data);
        }
    }
    scanf("%d", &N);
    for( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Delete(BST, X);
    }
    printf("Inorder:"); InorderTraversal(BST); printf("\n");

    return 0;
}

// 遞迴版本的插入演算法
BinTree Insert(BinTree BST, ElementType X)
{
    //pre:X不在樹中
    //post：X被加入到樹中

    if(BST == NULL) //空樹
    {
        Position node = (Position)malloc(sizeof(struct TNode));
        node->Left = NULL;
        node->Right = NULL;
        node->Data = X;

        BST = node;
        return BST;
    }

    if(X == BST->Data)
    {
        return NULL;
    }

    if(X < BST->Data)
    {
        BST->Left = Insert(BST->Left,X);//非常重要的是BST->Left = xx，我開始總是寫成BST = Insert(BST->Left,X);
    }
    else
    {
        BST->Right = Insert(BST->Right,X);
    }
    return BST;
}

BinTree DeleteNode(BinTree BST, Position parent, Position node)
{
    // 進來的node不為空
    // Case 1:葉子結點
    if(node->Left == NULL && node->Right == NULL)
    {
        if(parent == NULL) //根結點
        {   
            BST = NULL;
            free(node);
        }
        else if((parent->Left) && parent->Left->Data == node->Data)//父結點是左手牽著此結點,任何時刻需要判斷左、右指標是否存在才能去索引結點值
        {
            parent->Left = NULL;
            free(node);// 釋放這個葉子結點
        }
        else
        {
            parent->Right = NULL;
            free(node);// 釋放這個葉子結點
        }

    }
    // Case 2:有一個孩子，孩子的爺爺就是parent結點，因為parent是待刪除結點的爸爸，待刪除結點是孩子的爸爸
    else if((node->Left == NULL && node->Right) || (node->Left && node->Right == NULL))
    {
        if(node->Left)//還有個左孩子
        {
            if(parent == NULL) // 待刪除的node是根節點
            {
                BST = node->Left; // 將node的左孩子提升為根即可
            }
            else if((parent->Left) && parent->Left->Data == node->Data)//爺爺的左手牽著爸爸，現在牽著孫子
            {
                parent->Left = node->Left;
            }
            else
            {
                parent->Right = node->Left;
            }
        }
        else //還有右孩子
        {
            if(parent == NULL) // 待刪除的node是根節點
            {
                BST = node->Right; // 將node的左孩子提升為根即可
            }

            else if((parent->Left) && parent->Left->Data == node->Data)//爺爺的左手牽著爸爸，現在牽著孫子
            {
                parent->Left = node->Right;
            }
            else
            {
                parent->Right = node->Right;
            }
        }
    }
    // Case 3: 有兩個孩子呢！
    else
    {
        //首先找到待刪除結點的右子樹的最小結點
        Position rMin = FindMin(node->Right);
        node->Data = rMin->Data; //待刪除結點的值替換為右子樹的最小值
        // 刪除rMin這個結點:rMin結點一定無左孩子
        parent = LocateParent(BST->Right,rMin->Data);
        BST = DeleteNode(BST,parent,rMin);
    }

    return BST;
}


// 函式Delete將X從二叉搜尋樹BST中刪除，並返回結果樹的根結點指標；如果X不在樹中，則列印一行Not Found並返回原樹的根結點指標；
BinTree Delete( BinTree BST, ElementType X)
{
    // 均需要跟蹤父節點
    // 如果刪除的是葉子結點，直接刪就好了:交給爺爺！
    // 如果刪除的結點有左孩子但是沒有右孩子或者有右孩子沒有左孩子，直接讓這個孩子交給它爺爺，它爺爺哪隻手拽著它爸爸，現在就用哪隻手拽它
    // 如果刪除的結點有左孩子還有右孩子，這個需要從要刪除的結點的右子樹中找到一個最小的，用這個值填充待刪除結點的父親，然後刪掉這個最小結點，最小結點是葉子結點
    //
    Position node = Find(BST,X); //找到待刪除的結點，可以是根結點
    if(node == NULL)
    {
        printf("Not Found\n");
        return BST;
    }
    else //X在樹中
    {
        Position parent = LocateParent(BST,X); //找到X的父親結點，如果parent是NULL則，表示刪除的是根結點
        BST = DeleteNode(BST,parent,node);
    }

    return BST;
}
Position LocateParent(BinTree BST, ElementType X) // 找到結點值是X的父結點，返回結點的指標
{
    if(BST->Data == X) //X是根結點
    {
        BST = NULL;
    }
    if(BST)
    {
        if(((BST->Left) && BST->Left->Data == X) || ((BST->Right) && BST->Right->Data == X))
        {
            return BST;
        }
        if(X < BST->Data)
        {
            BST =  LocateParent(BST->Left,X);
        }
        else
        {
            BST = LocateParent(BST->Right,X);
        }
    }
    return BST;
}

// 各種尋找都是遞迴的巧妙利用

// 函式Find在二叉搜尋樹BST中找到X，返回該結點的指標；如果找不到則返回空指標；
Position Find( BinTree BST, ElementType X ) //這裡的BST不會改變原本的根結點表達的值，這是根的副本
{
    //這個在Delete中也要呼叫
    if(BST)
    {
        if(X == BST->Data) //如果元素值相同，返回這個結點指標
        {
            return BST;
        }
        if(X < BST->Data) // 往左子樹尋找
        {
            BST = Find(BST->Left,X);
        }
        else
        {
            BST = Find(BST->Right,X);
        }
    }
    return BST;
}

// 函式FindMin返回二叉搜尋樹BST中最小元結點的指標；
// 思路：一路向左
Position FindMin( BinTree BST )
{
    if(BST == NULL)
    {
        return NULL;
    }
    if(BST->Left == NULL) //這種上來就訪問Left指標，需要小心，因為不一定存在:BST本身不存在時候
    {
        return BST; // 此時BST指代的元素值是最左邊的值
    }

    else
    {
        BST = FindMin(BST->Left);
    }
    return BST;
}

// 函式FindMax返回二叉搜尋樹BST中最大元結點的指標。
// 思路：一路向右
Position FindMax( BinTree BST )
{
    if(BST == NULL)
    {
        return NULL;
    }
    if(BST->Right == NULL)
    {
        return BST;
    }
    else
    {
        BST = FindMax(BST->Right);
    }
    return BST;
}

測試結果是：

這是一次不參考別人程式碼，只用基本的遞迴知識以及對樹形結構的理解寫出來的二叉樹的五種操作的程式碼，其中，另外實現了兩種LocateParent函式用於找到指定數值結點的父結點，DeleteNode是一個輔助函式。不直接寫在Delete中是為了方便遞迴呼叫。

老實說，這段程式碼寫了兩個下午，共用時4個多小時，不加中間零碎時間的思考。寫的我幾乎要放棄，每次一個bug出現，單步跟蹤給了我繼續修正下去的勇氣。

我演算法功底一直停留在紙上談兵階段，真正動手才知道我差在哪裡。

不斷學習。

以上。