排序二叉树系列操作

前些天，听一位找到工作的大神谈起面试题，突然说起一道关于排序二叉树的题，题目要求找出比给定值小，但是最接近给定值的节点。

身为小白的我，看到这个题还是比较迷茫的，回来之后好好思考了一下，经过查资料，发现其实就是问查找前驱和后驱的问题。

下面是我自己实现的查找二叉树的系列操作，分享给大家，其中关于前驱后驱的问题，主要是参考算法导论的做法，现在网上的博客似乎这个讲的不是很清楚，所以具体的大家可以看算法导论相关部分。

 

#include <stdio.h>

typedef struct node
{
    int m_nValue;
    struct node *m_pLeft;
    struct node *m_pRight;
    struct node *m_pParent;
}BinarySearchTreeNode;

void InsertKey(BinarySearchTreeNode **pRoot, int nKey)
{
    BinarySearchTreeNode *pNode = new BinarySearchTreeNode();
    pNode->m_nValue = nKey;
    pNode->m_pLeft = NULL;
    pNode->m_pRight = NULL;
    pNode->m_pParent = NULL;

    if(*pRoot == NULL)
    {
        *pRoot = pNode;
        return;
    }

    if((*pRoot)->m_pLeft == NULL && (*pRoot)->m_nValue > nKey)
    {
        pNode->m_pParent = (*pRoot);
        (*pRoot)->m_pLeft = pNode;
        return;
    }

    if((*pRoot)->m_pRight == NULL && (*pRoot)->m_nValue < nKey)
    {
        pNode->m_pParent = (*pRoot);
        (*pRoot)->m_pRight = pNode;
        return;
    }

    if(nKey > (*pRoot)->m_nValue)
        InsertKey(&(*pRoot)->m_pRight, nKey);
    
    if(nKey < (*pRoot)->m_nValue)
        InsertKey(&(*pRoot)->m_pLeft, nKey);
}

BinarySearchTreeNode *Search(BinarySearchTreeNode *pRoot, int nValue)
{
    if(pRoot == NULL)
        return NULL;

    if(nValue == pRoot->m_nValue)
        return pRoot;
    else if(nValue > pRoot->m_nValue)
        return Search(pRoot->m_pRight, nValue);
    else
        return Search(pRoot->m_pLeft, nValue);
}

BinarySearchTreeNode *SearchMin(BinarySearchTreeNode *pRoot)
{
    if(pRoot == NULL)
        return NULL;

    if(pRoot->m_pLeft == NULL)
        return pRoot;
    else
        return SearchMin(pRoot->m_pLeft);
}

BinarySearchTreeNode *SearchMax(BinarySearchTreeNode *pRoot)
{
    if(pRoot == NULL)
        return NULL;

    if(pRoot->m_pRight == NULL)
        return pRoot;
    else
        return SearchMax(pRoot->m_pRight);
}

BinarySearchTreeNode *SearchPredecessor(BinarySearchTreeNode *pNode)
{
    if(pNode == NULL)
        return NULL;

    if(pNode->m_pLeft != NULL)
        return SearchMax(pNode->m_pLeft);
    else
    {
        BinarySearchTreeNode *pTemp = pNode->m_pParent;
        while(pTemp != NULL && pTemp->m_pLeft == pNode)
        {
            pNode = pTemp;
            pTemp = pNode->m_pParent;
        }
        return pTemp;
    }
}

BinarySearchTreeNode *SearchSuccessor(BinarySearchTreeNode *pNode)
{
    if(pNode == NULL)
        return NULL;

    if(pNode->m_pRight != NULL)
        return SearchMin(pNode->m_pRight);
    else
    {
        BinarySearchTreeNode *pTemp = pNode->m_pParent;
        while(pTemp != NULL && pTemp->m_pRight == pNode)
        {
            pNode = pTemp;
            pTemp = pNode->m_pParent;
        }
        return pTemp;
    }
}

void CreateBinarySearchTree(BinarySearchTreeNode **pRoot, int *pKeyArray, int nLength)
{
    for(int i = 0; i < nLength; i++)
        InsertKey(&(*pRoot), pKeyArray[i]);
}

int DeleteNode(BinarySearchTreeNode **pRoot, int nKey)
{
    BinarySearchTreeNode *pNode = Search((*pRoot), nKey);
    if(pNode == NULL)
        return 0;

    // 1. 删除节点是页节点(直接删除节点)
    if(pNode->m_pLeft == NULL && pNode->m_pRight == NULL)
    {
        if(pNode->m_pParent->m_pLeft == pNode)
        {
            pNode->m_pParent->m_pLeft = NULL;
            delete pNode;
        }
        else
        {
            pNode->m_pParent->m_pRight = NULL;
            delete pNode;
        }
    }
    // 2. 删除节点只有一个子节点
    else if(pNode->m_pLeft != NULL && pNode->m_pRight == NULL)
    {
        pNode->m_pLeft->m_pParent = pNode->m_pParent;
        
        // 如果待删节点为根节点
        if(pNode->m_pParent == NULL)
            *pRoot = pNode->m_pLeft;

        else if(pNode->m_pParent->m_pLeft == pNode)
            pNode->m_pParent->m_pLeft = pNode->m_pLeft;
        else
            pNode->m_pParent->m_pRight = pNode->m_pLeft;

        delete pNode;
    }
    // 2. 删除节点只有一个子节点
    else if(pNode->m_pRight != NULL && pNode->m_pLeft == NULL)
    {
        pNode->m_pRight->m_pParent = pNode->m_pParent;

        if(pNode->m_pParent == NULL)
            *pRoot = pNode->m_pRight;
        else if(pNode->m_pParent->m_pLeft == pNode)
            pNode->m_pParent->m_pLeft = pNode->m_pRight;
        else
            pNode->m_pParent->m_pRight = pNode->m_pRight;
    }
    // 3. 删除节点有左右两个子节点
    else
    {
        BinarySearchTreeNode *pSuccessor = SearchSuccessor(pNode);
        int nTempValue = pSuccessor->m_nValue;
        DeleteNode(pRoot, nTempValue);
        pNode->m_nValue = nTempValue;
    }
    return 1;
}

int main()
{
    int data[6] = {5, 8, 2, 0, 1, 7};

    BinarySearchTreeNode *pRoot = NULL;

    CreateBinarySearchTree(&pRoot, data, 6);

    printf("Max: %d\n", SearchMax(pRoot)->m_nValue);
    printf("Min: %d\n", SearchMin(pRoot)->m_nValue);

    printf("Root: %d\n", pRoot->m_nValue);
    printf("Root Predecessor: %d\n", SearchPredecessor(pRoot)->m_nValue);
    printf("Root Successor: %d\n", SearchSuccessor(pRoot)->m_nValue);
    printf("Search: %d\n", Search(pRoot, 7)->m_nValue);
    printf("Search Node Predecessor: %d\n", SearchPredecessor(Search(pRoot, 7))->m_nValue);
    printf("Search Node Successor: %d\n", SearchSuccessor(Search(pRoot, 7))->m_nValue);
    int isDelete = DeleteNode(&pRoot, 8);
    printf("Delete 8: %d\n", isDelete);
    return 0;
}