每日一道算法题6——判断整数序列是不是二元查找树的后序遍历结果

题目:输入一个整数数组,判断该数组是不是某二元查找树的后序遍历的结果。如果是返回true,否则返回false。 例如输入5、7、6、9、11、10、8,由于这一整数序列是如下树的后序遍历结果:
8
/ \
6 10
/ \ / \
5 7 9 11
因此返回true。
如果输入7、4、6、5,没有哪棵树的后序遍历的结果是这个序列,因此返回false。
分析:这是一道trilogy的笔试题,主要考查对二元查找树的理解。二元查找树的中序遍历为有序序列,且每个左子结点值都比根结点值小,每个右子结点值逗比根结点值大。

在后序遍历得到的序列中,最后一个元素为树的根结点。从头开始扫描这个序列,比根结点小的元素都应该位于序列的左半部分;从第一个大于跟结点开始到跟结点前面的一个元素为止,所有元素都应该大于跟结点,因为这部分元素对应的是树的右子树(制药找到一个元素比根结点元素大,从这个元素开始到结束都为根结点的右子结点)。根据这样的划分,把序列划分为左右两部分,我们递归地确认序列的左、右两部分是不是都是二元查找树。

参考答案:

#include <iostream>

using namespace std;


bool verifySquenceOfBST(int squence[], int length)
{
    if (squence == NULL || length <= 0)
        return false;
    // 加入是后序遍历,则序列最后一个元素为二元查找树的根结点 
    int root = squence[length - 1];

    int i = 0;
    //寻找第一个比根结点值大的结点
    //从这个结点起到最后一个结点(根结点)之前的结点为二元查找树的右子序列
    for (; i < length - 1; ++i)
    {
        if (squence[i] > root)
            break;
    }

    // 判断从找到的这个结点起(至根结点之前一个结点结束)的值是否都比根结点小(二元查找树性质)
    //不是则直接返回false
    int j = i;
    for (; j < length - 1; ++j)
    {
        if (squence[j] < root)
            return false;
    }

    // 递归判断左子节点是否满足二元查找树
    bool left = true;
    if (i > 0)
        left = verifySquenceOfBST(squence, i);

    // 递归判断右子节点是否满足二元查找树   
    bool right = true;
    if (i < length - 1)
        right = verifySquenceOfBST(squence + i, length - i - 1);

    return (left && right);
}

int main(int argc, char *argv[])
{

    int buf[] = { 5, 7, 6, 9, 11, 10, 8 };

    cout << (verifySquenceOfBST(buf, 7) ? "是二元查找树的后序遍历" : "不是二元查找树的后序遍历") << endl;

    getchar();
    return 0;
}
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 根据给定的二叉后序遍历和中序遍历结果,可以通过以下方法输出该的先序遍历结果: 1. 后序遍历中最后一个元素为根节点。 2. 根据根节点在中序遍历中的位置,将中序遍历结果分为左子和右子。 3. 递归处理左子和右子,对于左子的先序遍历结果放在根节点前面,对于右子的先序遍历结果放在根节点后面。 算法时间复杂度为 O(n) ### 回答2: 二叉是一种常见的数据结构,其遍历方式有前序、中序和后序三种。前序遍历是指先输出根节点,再遍历左子和右子;中序遍历是指先遍历左子,然后输出根节点,最后遍历右子后序遍历是指先遍历左子和右子,最后输出根节点。在已知二叉的中序遍历后序遍历的情况下,我们可以通过以下步骤求出该的先序遍历: 1. 后序遍历的最后一个节点一定是根节点,因此可以将后序遍历的最后一个节点保存在一个变量中。 2. 在中序遍历中找到根节点的位置,将中序遍历分成左子和右子两部分。 3. 根据中序遍历中左右子的长度,将后序遍历分成左子和右子两部分。 4. 递归地处理左子和右子,分别求出其先序遍历。 5. 将当前节点的值添加到先序遍历的结果中。 6. 返回先序遍历的结果。 以下是一个具体的实现代码,假设输入的中序遍历后序遍历分别保存在inorder和postorder两个数组中: ```python def build_tree(inorder, postorder): if not inorder: return [] root_val = postorder.pop() root_index = inorder.index(root_val) left_inorder = inorder[:root_index] right_inorder = inorder[root_index+1:] left_postorder = postorder[:len(left_inorder)] right_postorder = postorder[len(left_inorder):] left_tree = build_tree(left_inorder, left_postorder) right_tree = build_tree(right_inorder, right_postorder) return [root_val] + left_tree + right_tree inorder = [9, 3, 15, 20, 7] postorder = [9, 15, 7, 20, 3] preorder = build_tree(inorder, postorder) print(preorder) # [3, 9, 20, 15, 7] ``` 该代码中的build_tree函数接受两个参数,分别是中序遍历后序遍历的数组。函数首先检查中序遍历是否为空,如果为空,则返回一个空数组。否则,函数从后序遍历的最后一个元素中获取根节点的值,并找到该根节点在中序遍历中的位置。根据中序遍历中左右子的长度,函数将后序遍历分成左子和右子两部分。递归地处理左子和右子,分别求出其先序遍历。最后,将当前节点的值添加到先序遍历的结果中,并返回先序遍历的结果。 在本例中,给定的中序遍历后序遍历分别是[9, 3, 15, 20, 7]和[9, 15, 7, 20, 3]。根据上述算法,可以求出该的先序遍历是[3, 9, 20, 15, 7]。 ### 回答3: 二叉遍历是指按照一定的顺序遍历二叉的所有节点。常见的遍历方式有三种,分别是前序遍历、中序遍历后序遍历。 前序遍历遍历顺序为根节点、左子、右子,先访问根节点、再遍历左子、最后遍历右子。 中序遍历遍历顺序为左子、根节点、右子,先访问左子、再访问根节点、最后访问右子后序遍历遍历顺序为左子、右子、根节点,先访问左子、再访问右子、最后访问根节点。 给定一棵二叉后序遍历和中序遍历结果,我们需要输出该的先序遍历结果。可以通过以下步骤来实现: 1. 根据后序遍历可以得到二叉的根节点,将二叉按照根节点左右分为两部分。 2. 根据中序遍历分别得到左子和右子。 3. 递归对左子和右子进行步骤1~2,得到左子的根节点和右子的根节点。 4. 根据前序遍历的顺序,先输出根节点,再输出左子的节点,最后输出右子的节点。 具体实现过程如下: 首先,我们需要定义一个二叉节点的结构体,包含节点值、左子节点指针、右子节点指针。 struct TreeNode { int val; TreeNode* left; TreeNode* right; } 根据中序遍历后序遍历结果,可以得到二叉的根节点。 TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) { if (inorder.empty() || postorder.empty()) { return nullptr; } // 后序遍历的最后一个节点为根节点 int rootVal = postorder.back(); TreeNode* root = new TreeNode(rootVal); // 在中序遍历中寻找根节点的位置 auto rootIndex = find(inorder.begin(), inorder.end(), rootVal) - inorder.begin(); // 分别得到左子和右子的中序遍历后序遍历 vector<int> leftInorder(inorder.begin(), inorder.begin() + rootIndex); vector<int> rightInorder(inorder.begin() + rootIndex + 1, inorder.end()); vector<int> leftPostorder(postorder.begin(), postorder.begin() + rootIndex); vector<int> rightPostorder(postorder.begin() + rootIndex, postorder.end() - 1); // 递归构建左右子 root->left = buildTree(leftInorder, leftPostorder); root->right = buildTree(rightInorder, rightPostorder); return root; } 接下来,我们可以通过前序遍历输出二叉的所有节点值。 void preOrder(TreeNode* root, vector<int>& result) { if (root == nullptr) { return; } result.push_back(root->val); preOrder(root->left, result); preOrder(root->right, result); } int main() { vector<int> inorder = {9, 3, 15, 20, 7}; vector<int> postorder = {9, 15, 7, 20, 3}; TreeNode* root = buildTree(inorder, postorder); vector<int> result; // 输出前序遍历结果 preOrder(root, result); for (auto num : result) { cout << num << " "; } return 0; } 综上所述,根据后序遍历和中序遍历结果,可以通过递归构建二叉,并输出先序遍历结果。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值