二叉搜索树的后序遍历

题目:
输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历结果。

后序遍历是左右根,
思路
二叉树后序遍历数组的最后一个数为根结点,剩余数字中,小于根结点的数字(即左子树部分)都排在前面,
大于根结点的数字(即右子树部分)都排在后面。根据遍历数组的这个特性,可以编写出一个递归函数,
用于实现题目所要求的判断功能。

package helen.a;

public class SquenceOfBST {

    public boolean squenceOfBST(int a[]){
        if(a==null||a.length==0){
            return false;
        }
        return verifyCore(a,0,a.length-1);

    }

    private boolean verifyCore(int[] a, int start, int end) {
        //  4, 8, 6, 12, 16, 14, 10
        //start大于end说明上层没有左子树或右子树
        if(start>=end){
            return true;
        }
        int mid=start;
        while(a[mid]<a[end]){
            mid++;
        }
        for(int i=mid;i<end;i++){
            if(a[i]<a[end]){
                return false;
            }
        }
        return verifyCore(a,start,mid-1)&&verifyCore(a,mid,end-1);
    }  // ====================测试代码====================
    void test(String testName, int sequence[], boolean expected){
        if(testName != null)
            System.out.printf("%s begins: ", testName);

        if(squenceOfBST(sequence) == expected)
            System.out.printf("passed.\n");
        else
            System.out.printf("failed.\n");
    }

    //         10
//         /      \
//        6        14
//       /\        /\
//      4  8     12  16
    void test1(){
        int data[] = {4, 8, 6, 12, 16, 14, 10};
        test("Test1", data,  true);
    }

    //        5
//          / \
//         4   7
//            /
//           6
    void test2(){
        int data[] = {4, 6, 7, 5};
        test("Test2", data,  true);
    }
    //
//    //            5
              /
             4
            /
           3
          /
         2
        /
       1
    void test3(){
        int data[] = {1, 2, 3, 4, 5};
        test("Test3", data, true);
    }
    //
//   1
  \
   2
    \
     3
      \
       4
        \
         5
    void test4(){
        int data[] = {5, 4, 3, 2, 1};
        test("Test4", data, true);
    }
    //
//    // 树中只有1个结点
    void test5(){
        int data[] = {5};
        test("Test5", data,  true);
    }
    //
    void test6(){
        int data[] = {7, 4, 6, 5};
        test("Test6", data,  false);
    }
    //
    void test7(){
        int data[] = {4, 6, 12, 8, 16, 14, 10};
        test("Test7", data,  false);
    }
    //
    void test8(){
        test("Test8", null,  false);
    }

    public static void main(String args[]){
       // new SquenceOfBST().test1();
       // new SquenceOfBST().test2();
        new SquenceOfBST().test3();
        new SquenceOfBST().test4();
        new SquenceOfBST().test5();
        new SquenceOfBST().test6();
        new SquenceOfBST().test7();
        new SquenceOfBST().test8();
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
对于这个问题,我们可以使用队列和分治法来求解二搜索的层。具体的实现方法如下: 1. 首先,根据后的定义,可以知道二搜索的根节点是列的最后一个元素。 2. 然后,使用分治法将列划分为两个部分,即左子和右子。可以找到第一个比根节点小的元素,将其之前的部分定义为左子的后,之后的部分定义为右子的后。 3. 对于左右子,分别重复上述过程,递归求解左右子的层。 4. 最后,将左右子的层按照层次合并起来,即可得到整棵二搜索的层。 下面是具体的实现代码: ```python def postorder_to_levelorder(postorder): if not postorder: return [] root = postorder[-1] mid = bisect.bisect_left(postorder, root) left_postorder = postorder[:mid] right_postorder = postorder[mid:-1] left_levelorder = postorder_to_levelorder(left_postorder) right_levelorder = postorder_to_levelorder(right_postorder) levelorder = [root] queue = [root] while queue: node = queue.pop(0) if node in left_levelorder: levelorder.extend(left_levelorder[left_levelorder.index(node)+1:]) queue.extend(left_levelorder[left_levelorder.index(node)+1:]) if node in right_levelorder: levelorder.extend(right_levelorder[right_levelorder.index(node)+1:]) queue.extend(right_levelorder[right_levelorder.index(node)+1:]) return levelorder ``` 该实现使用了递归和队列,时间复杂度为 O(nlogn)。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值