题目概述

• 算法说明
  输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回true,否则返回false。假设输入的数组的任意两个数字都互不相同。（ps：我们约定空树不是二叉搜素树）
  
  二叉搜索树是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。
• 测试用例
  输入：
  [4,8,6,12,16,14,10]
  [4,6,7,5]
  [1,2,3,4,5]
  [5,4,3,2,1]
  [5]
  [7,4,6,5]
  [4,6,12,8,16,14,10]
  []
  [7,4,9,3,8,11,12,10]
  [1,2,7,4,6,5,3]
  [8,4,6,12,16,14,10]
  [2,6,1,5,4,10,12,14,16,8]
  [10,2,6]
  输出：
  true
  true
  true
  true
  true
  false
  false
  false
  false
  false
  false
  false
  false

解析&参考答案

• 解析
  方法1： 先遍历一遍找到其根节点，然后将其分割为左右子树，在递归判断左右子树是否为二叉搜索树。
  方法2： 上限约束法(具体见牛客网分析)，比递归效率更高的方法，从O(nlogn)到O(n)。

• 参考答案

vim jz23.go
package main

import "fmt"

func VerifySquenceOfBST(sequence []int) bool {
	if len(sequence) == 0 {
		return false
	}
	if len(sequence) == 1 {
		return true
	}
	length := len(sequence)
	i := 0
	for ; i < length-1; i++ {
		if sequence[i] > sequence[length-1] {
			break
		}
	}
	j := i
	for ; j < length-1; j++ {
		if sequence[j] < sequence[length-1] {
			return false
		}
	}
	left := true
	if i > 0 {
		left = VerifySquenceOfBST(sequence[:i])
	}
	right := true
	if i < length-1 {
		right = VerifySquenceOfBST(sequence[i : length-1])
	}
	return left && right
}

func main() {
	arr := []int{4, 8, 6, 12, 16, 14, 10}
	result := VerifySquenceOfBST(arr)
	fmt.Print(result)
}

vim jz23_test.go
package main

import "testing"

func TestVerifySquenceOfBST(t *testing.T) {
	tests := []struct {
		arr    []int
		result bool
	}{
		{[]int{4, 8, 6, 12, 16, 14, 10}, true},
		{[]int{4, 6, 7, 5}, true},
		{[]int{1, 2, 3, 4, 5}, true},
		{[]int{5, 4, 3, 2, 1}, true},
		{[]int{5}, true},
		{[]int{7, 4, 6, 5}, false},
		{[]int{4, 6, 12, 8, 16, 14, 10}, false},
		{[]int{}, false},
		{[]int{7, 4, 9, 3, 8, 11, 12, 10}, false},
		{[]int{1, 2, 7, 4, 6, 5, 3}, false},
		{[]int{8, 4, 6, 12, 16, 14, 10}, false},
		{[]int{2, 6, 1, 5, 4, 10, 12, 14, 16, 8}, false},
		{[]int{10, 2, 6}, false},
	}
	for _, tt := range tests {
		if actual := VerifySquenceOfBST(tt.arr); actual != tt.result {
			t.Errorf("arr %v got %v, expected %v\n", tt.arr, VerifySquenceOfBST(tt.arr), tt.result)
		}
	}
}

注意事项

1. 递归方法在每一层的遍历开销是O(n)，而对于二叉树而言，递归的层数平均是O(logn)，因此，递归方法的最终复杂度是O(nlogn)。
2. to add – 补充上限约束法

说明

1. 当前使用 go1.15.8
2. 参考 牛客网--剑指offer
   标题中jzn(n为具体数字)代表牛客网剑指offer系列第n号题目，例如 jz01 代表牛客网剑指offer中01号题目。

注意!!!

• 笔者最近在学习 golang，因此趁机通过数据结构和算法来进一步熟悉下go语言
• 当前算法主要来源于剑指 offer，后续会进一步补充 LeetCode 上重要算法，以及一些经典算法
• 此处答案仅为参考，不一定是最优解，欢迎感兴趣的读者在评论区提供更优解