oral_quiz->#根据先根、中根，建树#

#include "stdafx.h"
#include "Utilities/BinaryTree.h"
#include <exception>

BinaryTreeNode* ConstructCore(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder);

BinaryTreeNode* Construct(int* preorder, int* inorder, int length) {
	if(preorder == NULL || inorder == NULL || length <= 0) return NULL;
	return ConstructCore(preorder, preorder+length-1, inorder, inorder+length-1);
}

BinaryTreeNode* ConstructCore(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder) {
	int rootValue = *startPreorder;
	BinaryTreeNode* root = new BinaryTreeNode();
	root->m_nValue = rootValue;
	root->m_pLeft = root->m_pRight = NULL;

	//left only one node
	if((startPreorder == endPreorder) && (startInorder == endInorder)) {
		if(*startPreorder == *startInorder)
			return root;
		else
			throw std::exception();
	}

	//find root node in inorder
	int* rootInorder = startInorder;
	while(rootInorder <= endInorder && *rootInorder != rootValue)
		++rootInorder;

	if(rootInorder == endInorder && *rootInorder != rootValue) {
		throw std::exception();
	}

	int leftLength = rootInorder - startInorder;
	int* leftEndPreorder = startPreorder + leftLength;

	//left subtree
	if(leftLength > 0) {
		root->m_pLeft = ConstructCore(startPreorder+1, leftEndPreorder, startInorder, rootInorder-1);
	}

	//right subtree
	if(0 < endInorder - rootInorder) {
		root->m_pRight = ConstructCore(leftEndPreorder+1, endPreorder, rootInorder+1, endInorder);
	}

	return root;
}

//=====================================Test====================================
void Test(const char* testName, int* preorder, int* inorder, int length) {
	if(testName != NULL) printf("%s begins:\n", testName);

	printf("The preorder sequence is: ");
	for(int i=0; i<length; ++i) {
		printf("%d ", preorder[i]);
	}
	printf("\n");

	printf("The inorder sequence is: ");
	for(int i=0; i<length; ++i) {
		printf("%d ", inorder[i]);
	}
	printf("\n");

	try {
		BinaryTreeNode* root = Construct(preorder, inorder, length);
		PrintTree(root);

		DestroyTree(root);
	} catch(std::exception& e) {
		printf("Invalid Input.\n");
	}
}

//normal binary tree, correct input
//			1
//		   /  \
//		  2    3
//		 /	  / \
//		4    5   6
//	     \      /
//	      7    8
void Test1() {
	const int length = 8;
	int preorder[length] = {1,2,4,7,3,5,6,8};
	int inorder[length] = {4,7,2,1,5,3,8,6};
	Test("Test1", preorder, inorder, length);
}

//no right child
//            1
//           /
//          2
//         /
//        3
//       /
//      4
//     /
//    5
void Test2() {
	const int length = 5;
	int preorder[length] = {1,2,3,4,5};
	int inorder[length] = {5,4,3,2,1};
	Test("Test2", preorder, inorder, length);
}

// no left child
//            1
//             \
//              2
//               \
//                3
//                 \
//                  4
//                   \
//                    5
void Test3()
{
    const int length = 5;
    int preorder[length] = {1, 2, 3, 4, 5};
    int inorder[length] = {1, 2, 3, 4, 5};

    Test("Test3", preorder, inorder, length);
}

// only one root node
void Test4()
{
    const int length = 1;
    int preorder[length] = {1};
    int inorder[length] = {1};

    Test("Test4", preorder, inorder, length);
}

// 完全二叉树
//              1
//           /     \
//          2       3
//         / \     / \
//        4   5   6   7
void Test5()
{
    const int length = 7;
    int preorder[length] = {1, 2, 4, 5, 3, 6, 7};
    int inorder[length] = {4, 2, 5, 1, 6, 3, 7};

    Test("Test5", preorder, inorder, length);
}

// input NULL pointer
void Test6()
{
    Test("Test6", NULL, NULL, 0);
}

// unmatched input
void Test7()
{
    const int length = 7;
    int preorder[length] = {1, 2, 4, 5, 3, 6, 7};
    int inorder[length] = {4, 2, 8, 1, 6, 3, 7};

    Test("Test7: for unmatched input", preorder, inorder, length);
}

int main(int argc, char* argv[]) {
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    Test7();
	return 0;
}