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

发布一个k8s部署视频：https://edu.csdn.net/course/detail/26967

课程内容：各种k8s部署方式。包括minikube部署，kubeadm部署，kubeasz部署，rancher部署，k3s部署。包括开发测试环境部署k8s，和生产环境部署k8s。

腾讯课堂连接地址https://ke.qq.com/course/478827?taid=4373109931462251&tuin=ba64518

第二个视频发布  https://edu.csdn.net/course/detail/27109

腾讯课堂连接地址https://ke.qq.com/course/484107?tuin=ba64518

介绍主要的k8s资源的使用配置和命令。包括configmap，pod，service，replicaset，namespace，deployment，daemonset，ingress，pv，pvc，sc，role，rolebinding，clusterrole，clusterrolebinding，secret，serviceaccount，statefulset，job，cronjob，podDisruptionbudget，podSecurityPolicy,networkPolicy,resourceQuota，limitrange，endpoint，event，conponentstatus，node，apiservice，controllerRevision等。

第三个视频发布：https://edu.csdn.net/course/detail/27574

详细介绍helm命令，学习helm chart语法，编写helm chart。深入分析各项目源码，学习编写helm插件

————————————————------------------------------------------------------------------------------------------------------------------

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版

blog.csdn.net/hxpjava1/article/details/22285373

 

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;
}