自学教程：C++ ConnectTreeNodes函数代码示例

//            8//        6      10//       5 7    9  11void TestA(){    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("TestA0", pNode8, 0, true, -1);    Test("TestA1", pNode8, 1, false, 5);    Test("TestA2", pNode8, 2, false, 6);    Test("TestA3", pNode8, 3, false, 7);    Test("TestA4", pNode8, 4, false, 8);    Test("TestA5", pNode8, 5, false, 9);    Test("TestA6", pNode8, 6, false, 10);    Test("TestA7", pNode8, 7, false, 11);    Test("TestA8", pNode8, 8, true, -1);    DestroyTree(pNode8);    printf("/n/n");}

// 测试二叉树：出叶子结点之外，左右的结点都有且只有一个左子结点//            8//          7   //        6 //      5//    4void Test2(){    printf("=====Test2 starts:=====/n");    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    ConnectTreeNodes(pNode8, pNode7, NULL);    ConnectTreeNodes(pNode7, pNode6, NULL);    ConnectTreeNodes(pNode6, pNode5, NULL);    ConnectTreeNodes(pNode5, pNode4, NULL);    PrintTree(pNode8);    printf("=====Test2: MirrorRecursively=====/n");    MirrorRecursively(pNode8);    PrintTree(pNode8);    printf("=====Test2: MirrorIteratively=====/n");    MirrorIteratively(pNode8);    PrintTree(pNode8);    DestroyTree(pNode8);}

//               5//              ///             4//            ///           3//          ///         2//        ///       1void TestB(){    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);    ConnectTreeNodes(pNode5, pNode4, nullptr);    ConnectTreeNodes(pNode4, pNode3, nullptr);    ConnectTreeNodes(pNode3, pNode2, nullptr);    ConnectTreeNodes(pNode2, pNode1, nullptr);    Test("TestB0", pNode5, 0, true, -1);    Test("TestB1", pNode5, 1, false, 1);    Test("TestB2", pNode5, 2, false, 2);    Test("TestB3", pNode5, 3, false, 3);    Test("TestB4", pNode5, 4, false, 4);    Test("TestB5", pNode5, 5, false, 5);    Test("TestB6", pNode5, 6, true, -1);    DestroyTree(pNode5);    printf("/n/n");}

// ====================测试代码====================// 测试完全二叉树：除了叶子节点，其他节点都有两个子节点//            8//        6      10//       5 7    9  11void Test1(){    printf("=====Test1 starts:=====/n");    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);    PrintTree(pNode8);    printf("=====Test1: MirrorRecursively=====/n");    MirrorRecursively(pNode8);    PrintTree(pNode8);    printf("=====Test1: MirrorIteratively=====/n");    MirrorIteratively(pNode8);    PrintTree(pNode8);    DestroyTree(pNode8);}

// There are branches in trees, and tree B is not a subtree of tree A//                  8                8//              /       /           / ///             8         7         9   2//           /   ///          9     3//               / ///              4   7void Test2(){    BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(7);    BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(9);    BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNodeA6 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNodeA7 = CreateBinaryTreeNode(7);    ConnectTreeNodes(pNodeA1, pNodeA2, pNodeA3);    ConnectTreeNodes(pNodeA2, pNodeA4, pNodeA5);    ConnectTreeNodes(pNodeA5, pNodeA6, pNodeA7);    BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9);    BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(2);    ConnectTreeNodes(pNodeB1, pNodeB2, pNodeB3);    Test("Test2", pNodeA1, pNodeB1, false);    DestroyTree(pNodeA1);    DestroyTree(pNodeB1);}

// ====================测试代码====================//            8//        6      10//       5 7    9  11void Test1(){    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);    printf("====Test1 Begins: ====/n");    printf("Expected Result is:/n");    printf("8 /n");    printf("10 6 /n");    printf("5 7 9 11 /n/n");    printf("Actual Result is: /n");    Print(pNode8);    printf("/n");    DestroyTree(pNode8);}

// 1//  ///   2//    ///     3//      ///       4//        ///         5void TestC(){    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    ConnectTreeNodes(pNode1, nullptr, pNode2);    ConnectTreeNodes(pNode2, nullptr, pNode3);    ConnectTreeNodes(pNode3, nullptr, pNode4);    ConnectTreeNodes(pNode4, nullptr, pNode5);    Test("TestC0", pNode1, 0, true, -1);    Test("TestC1", pNode1, 1, false, 1);    Test("TestC2", pNode1, 2, false, 2);    Test("TestC3", pNode1, 3, false, 3);    Test("TestC4", pNode1, 4, false, 4);    Test("TestC5", pNode1, 5, false, 5);    Test("TestC6", pNode1, 6, true, -1);    DestroyTree(pNode1);    printf("/n/n");}

int main() {	BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8);	BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(8);	BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(7);	BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(9);	BinaryTreeNode* pNodeA5 = CreateBinaryTreeNode(2);	BinaryTreeNode* pNodeA6 = CreateBinaryTreeNode(4);	BinaryTreeNode* pNodeA7 = CreateBinaryTreeNode(7);	ConnectTreeNodes(pNodeA1, pNodeA2, pNodeA3);	ConnectTreeNodes(pNodeA2, pNodeA4, pNodeA5);	ConnectTreeNodes(pNodeA5, pNodeA6, pNodeA7);	BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8);	BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9);	BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(2);	ConnectTreeNodes(pNodeB1, pNodeB2, pNodeB3);	printf("%d/n",HasSubtreeCore(pNodeA1, pNodeB1));		return 0;}

//        100//        ///       50   //         ///         150void Test_32_2_6(){	BinaryTreeNode* pNode100 = CreateBinaryTreeNode(100);	BinaryTreeNode* pNode50 = CreateBinaryTreeNode(50);	BinaryTreeNode* pNode150 = CreateBinaryTreeNode(150);	ConnectTreeNodes(pNode100, pNode50, nullptr);	ConnectTreeNodes(pNode50, nullptr, pNode150);	Test_32_2("Test_32_2_6", pNode100);	DestroyTree(pNode100);}

// Tree A is emptyvoid Test7(){    BinaryTreeNode* pNodeB1 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNodeB2 = CreateBinaryTreeNode(9);    BinaryTreeNode* pNodeB3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNodeB4 = CreateBinaryTreeNode(2);    ConnectTreeNodes(pNodeB1, NULL, pNodeB2);    ConnectTreeNodes(pNodeB2, pNodeB3, pNodeB4);    Test("Test7", NULL, pNodeB1, false);    DestroyTree(pNodeB1);}

// Tree B is emptyvoid Test8(){    BinaryTreeNode* pNodeA1 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNodeA2 = CreateBinaryTreeNode(9);    BinaryTreeNode* pNodeA3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNodeA4 = CreateBinaryTreeNode(2);    ConnectTreeNodes(pNodeA1, NULL, pNodeA2);    ConnectTreeNodes(pNodeA2, pNodeA3, pNodeA4);    Test("Test8", pNodeA1, NULL, false);    DestroyTree(pNodeA1);}

//            5//          4//        3//      2void Test_32_2_2(){	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_32_2("Test_32_2_2", pNode5);	DestroyTree(pNode5);}

//            10//         /      ///        5        12//       //        //      4  7     // 没有路径上的结点和为15void Test2(){    BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode12 = CreateBinaryTreeNode(12);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);    ConnectTreeNodes(pNode10, pNode5, pNode12);    ConnectTreeNodes(pNode5, pNode4, pNode7);    printf("No paths should be found in Test2./n");    Test("Test2", pNode10, 15);    DestroyTree(pNode10);}

//            11//        6      16//       5 7       9void Test2(){    BinaryTreeNode* pNode11 = CreateBinaryTreeNode(11);    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode16 = CreateBinaryTreeNode(16);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);    BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9);    ConnectTreeNodes(pNode11, pNode6, pNode16);    ConnectTreeNodes(pNode6, pNode5, pNode7);    ConnectTreeNodes(pNode16, NULL, pNode9);    Test("Test2", pNode11, 3);    DestroyTree(pNode11);}

// 1//  ///   2//    ///     3//      ///       4//        ///         5void Test5(){    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    ConnectTreeNodes(pNode1, NULL, pNode2);    ConnectTreeNodes(pNode2, NULL, pNode3);    ConnectTreeNodes(pNode3, NULL, pNode4);    ConnectTreeNodes(pNode4, NULL, pNode5);    Test("Test5", pNode1, false);    DestroyTree(pNode1);}

//            12//        6      9//       5     8   10  void Test3(){    BinaryTreeNode* pNode12 = CreateBinaryTreeNode(12);    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10);    ConnectTreeNodes(pNode12, pNode6, pNode9);    ConnectTreeNodes(pNode6, pNode5, NULL);    ConnectTreeNodes(pNode9, pNode8, pNode10);    Test("Test3", pNode12, 3);    DestroyTree(pNode12);}

//            8//        6      6//       5 7    7void Test3(){    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNode61 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode62 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode51 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode71 = CreateBinaryTreeNode(7);    BinaryTreeNode* pNode72 = CreateBinaryTreeNode(7);    ConnectTreeNodes(pNode8, pNode61, pNode62);    ConnectTreeNodes(pNode61, pNode51, pNode71);    ConnectTreeNodes(pNode62, pNode72, NULL);    Test("Test3", pNode8, false);    DestroyTree(pNode8);}

// 不是平衡二叉树//             1//         /      ///        2        3//       //         //      4  5        //        ///       6void Test3(){    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);    ConnectTreeNodes(pNode1, pNode2, pNode3);    ConnectTreeNodes(pNode2, pNode4, pNode5);    ConnectTreeNodes(pNode5, pNode6, NULL);    Test("Test3", pNode1, false);    DestroyTree(pNode1);}

//               5//              ///             4//            ///           3//          ///         2//        ///       1void Test2(){    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);    ConnectTreeNodes(pNode5, pNode4, NULL);    ConnectTreeNodes(pNode4, pNode3, NULL);    ConnectTreeNodes(pNode3, pNode2, NULL);    ConnectTreeNodes(pNode2, pNode1, NULL);    Test("Test2", pNode5);    DestroyList(pNode1);}

// 1//  ///   2//    ///     3//      ///       4//        ///         5// 没有路径上面的结点和为16void Test4(){    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    ConnectTreeNodes(pNode1, NULL, pNode2);    ConnectTreeNodes(pNode2, NULL, pNode3);    ConnectTreeNodes(pNode3, NULL, pNode4);    ConnectTreeNodes(pNode4, NULL, pNode5);    printf("No paths should be found in Test4./n");    Test("Test4", pNode1, 16);    DestroyTree(pNode1);}

//            5//          4//        3//      2void Test8_11(){    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);    ConnectTreeNodes(pNode5, pNode4, NULL);    ConnectTreeNodes(pNode4, pNode3, NULL);    ConnectTreeNodes(pNode3, pNode2, NULL);    Test("Test8", pNode5, NULL);    Test("Test9", pNode4, pNode5);    Test("Test10", pNode3, pNode4);    Test("Test11", pNode2, pNode3);    DestroyTree(pNode5);}

//        2//         3//          4//           5void Test12_15(){    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    ConnectTreeNodes(pNode2, NULL, pNode3);    ConnectTreeNodes(pNode3, NULL, pNode4);    ConnectTreeNodes(pNode4, NULL, pNode5);    Test("Test12", pNode5, NULL);    Test("Test13", pNode4, pNode5);    Test("Test14", pNode3, pNode4);    Test("Test15", pNode2, pNode3);    DestroyTree(pNode2);}

//               5//              ///             4//            ///           3//          ///         2//        ///       1// 有一条路径上面的结点和为15void Test3(){    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);    ConnectTreeNodes(pNode5, pNode4, NULL);    ConnectTreeNodes(pNode4, pNode3, NULL);    ConnectTreeNodes(pNode3, pNode2, NULL);    ConnectTreeNodes(pNode2, pNode1, NULL);    printf("One path should be found in Test3./n");    Test("Test3", pNode5, 15);    DestroyTree(pNode5);}

//            8//        10      6//      11  9   7   5void Test6(){    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10);    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode11 = CreateBinaryTreeNode(11);    BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9);    BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    ConnectTreeNodes(pNode8, pNode10, pNode6);    ConnectTreeNodes(pNode10, pNode11, pNode9);    ConnectTreeNodes(pNode6, pNode7, pNode5);    Test("Test6", pNode8, 1);    DestroyTree(pNode8);}

//            10//         /      ///        6        14//       //        ////      4  8     12  16void Test1(){88    BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10);    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode14 = CreateBinaryTreeNode(14);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNode12 = CreateBinaryTreeNode(12);    BinaryTreeNode* pNode16 = CreateBinaryTreeNode(16);    ConnectTreeNodes(pNode10, pNode6, pNode14);    ConnectTreeNodes(pNode6, pNode4, pNode8);    ConnectTreeNodes(pNode14, pNode12, pNode16);    Test("Test1", pNode10);    DestroyList(pNode4);}

// 1//  ///   2//    ///     3//      ///       4//        ///         5// 没有路径上面的结点和为16void Test_34_4(){	BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);	BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);	BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);	BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);	BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);	ConnectTreeNodes(pNode1, nullptr, pNode2);	ConnectTreeNodes(pNode2, nullptr, pNode3);	ConnectTreeNodes(pNode3, nullptr, pNode4);	ConnectTreeNodes(pNode4, nullptr, pNode5);	printf("No paths should be found in Test_34_4./n");	Test_34("Test_34_4", pNode1, 16);	DestroyTree(pNode1);}

void Test_32_2_1(){	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_32_2("Test_32_2_1", pNode8);	DestroyTree(pNode8);}

//            8//        6      9//       5 7    7 5void Test2(){    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNode61 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9);    BinaryTreeNode* pNode51 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode71 = CreateBinaryTreeNode(7);    BinaryTreeNode* pNode72 = CreateBinaryTreeNode(7);    BinaryTreeNode* pNode52 = CreateBinaryTreeNode(5);    ConnectTreeNodes(pNode8, pNode61, pNode9);    ConnectTreeNodes(pNode61, pNode51, pNode71);    ConnectTreeNodes(pNode9, pNode72, pNode52);    Test("Test2", pNode8, false);    DestroyTree(pNode8);}

// 完全二叉树//             1//         /      ///        2        3//       //       / ///      4  5     6   7void Test1(){    BinaryTreeNode* pNode1 = CreateBinaryTreeNode(1);    BinaryTreeNode* pNode2 = CreateBinaryTreeNode(2);    BinaryTreeNode* pNode3 = CreateBinaryTreeNode(3);    BinaryTreeNode* pNode4 = CreateBinaryTreeNode(4);    BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);    ConnectTreeNodes(pNode1, pNode2, pNode3);    ConnectTreeNodes(pNode2, pNode4, pNode5);    ConnectTreeNodes(pNode3, pNode6, pNode7);    Test("Test1", pNode1, true);    DestroyTree(pNode1);}

//            8//        6      6//       5 7    7 5void Test1(){    BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);    BinaryTreeNode* pNode61 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode62 = CreateBinaryTreeNode(6);    BinaryTreeNode* pNode51 = CreateBinaryTreeNode(5);    BinaryTreeNode* pNode71 = CreateBinaryTreeNode(7);    BinaryTreeNode* pNode72 = CreateBinaryTreeNode(7);    BinaryTreeNode* pNode52 = CreateBinaryTreeNode(5);    ConnectTreeNodes(pNode8, pNode61, pNode62);    ConnectTreeNodes(pNode61, pNode51, pNode71);    ConnectTreeNodes(pNode62, pNode72, pNode52);    Test("Test1", pNode8, true);    DestroyTree(pNode8);}