排序二叉树的建立，查询与删除

因为排序二叉树的有序性，建立与查询都不是很难，唯一的难点是删除结点的操作，删除节点且要保证该树仍为二叉树且仍满足有序的性质

二叉树的删除操作主要有三种情况：

• 所删除的节点是叶子节点，这样就可以先遍历这个树，然后找到需要删除的节点，把它free掉就好
• 所删除的节点只有一个左子结点，或者只有一个右子结点，则把该节点的子结点变为它父结点的子结点 ，然后free掉这个结点
• 就是最麻烦的一类，删除的结点既有左子结点又有右子结点，这时，我们的处理方式是，用左子树的最右结点，就是值最大那个叶节点的值覆盖掉要删除的结点，并free掉那个叶子节是

具体实现代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <queue>
#include <vector>
#include <cmath>
#include <iomanip>
#include <malloc.h>

#define INF 0x3f3f3f3f
#define FRER() freopen("in.txt", "r", stdin)
#define FREW() freopen("out.txt", "w", stdout)

using namespace std;

typedef struct node {
    int nValue;
    struct node *pLeft;
    struct node *pRight;
}BinaryTree;

void InsertNode(BinaryTree **pTree, int nNum) {
    BinaryTree *pTemp = NULL;
    pTemp = (BinaryTree*)malloc(sizeof(BinaryTree));
    pTemp->nValue = nNum;
    pTemp->pLeft = NULL;
    pTemp->pRight = NULL;

    //空树
    if(*pTree == NULL) {
        *pTree = pTemp;
        return ;
    }

    //非空树
    BinaryTree *pNode = *pTree;
    while(1) {
        if(nNum > pNode->nValue) {
            //去右侧
            if(pNode->pRight == NULL) {
                pNode->pRight = pTemp;
                return;
            }

            //向右走
            pNode = pNode->pRight;
        }
        else if(nNum < pNode->nValue) {
            //去左侧
            if(pNode->pLeft == NULL) {
                pNode->pLeft = pTemp;
                return ;
            }

            //向左走
            pNode = pNode->pLeft;
        }
        //相等
        else {
            free(pTemp);
            pTemp = NULL;
            return ;
        }
    }
}

void CreateBST(int arr[], int nLength, BinaryTree **pTree) {
    if(arr == NULL || nLength <= 0)
        return ;
    for(int i = 0; i < nLength; ++i) {
        InsertNode(pTree, arr[i]);
    }
}

void BiTreeTreavelsal(BinaryTree *pNode) {
    if(pNode == NULL) return ;
    printf("%d ", pNode->nValue);
    BiTreeTreavelsal(pNode->pLeft);
    BiTreeTreavelsal(pNode->pRight);
}

void Search(BinaryTree *pTree, int nNum, BinaryTree **pDel, BinaryTree **pFather) {
    while(pTree != NULL) {
        if(pTree->nValue == nNum) {
            *pDel = pTree;
            return ;
        }
        else if(pTree->nValue > nNum) {
            *pFather = pTree;
            pTree = pTree->pLeft;
        }
        else {
            *pFather = pTree;
            pTree = pTree->pRight;
        }
    }
}

void DelNode(BinaryTree **pTree, int nNum) {
    if(*pTree == NULL) return ;
    
    //查找
    BinaryTree *pDel = NULL;
    BinaryTree *pFather = NULL;

    Search(*pTree, nNum, &pDel, &pFather);

    //二叉树上没有该点
    if(pDel == NULL) return ;

    BinaryTree *pMark = NULL;
    if(pDel->pLeft != NULL && pDel->pRight != NULL) {
        
        //找左的最右
        pMark = pDel;

        //向左走一步
        pFather = pDel;
        pDel = pDel->pLeft;
        
        while(pDel->pRight != NULL) {
            pFather = pDel;
            pDel = pDel->pRight;
        }

        //值覆盖
        pMark->nValue = pDel->nValue;
    }

    //被删除的结点是根结点
    if(pFather == NULL) {
        *pTree = pDel->pLeft ? pDel->pLeft : pDel->pRight;
        free(pDel);
        pDel = NULL;
        return ;
    }

    //被删除的结点不是根结点
    if(pDel == pFather->pLeft) {
        pFather->pLeft = pDel->pLeft ? pDel->pLeft : pDel->pRight;
        free(pDel);
        pDel = NULL;
        return ;
    }
    else {
        pFather->pRight = pDel->pLeft ? pDel->pLeft : pDel->pRight;
        free(pDel);
        pDel = NULL;
        return ;
    }
}

int main()
{
    int arr[] = {10,38,2,100,80,15,1,8,16};
    BinaryTree *pTree = NULL;
    CreateBST(arr,sizeof(arr)/sizeof(arr[0]),&pTree);
    BiTreeTreavelsal(pTree);
    printf("
");
    DelNode(&pTree,10);
    BiTreeTreavelsal(pTree);
    return 0;
}