《剑指offer》面试题08：二叉树的下一个节点

更多剑指offer习题请点击：《剑指offer》（第二版）题集目录索引

题目：
  给定一棵二叉树和其中的一个结点，如何找出中序遍历顺序的下一个结点？树中的结点除了有两个分别指向左右子结点的指针以外，还有一个指向父结点的指针。

---

解题思路：
  面对这种看似复杂无从下手的题，我们不应急着写代码，而是先捋清除思路，列出可能出现的所有情况，然后再看有哪些情况可以合并，这样可以尽可能的避免出错。

1. 该节点有右子树，那么它的下一个节点就是它右子树的最左节点。例如：2的下一个节点是6。
2. 该节点无右子树：
   
   1. 该节点是它父节点的左节点，那它的下一个节点就是它的父节点。例如：6的下一个节点是5。
   2. 该节点是它父节点的右节点，那就顺着它的父节点往上找，找到某个节点，这个节点是它父节点的左节点，那么这个父节点就是源节点的下一个节点。例如7的下一个节点是1。

  分析到这算是基本确定了，但此时还要考虑到一些特殊情况。

1. 找最后一个节点的下一个节点。
2. 考虑单支树的情况（左单支树、右单支树）。
3. 考虑一棵树只有一个节点的情况。

  考虑完上述所有情况，我们便可以开始写代码了。

---

< function code >

BinaryTreeNode* GetNext(BTNode* pNode) //下一个节点
{
    if (pNode == nullptr)
        return nullptr;

    BTNode* next = nullptr;   //标记源节点的下一个节点
    BTNode* cur = nullptr;    //指向当前节点
    BTNode* parent = nullptr; //指向当前节点的父节点

    if (pNode->_right != nullptr) //该节点的右子树不为空
    {
        next = pNode->_right;
        while (next->_left != nullptr)
        {
            next = next->_left;
        }
    }
    else if (pNode->_parent != nullptr) //该节点的右子树为空
    {
        parent = pNode->_parent;
        cur = pNode;
        while (parent != nullptr && parent->_right == cur) //该节点是父节点的右节点的情况
        {
            cur = parent;
            parent = parent->_parent;
        }
        next = parent; //包含了该节点是父节点的左节点这种情况
    }
    return next; //包含了树只有一个节点这种情况（直接就执行这句）
}

---

< Building trigeminal tree code >

BinaryTreeNode* CreateBinaryTreeNode(int value)
{
    BinaryTreeNode* pNode = new BinaryTreeNode();
    pNode->_data = value;
    pNode->_left = nullptr;
    pNode->_right = nullptr;
    pNode->_parent = nullptr;

    return pNode;
}

void ConnectTreeNodes(BinaryTreeNode* pParent, BinaryTreeNode* pLeft, BinaryTreeNode* pRight)
{
    if (pParent != nullptr)
    {
        pParent->_left = pLeft;
        pParent->_right = pRight;

        if (pLeft != nullptr)
            pLeft->_parent = pParent;
        if (pRight != nullptr)
            pRight->_parent = pParent;
    }
}

void PrintTreeNode(BinaryTreeNode* pNode)
{
    if (pNode != nullptr)
    {
        printf("value of this node is: %d\n", pNode->_data);

        if (pNode->_left != nullptr)
            printf("value of its left child is: %d.\n", pNode->_left->_data);
        else
            printf("left child is null.\n");

        if (pNode->_right != nullptr)
            printf("value of its right child is: %d.\n", pNode->_right->_data);
        else
            printf("right child is null.\n");
    }
    else
    {
        printf("this node is null.\n");
    }

    printf("\n");
}

void PrintTree(BinaryTreeNode* pRoot)
{
    PrintTreeNode(pRoot);

    if (pRoot != nullptr)
    {
        if (pRoot->_left != nullptr)
            PrintTree(pRoot->_left);

        if (pRoot->_right != nullptr)
            PrintTree(pRoot->_right);
    }
}

void DestroyTree(BinaryTreeNode* pRoot)
{
    if (pRoot != nullptr)
    {
        BinaryTreeNode* pLeft = pRoot->_left;
        BinaryTreeNode* pRight = pRoot->_right;

        delete pRoot;
        pRoot = nullptr;

        DestroyTree(pLeft);
        DestroyTree(pRight);
    }
}

---

< test code >

void Test(char* testName, BinaryTreeNode* pNode, BinaryTreeNode* expected)
{
    if (testName != nullptr)
        printf("%-6s begins: ", testName);

    BinaryTreeNode* pNext = GetNext(pNode);
    if (pNext == expected)
        printf("Passed.\n");
    else
        printf("FAILED.\n");
}

//            8
//        6       10
//      5   7   9    11
void Test1_7()
{
    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);
    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);
    BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);
    BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9);
    BinaryTreeNode* pNode11 = CreateBinaryTreeNode(11);

    ConnectTreeNodes(pNode8, pNode6, pNode10);
    ConnectTreeNodes(pNode6, pNode5, pNode7);
    ConnectTreeNodes(pNode10, pNode9, pNode11);

    Test("Test1", pNode8, pNode9);
    Test("Test2", pNode6, pNode7);
    Test("Test3", pNode10, pNode11);
    Test("Test4", pNode5, pNode6);
    Test("Test5", pNode7, pNode8);
    Test("Test6", pNode9, pNode10);
    Test("Test7", pNode11, nullptr);

    DestroyTree(pNode8);
}

//            5
//          4
//        3
//      2
void Test8_11()
{
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);

    ConnectTreeNodes(pNode5, pNode4, nullptr);
    ConnectTreeNodes(pNode4, pNode3, nullptr);
    ConnectTreeNodes(pNode3, pNode2, nullptr);

    Test("Test8", pNode5, nullptr);
    Test("Test9", pNode4, pNode5);
    Test("Test10", pNode3, pNode4);
    Test("Test11", pNode2, pNode3);

    DestroyTree(pNode5);
}

//        2
//         3
//          4
//           5
void Test12_15()
{
    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);
    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);
    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);

    ConnectTreeNodes(pNode2, nullptr, pNode3);
    ConnectTreeNodes(pNode3, nullptr, pNode4);
    ConnectTreeNodes(pNode4, nullptr, pNode5);

    Test("Test12", pNode5, nullptr);
    Test("Test13", pNode4, pNode5);
    Test("Test14", pNode3, pNode4);
    Test("Test15", pNode2, pNode3);

    DestroyTree(pNode2);
}

void Test16()
{
    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);

    Test("Test16", pNode5, nullptr);

    DestroyTree(pNode5);
}

int main()
{
    Test1_7();
    Test8_11();
    Test12_15();
    Test16();

    system("pause");
    return 0;
}

---

< Running result >