微软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插件
————————————————------------------------------------------------------------------------------------------------------------------

第9题（树）
判断整数序列是不是二元查找树的后序遍历结果
题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。
如果是返回true，否则返回false。

例如输入5、7、6、9、11、10、8，由于这一整数序列是如下树的后序遍历结果：

         8
      /  /
     6    10
    / /  / /
   5  7 9  11
因此返回true。
如果输入7、4、6、5，没有哪棵树的后序遍历的结果是这个序列，因此返回false。

 

 

package com.microsoft;


public class BinarySearchTree {
	private Node root;
	public BinarySearchTree(int[]data){
		for(int i=0;i<data.length;i++){
			Node node=new Node();
			node.setValue(data[i]);
			insert(node);
		}
	}
	public BinarySearchTree(int[]data,boolean reverse)throws Exception{
		for(int i=data.length-1;i>=0;i--){
			Node node=new Node();
			node.value=data[i];
			if(root==null){
				root=node;
				continue;
			}
			Node current=root;
			while(current!=null){
				if(node.value>current.value){
					if(current.left!=null){
						throw new Exception("该数组不是某二元查找树的后序遍历的结果");
					}
					if(current.right!=null){
						current=current.right;
					}else{
						current.right=node;
						current=null;
					}
				}else{
					if(current.left!=null){
						current=current.left;
					}else{
						current.left=node;
						current=null;
					}
				}
			}
		}
	}
	
	/**
	 * 中序遍历
	 */
	public void inorderTreeWalk(){
		innerInorderTreeWalk(root);
		System.out.println();
	}
	/**
	 * 中序遍历
	 */
	private void innerInorderTreeWalk(Node node){
		if(node!=null){
			innerInorderTreeWalk(node.left);
			System.out.print("-->"+node.value);
			innerInorderTreeWalk(node.right);
		}
	}
	/**
	 * 先序遍历
	 */
	public void preorderWalk(){
		innerPreorderWalk(root);
		System.out.println();
	}
	private void innerPreorderWalk(Node node){
		System.out.print("-->"+node.value);
		innerPreorderWalk(node.left);
		innerPreorderWalk(node.right);
	}
	/**
	 * 后续遍历
	 */
	public void postorderWalk(){
		innerPostorderWalk(root);
		System.out.println();
	}
	private void innerPostorderWalk(Node node){
		if(node==null){
			return;
		}
		innerPostorderWalk(node.left);
		innerPostorderWalk(node.right);
		System.out.print("-->"+node.value);
	}
	/**
	 * 查找值为value的节点
	 * @param value
	 * @return
	 */
	public Node search(int value){
		return innerSearch(root,value);
	}
	private Node innerSearch(Node node,int value){
		if(node==null||node.value==value){
			return node;
		}
		if(node.value>value){
			return innerSearch(node.left,value);
		}else{
			return innerSearch(node.right,value);
		}
	}
	/**
	 * 返回最小值节点
	 * @return
	 */
	public Node minimum(){
		return innerMinimum(root);
	}
	private Node innerMinimum(Node node){
		if(node.left!=null){
			return innerMinimum(node.left);
		}
		return node;
	}
	/**
	 * 返回最大值节点
	 * @return
	 */
	public Node maximum(){
		return innerMaximum(root);
	}
	private Node innerMaximum(Node node){
		if(node.right!=null){
			return innerMaximum(node.right);
		}
		return node;
	}
	/**
	 * 返回给定节点的后继结点
	 * @param node
	 * @return
	 */
	public Node successor(Node node){
		if(node.right!=null){
			return innerMinimum(node.right);
		}
		Node y=node.parent;
		while(y!=null&&y.right==node){
			node=y;
			y=y.parent;
		}
		return y;
	}
	public void insert(int value){
		Node node=new Node();
		node.setValue(value);
		insert(node);
	}
	/**
	 * 插入节点
	 * @param node
	 */
	public void insert(Node node){
		Node y=null;
		Node x=root;
		while(x!=null){
			y=x;
			if(node.value<x.value){
				x=x.left;
			}else{
				x=x.right;
			}
		}
		node.parent=y;
		if(y==null){
			root=node;
		}else if(y.value>node.value){
			y.left=node;
		}else{
			y.right=node;
		}
	}
	
	private void transplant(Node u,Node v){
		if(u.parent==null){
			root=v;
		}else if(u==u.parent.left){
			u.parent.left=v;
		}else{
			u.parent.right=v;
		}
		if(v!=null){
			v.parent=u.parent;
		}
	}
	public void delete(int value){
		delete(search(value));
	}
	/**
	 * 删除节点
	 * @param node
	 */
	public void delete(Node node){
		if(node.left==null){
			transplant(node,node.right);
		}else if(node.right==null){
			transplant(node,node.left);
		}else{
			Node y=innerMinimum(node.right);
			if(y.parent!=node){
				transplant(y,y.right);
				y.right=node.right;
				y.right.parent=y;
			}
			transplant(node,y);
			y.left=node.left;
			y.left.parent=y;
		}
	}
	private static class Node{
		private Node left;
		private Node right;
		private Node parent;
		private int value;
		public Node getLeft() {
			return left;
		}
		public void setLeft(Node left) {
			this.left = left;
		}
		public Node getRight() {
			return right;
		}
		public void setRight(Node right) {
			this.right = right;
		}
		public Node getParent() {
			return parent;
		}
		public void setParent(Node parent) {
			this.parent = parent;
		}
		public int getValue() {
			return value;
		}
		public void setValue(int value) {
			this.value = value;
		}
		
	}
	public static void main(String[] args) throws Exception{
		int [] data=new int[]{5,7,6,9,11,10,8};
		BinarySearchTree tree=new BinarySearchTree(data,true);
		tree.postorderWalk();
		int [] data2=new int[]{7,4,6,5};
		BinarySearchTree tree2=new BinarySearchTree(data2,true);
		tree2.postorderWalk();

	}

}