33. 二叉搜索树的后序遍历序列

本文介绍如何判断一个序列是否为二叉搜索树的后序遍历,并利用前序遍历构建二叉搜索树。通过递归方法划分左右子树,实现序列的有效验证及树结构的构建。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

剑指 Offer 33. 二叉搜索树的后序遍历序列

LCR 152. 验证二叉搜索树的后序遍历序列

输入一个整数数组,判断该数组是不是某二叉搜索树后序遍历结果。如果是则返回 true,否则返回 false假设输入的数组的任意两个数字都互不相同

参考以下这颗二叉搜索树:

     5
    / \
   2   6
  / \
 1   3

示例 1:

输入: [1,6,3,2,5]
输出: false

示例 2:

输入: [1,3,2,6,5]
输出: true

提示:

  • 数组长度 <= 1000

解题思路

后序遍历得到的序列中,最后一个数字是树的根节点的值。又由于是二叉搜索树且没有重复数字,故数组中前面的数字可以分为两部分:第一部分是左子树节点的值,它们都比根节点的值小;第二部分是右子树节点的值,它们都比根节点的值大。

由此我们可以这样做:

  1. 找到根节点
  2. 从头遍历当前区间中的值,找到第一个不小于根节点的值,此时,该值左边的数都小于根节点是根节点的左子树,剩下的就应该是右子树,右子树中的值都需要大于根节点的,否则就不能构成二叉搜索树。

如数组{5,7,6,9,11,10,8},后续遍历最后一个数字8就是根节点的值。前面5,7,6均小于8,是左子树,此时我们判断剩下的9,11,10是否都大于8,如果都大于8,说明他们可以作为根节点的右子树。之后可以用同样的方法确定与数组每一部分对应的子树的结构。这其实就是一个递归的过程。

对于递归回溯,大家肯定都知道是什么,看别人的代码也基本可以看懂,但是自己去写的时候,总感觉不是那么回事。这就是对递归回溯的整个过程没有思考清楚,本人建议可以自己多画几次递归回溯的流程图,去思考清楚是怎么回溯的,这样自己写的时候才能迅速的反应过来。记住一点,每一次递归都是调用了方法自身,都会开辟一个新的方法栈,只有遇到return语句或者当前方法栈运行结束才会往回回溯。否则上一级栈会一直等着他的下一级栈回来。
在这里插入图片描述

Java代码

class Solution {
    public boolean verifyPostorder(int[] postorder) {
        if(postorder == null || postorder.length == 0) return true;
        return dfs(postorder,0,postorder.length - 1);
    }
    
    public boolean dfs(int[] postorder,int start,int end){
        if(start >= end) return true;//分到只剩下一个数了,只有一个树节点肯定可以构成二叉搜索树
        int root = postorder[end];//当前子结构的根节点
        int i = start;//i用于找到第一个大于子结构根节点的值
        while(i < end && postorder[i] < root) i++;
        //从i到end-1就应该是右子树了,所有的值都应该大于root
        //如果有不大于root的,说明无法构成二叉搜索树
        for(int j = i;j < end;j++){
            if(postorder[j] < root){
                return false;
            }
        }
        //递归判断左右子树是否也符合二叉搜索树的性质
        return dfs(postorder,start,i - 1) && dfs(postorder,i,end - 1);
    }
}

在这里插入图片描述

Go代码

func verifyTreeOrder(postorder []int) bool {
    // 后续最后一个元素是根节点,然后由于是二叉搜索树,所以小于根节点的是左子树,反之,是右子树
    if len(postorder) == 0 {
        return true
    }
    return dfs(postorder,0,len(postorder) - 1)
}

// 全局坚持左闭右闭
func dfs(postorder []int,left,right int) bool {
    if left >= right { // 只有一个节点,或者没有节点的时候,是一棵二叉搜索树
        return true
    }
    root := postorder[right]
    l := left
    for l < right {
        if postorder[l] < root {
            l++
        } else {
            // 遇到一个不小于的时候就退出for,此时l就是第一个不小于root的元素,也就是右子树第一个元素
            break
        }
    }
    
    // 现在l到right之间的就是右子树,需要所有数字都大于root
    for i := l ;i < right;i++ {
        if postorder[i] < root {
            return false
        }
    }
    return dfs(postorder,left,l - 1) && dfs(postorder,l,right - 1)
}

在这里插入图片描述


扩展题:LeetCode 1008. 前序遍历构造二叉搜索树

1008. 前序遍历构造二叉搜索树

返回与给定前序遍历 preorder 相匹配的二叉搜索树(binary search tree)的根结点。

(回想一下,二叉搜索树是二叉树的一种,其每个节点都满足以下规则,对于 node.left 的任何后代,值总 < node.val,而 node.right 的任何后代,值总 > node.val。此外,前序遍历首先显示节点 node 的值,然后遍历 node.left,接着遍历 node.right。)

题目保证,对于给定的测试用例,总能找到满足要求的二叉搜索树。

示例:

输入: [8,5,1,7,10,12]
输出: [8,5,10,1,7,null,12]
在这里插入图片描述

提示:

  • 1 <= preorder.length <= 100
  • 1 <= preorder[i] <= 10^8
  • preorder 中的值互不相同

解题思路

这就是剑指offer p182的相关题目,是上一题的扩展题,上题是判断能否构成二叉搜索树,而这题是告知一定可以构成二叉搜索树,让我们构造出该树。其实就是换汤不换药。思路与上题一致,这里换成了前序遍历罢了。为了加深对递归回溯的理解,仍然画了一个图,以[8,5,1,7,10,12]为例。
在这里插入图片描述

Java代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode bstFromPreorder(int[] preorder) {
        if(preorder == null || preorder.length == 0) return null;
        TreeNode root = dfs(preorder,0,preorder.length - 1);
        return root;
    }
    
    private TreeNode dfs(int[] preorder,int start,int end){
    	//注意这里条件与上稍有不同,'='时,需要返回new TreeNode(preorder[start]),为了统一,去掉‘=’
        if(start > end) return null;
        TreeNode root = new TreeNode(preorder[start]);
        //找到第一个不小于根节点值的值,从而划分左右子树,继续递归下去
        int i = start+1;//保存第一个大于根节点值的索引
        while(i <= end && preorder[i] < root.val ) i++;
        root.left = dfs(preorder,start+1,i-1);
        root.right = dfs(preorder,i,end);
        return root;
    }
}

在这里插入图片描述

Go代码


/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func bstFromPreorder(preorder []int) *TreeNode {
    if len(preorder) == 0 {
        return nil
    }

    // 只要递归过程中,全程坚持左闭右闭或者左闭右开,区间就不容易乱
    // 这里选择左闭右闭
    root := dfs(preorder,0,len(preorder) - 1)
    return root
}

func dfs(preorder []int,left,right int) *TreeNode {
    if left > right {
        return nil
    }
    if left == right {
        return &TreeNode{Val:preorder[left]}
    }
    root := &TreeNode{Val :preorder[left]}
    // 找到左子树区间
    l := left + 1
    for l <= right {
        if preorder[l] < root.Val {
            l++
        } else {
            break
        }
    }
    // l此时是不小于root.Val的第一个数,也就是右子树的第一个数
    root.Left = dfs(preorder,left + 1,l - 1)
    root.Right = dfs(preorder,l,right)
    return root 

}

在这里插入图片描述

举一反三

如果面试题要求处理一棵二叉树的遍历序列,则可以先找到二叉树的根节点,再基于根节点把整个树的遍历序列拆分为左右子序列,然后递归的处理这两个序列。上面两题都是这个思路,剑指offer 7. 重建二叉树应用的也是该思路。

评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值