数据结构-红黑树扩张-顺序统计树

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

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

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

第二个视频发布  https://edu.youkuaiyun.com/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.youkuaiyun.com/course/detail/27574

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

 

package com.data.struct;


public class OrderStatisticTree {
	private Node root;
	//private Node nil;
	
	public OrderStatisticTree(int []data){
		for(int i=0;i<data.length;i++){
			Node node=new Node();
			node.setValue(data[i]);
			node.setSize(1);
			insert(node);
		}
	}
	
	/**
	 * 查找第i小的节点
	 * @param i
	 * @return
	 */
	public Node select(int i){
		return select(root,i);
	}
	/**
	 * 查找第i小的节点
	 * @param i
	 * @return
	 */
	private Node select(Node node,int i){
		int r;
		if(node.left!=null){
			r=node.left.size+1;
		}else{
			r=1;
		}
		
		if(i==r){
			return node;
		}else if(i<r){
			return select(node.left,i);
		}else {
			return select(node.right,i-r);
		}
	}
	/**
	 * 查找元素node质
	 * @param node
	 * @return
	 */
	public int rank(Node node){
		int r;
		if(node.left==null){
			r=1;
		}else{
			r=node.left.size+1;
		}
		Node y=node;
		while(y!=root){
			if(y==y.parent.right){
				if(y.parent.left==null){
					r=r+1;
				}else{
					r=r+y.parent.left.size+1;
				}
			}
			y=y.parent;
		}
		return r;
	}
	/**
	 * 中序遍历
	 */
	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(){
		System.out.println("      "+((root.color==Node.RED?"R":"B")+root.value));
		innerPreorderWalk(root,1);
		System.out.println();
	}
	private void innerPreorderWalk(Node node,int depth){
		if(node!=null){
			if(node.left!=null){
				for(int i=6-depth*2;i>0;i--){
					System.out.print(" ");
				}
				System.out.print((node.left.color==Node.RED?"R":"B")+node.left.value+node.value);
			}else{
				System.out.print("  ");
			}
			if(node.right!=null){
				System.out.print("  ");
				System.out.print((node.right.color==Node.RED?"R":"B")+node.right.value+node.value);
			}else{
				System.out.print("  ");
			}
			if(node.left!=null||node.right!=null){
				System.out.println();
			}
			innerPreorderWalk(node.left,depth+1);
			innerPreorderWalk(node.right,depth+1);
			
		}
		
	}
	/**
	 * 后续遍历
	 */
	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;
	}
	/**
	 * 插入
	 * @param node
	 */
	private void insert(Node node){
		Node y=null;
		Node x=root;
		while(x!=null){
			y=x;
			x.size+=1;
			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;
		}
		root.parent=null;
		node.color=Node.RED;
		preorderWalk();
		insertFixUp(node);
		preorderWalk();

	}
	/**
	 * 插入修复颜色
	 * @param node
	 */
	private void insertFixUp(Node node){
		if(node.parent==null){
			node.color=Node.BLACK;
		}else if(node.parent.parent==null){
			node.color=Node.RED;
		}else {
			while(node.parent==null||node.parent.color==Node.RED){
				if(node.parent==null){
					node.color=Node.BLACK;
					return;
				}else if(node.parent==node.parent.parent.left){
					Node y=node.parent.parent.right;
					if(y==null||y.color==Node.RED){
						node.parent.color=Node.BLACK;
						if(y!=null){
							y.color=Node.BLACK;
						}else{
							node.parent.parent.color=Node.RED;
							rightRotate(node.parent.parent);
							return;
						}
						node.parent.parent.color=Node.RED;
						
						node=node.parent.parent;
					}else if(node==node.parent.right){
						node=node.parent;
						leftRotate(node);
					}else{
						node.parent.color=Node.BLACK;
						node.parent.parent.color=Node.RED;
						rightRotate(node.parent.parent);
					}
				}else{
					Node y=node.parent.parent.left;
					if(y==null||y.color==Node.RED){
						node.parent.color=Node.BLACK;
						if(y!=null){
							y.color=Node.BLACK;
						}else{
							node.parent.parent.color=Node.RED;
							leftRotate(node.parent.parent);
							return;
						}
						node.parent.parent.color=Node.RED;
						
						node=node.parent.parent;
					}else if(node==node.parent.left){
						node=node.parent;
						rightRotate(node);
					}else{
						node.parent.color=Node.BLACK;
						node.parent.parent.color=node.RED;
						leftRotate(node.parent.parent);
					}
				}
			}
		}
	}
	public void insert(int value){
		Node node=new Node();
		node.setValue(value);
		node.setSize(1);
		insert(node);
	}
	private void delete(Node node){
		Node y=node;
		int yoc=y.color;
		Node x;
		if(node.left==null&&node.right!=null){
			 x=node.right;
			transplant(node, node.right);
		}else if(node.right==null&&node.left!=null){
			 x=node.left;
			transplant(node, node.left);
		}else if(node.left==null&&node.right==null){
			if(node.parent==null){
				root=null;
				System.out.println("root is null");
				return;
			}
			x=node.parent;
			if(node==node.parent.left){
				node.parent.left=null;
				if(x.color==Node.RED){
					leftRotate(x);
					preorderWalk();
					return;
				}else if(x.color==Node.BLACK&&node.color==Node.BLACK){
					x=node.parent.right;
					deleteFixUp(x);
					return;
				}
			}else{
				node.parent.right=null;
				if(x.color==Node.RED){
					rightRotate(x);
					preorderWalk();
					return;
				}else if(x.color==Node.BLACK&&node.color==Node.BLACK){
					x=node.parent.left;
					deleteFixUp(x);
					return;
				}
			}
		}else{
			y=innerMinimum(node.right);
			yoc=y.color;
			 
			if(y.parent!=node){
				transplant(y, y.right);
				y.right=node.right;
				y.right.parent=y;
			}
			transplant(node, y);
			x=y.right;
			y.left=node.left;
			y.left.parent=y;
			y.color=node.color;
			if(x==null){
				preorderWalk();
				y.color=Node.RED;
				if(y.left!=null){
					y.left.color=Node.BLACK;
					rightRotate(y);
				}else if(y.right!=null){
					y.right.color=Node.RED;
					leftRotate(y);
				}else{
					y.color=Node.RED;
				}
				preorderWalk();
				return;
				
			}
		}
		preorderWalk();
		if(yoc==Node.BLACK){
			deleteFixUp(x);
			preorderWalk();
		}
		
	}
	private void deleteFixUp(Node node){
		if(node==null){
			
		}
		while(node!=root&&node.color==Node.BLACK){
			Node w;
			if(node==node.parent.left){
				w=node.parent.right;
				if(w.color==Node.RED){
					w.color=Node.BLACK;
					node.parent.color=Node.RED;
					leftRotate(node.parent);
					w=node.parent.right;
				}
				if(w.left.color==Node.BLACK&&w.right.color==Node.BLACK){
					w.color=Node.RED;
					node=node.parent;
				}else if(w.right.color==Node.BLACK){
					w.left.color=Node.BLACK;
					w.color=Node.RED;
					rightRotate(w);
					w=node.parent.right;
				}
				w.color=node.parent.color;
				node.parent.color=Node.BLACK;
				w.right.color=Node.BLACK;
				leftRotate(node.parent);
				node=root;
				
			}else{
				w=node.parent.left;
				if(w.color==Node.RED){
					w.color=Node.BLACK;
					node.parent.color=Node.RED;
					rightRotate(node.parent);
					w=node.parent.left;
				}
				if(w.right.color==Node.BLACK&&w.left.color==Node.BLACK){
					w.color=Node.RED;
					node=node.parent;
				}else if(w.left.color==Node.BLACK){
					w.left.color=Node.BLACK;
					w.color=Node.RED;
					leftRotate(w);
					w=node.parent.left;
				}
				w.color=node.parent.color;
				node.parent.color=Node.BLACK;
				w.left.color=Node.BLACK;
				rightRotate(node.parent);
				node=root;
			}
		}
		node.color=Node.BLACK;
		
	}
	/**
	 * 左旋转
	 * @param node
	 */
	private void leftRotate(Node node){
		Node y=node.right;
		y.size=node.size;
		node.right=y.left;
		if(y.left!=null){
			y.left.parent=node;
		}
		y.parent=node.parent;
		if(node.parent==null){
			root=y;
		}else if(node==node.parent.left){
			node.parent.left=y;
		}else{
			node.parent.right=y;
		}
		y.left=node;
		node.parent=y;
		
		if(node.left==null&&node.right!=null){
			node.size=node.right.size+1;
		}else if(node.right==null&&node.left!=null){
			node.size=node.left.size+1;
		}else if(node.left==null&&node.right==null){
			node.size=1;
			return;
		}else{
			node.size=node.left.size+node.right.size+1;
		}
	}
	/**
	 * 右旋转
	 * @param node
	 */
	private void rightRotate(Node node){
		Node y=node.left;
		y.size=node.size;
		node.left=y.right;
		if(y.right!=null){
			y.right.parent=node;
		}
		y.parent=node.parent;
		if(node.parent==null){
			root=y;
		}else if(node==node.parent.left){
			node.parent.left=y;
		}else{
			node.parent.right=y;
		}
		y.right=node;
		node.parent=y;
		if(node.left==null&&node.right!=null){
			node.size=node.right.size+1;
		}else if(node.right==null&&node.left!=null){
			node.size=node.left.size+1;
		}else if(node.left==null&&node.right==null){
			node.size=1;
			return;
		}else{
			node.size=node.left.size+node.right.size+1;
		}
		
	}
	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;
		}
	}
	/**
	 * 删除节点
	 * @param value
	 */
	public void delete(int value){
		delete(search(value));
	}
	private static class Node{
		public static final int RED=1;
		public static final int BLACK=2;
		private Node left;
		private Node right;
		private Node parent;
		private int value;
		private int color;
		private int size;
		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 int getColor() {
			return color;
		}
		public void setColor(int color) {
			this.color = color;
		}
		public int getSize() {
			return size;
		}
		public void setSize(int size) {
			this.size = size;
		}
		
		
		
	}
	public static void main(String[] args) {
		int [] data=new int[]{8,3,2,6,3,9,1,10,11};
		OrderStatisticTree tree=new OrderStatisticTree(data);
		tree.inorderTreeWalk();
		System.out.println("===========");
		//System.out.println(tree.rank(tree.select(3)));
		//System.out.println(tree.rank(tree.select(7)));
		System.out.println(tree.rank(tree.select(8)));
	}
}