微软100题第9题(判断整数序列是不是二元查找树的后序遍历结果)

1scala版本

package ms
/**
* 第9题（树）
判断整数序列是不是二元查找树的后序遍历结果
题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。
如果是返回true，否则返回false。
例如输入5、7、6、9、11、10、8，由于这一整数序列是如下树的后序遍历结果：
8
/  /
6    10
/ /  / /
5  7 9  11
因此返回true。
如果输入7、4、6、5，没有哪棵树的后序遍历的结果是这个序列，因此返回false。
*/
import scala.util.control.Breaks._
object MicroSoft009 {
def isBinarySearchTree(data:List[Int],start:Int,end:Int):Boolean={
if(start>end){
return true;
}
val root=data(end);
var subRootIndex= -1;
var breaked=false;
breakable{
for(i<-start until end){
if(data(i)>=root){
subRootIndex=i;
breaked=true;
break;
}
}
}
if(!breaked){
return isBinarySearchTree(data,start,end-1);
}
for(i<-subRootIndex+1 until end){
if(data(i)<root){
return false;
}
}
val left=isBinarySearchTree(data,start,subRootIndex-1);
if(!left){
return false;
}
return isBinarySearchTree(data,subRootIndex,end-1);
}

def main(args: Array[String]): Unit = {
val data=List(5,7,6,9,11,10,8);
println(isBinarySearchTree(data,0,data.length-1))
val data2=List(7,4,6,5)
println(isBinarySearchTree(data2,0,data2.length-1))
}
}

2java版

3python版

'''
Created on 2017-1-17

@author: admin
第9题（树）
判断整数序列是不是二元查找树的后序遍历结果
题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。
如果是返回true，否则返回false。
例如输入5、7、6、9、11、10、8，由于这一整数序列是如下树的后序遍历结果：
8
/  /
6    10
/ /  / /
5  7 9  11
因此返回true。
如果输入7、4、6、5，没有哪棵树的后序遍历的结果是这个序列，因此返回false。
'''
def isPostOrderBinaryTreeWalk(data,start,end):
if (start>end):
return True
root=data[end]
subRootIndex=-1
for i in range(start,end):
if data[i]>=root:
subRootIndex=i
break;
if subRootIndex!=-1:
for i in range(subRootIndex+1,end):
if data[i]<root:
return False
if subRootIndex==-1:
return isPostOrderBinaryTreeWalk(data, start, end-1)
left=isPostOrderBinaryTreeWalk(data, start, subRootIndex-1)
if not left:
return False
return isPostOrderBinaryTreeWalk(data, subRootIndex, end-1)
if __name__ == '__main__':
data1=[5,7,6,9,11,10,8]
print(isPostOrderBinaryTreeWalk(data1, 0, len(data1)-1))
data2=[7,4,6,5]
print(isPostOrderBinaryTreeWalk(data2, 0,len(data2)-1))

c语言版本

/*
* microsoft009.c
*
*  Created on: 2017年1月26日
*      Author: admin
第9题（树）
判断整数序列是不是二元查找树的后序遍历结果
题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。
如果是返回true，否则返回false。
例如输入5、7、6、9、11、10、8，由于这一整数序列是如下树的后序遍历结果：
8
/  /
6    10
/ /  / /
5  7 9  11
因此返回true。
如果输入7、4、6、5，没有哪棵树的后序遍历的结果是这个序列，因此返回false。
*/
#include <stdio.h>
#define bool int
#define false 0
#define true 1

bool isPostOrderWalkBinaryTree(int data[],int start,int end);

int main(){
int data1[]={5,7,6,9,11,10,8};
int data2[]={7,4,6,5};
printf("data1 is isPostOrderWalkBinaryTree:%s\n",(isPostOrderWalkBinaryTree(data1,0,6)==true)?"true":"false");
printf("data2 is isPostOrderWalkBinaryTree:%s\n",(isPostOrderWalkBinaryTree(data2,0,3)==true)?"true":"false");
return 0;
}

bool isPostOrderWalkBinaryTree(int data[],int start,int end){
if(start>=end){
return true;
}
int last=data[end];
int index=-1;
for(int i=start;i<end;i++){
if(data[i]>last){
index=i;
break;
}
}
if(index==-1){
return isPostOrderWalkBinaryTree(data,start,end-1);
}else{
for(int i=index+1;i<end;i++){
if(data[i]<=last){
return false;
}
}
}

return isPostOrderWalkBinaryTree(data,start,index-1)&&isPostOrderWalkBinaryTree(data,index+1,end-1);
}

c++版本

/*
* microsoft009.cpp
*
*  Created on: 2017年2月6日
*      Author: admin
第9题（树）
判断整数序列是不是二元查找树的后序遍历结果
题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。
如果是返回true，否则返回false。
例如输入5、7、6、9、11、10、8，由于这一整数序列是如下树的后序遍历结果：
8
/  /
6    10
/ /  / /
5  7 9  11
因此返回true。
如果输入7、4、6、5，没有哪棵树的后序遍历的结果是这个序列，因此返回false。
*/

#include "iostream"
using namespace std;
#include "limits.h"

bool judgeBinaryTreePreOrder(int data[] ,int start,int end){
int last=data[end];
int index=INT_MIN;
for(int i=start;i<end;i++){
if(data[i]>last){
index=i;
break;
}
}
int i;
if(index<start){
i=start;
}else{
i=index+1;
}
for(;i<end;i++){
if(data[i]<last){
return false;
}
}
bool right=false;
bool left=false;
if(index>start){
right=judgeBinaryTreePreOrder(data,index,end-1);
left=judgeBinaryTreePreOrder(data,start,index-1);
return right&left;
}else{
if(end-1>=start){
return judgeBinaryTreePreOrder(data,0,end-1);
}
return true;
}
}

int main(){
//int data[]={5,7,6,9,11,10,8};
int data[]={7,4,6,5};
cout<<boolalpha;
cout<<judgeBinaryTreePreOrder(data,0,6)<<endl;;
return 0;
}