数据结构-二叉搜所树java实现

发布一个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插件
————————————————------------------------------------------------------------------------------------------------------------------

 

package com.data.struct;

/**
 * 二叉搜索树
 * @author Administrator
 *
 */
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 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){
		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) {
		int [] data=new int[]{8,3,2,6,3,9,1};
		BinarySearchTree tree=new BinarySearchTree(data);
		tree.inorderTreeWalk();
		tree.insert(5);
		tree.inorderTreeWalk();
		tree.delete(3);
		tree.inorderTreeWalk();

	}

}