遍历重构

1. 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
2. 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。
3. 把一个有序整数数组放到一棵二叉树中，要求树的高度最小。

1、思路：

　　前序遍历的第一个是根结点，在中序遍历中找到该结点，则该结点左侧是左子树的范围，右侧是右子树的范围。由该范围再去前序遍历数组中圈定同样个数的左右子树。同理递归处理左右子树。

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[0];
    BinaryTreeNode* root = new BinaryTreeNode();
    root->m_nValue = rootValue;
    root->m_pLeft = root->m_pRight = NULL;

    if(startPreorder == endPreorder)
    {
        if(startInorder == endInorder && *startPreorder == *startInorder)
            return root;
        else
            throw std::exception("Invalid input.");
    }

    // 在中序遍历中找到根结点的值
    int* rootInorder = startInorder;
    while(rootInorder <= endInorder && *rootInorder != rootValue)
        ++ rootInorder;

    if(rootInorder == endInorder && *rootInorder != rootValue)
        throw std::exception("Invalid input.");

    int leftLength = rootInorder - startInorder;
    int* leftPreorderEnd = startPreorder + leftLength;
    if(leftLength > 0)
    {
        // 构建左子树
        root->m_pLeft = ConstructCore(startPreorder + 1, leftPreorderEnd, 
            startInorder, rootInorder - 1);
    }
    if(leftLength < endPreorder - startPreorder)
    {
        // 构建右子树
        root->m_pRight = ConstructCore(leftPreorderEnd + 1, endPreorder,
            rootInorder + 1, endInorder);
    }

    return root;
}

 

2、思路：

　　二叉搜索树的特点是左子树的所有元素比根节点小，右子树的所有元素比根节点大。由根节点找到左右子树的范围，并判断是否负责大小性质。

bool VerifySquenceOfBST(int sequence[], int length)
{
    if(sequence == NULL || length <= 0)
        return false;

    int root = sequence[length - 1];

    // 在二叉搜索树中左子树的结点小于根结点
    int i = 0;
    for(; i < length - 1; ++ i)
    {
        if(sequence[i] > root)
            break;
    }

    // 在二叉搜索树中右子树的结点大于根结点
    int j = i;
    for(; j < length - 1; ++ j)
    {
        if(sequence[j] < root)
            return false;
    }

    // 判断左子树是不是二叉搜索树
    bool left = true;
    if(i > 0)
        left = VerifySquenceOfBST(sequence, i);

    // 判断右子树是不是二叉搜索树
    bool right = true;
    if(i < length - 1)
        right = VerifySquenceOfBST(sequence + i, length - i - 1);

    return (left && right);
}

 

3、思路：

　　递归对半处理数组，每次取中间节点作为root，左半部分和右半部分分别作为左右孩子。

TreeNode* Array2TreeCore(int data[], int start, int end)
{
    if (start > end) return NULL;
    int mid = (start + end) / 2;
    TreeNode* root = new TreeNode(data[mid]);
    root->left = Array2TreeCore(data, start, mid - 1);
    root->right = Array2TreeCore(data, mid + 1, end);
    return root;
}

TreeNode* Array2Tree(int data[], int len)
{
    if (data == NULL || len < 0) return NULL;
    return Array2TreeCore(data, 0, len - 1);
}