// 写层序遍历用
import java.util.Queue;
import java.util.LinkedList;

public class BinaryTree<T extends Comparable> {
	public Node root;

	BinaryTree(){
		root = null;
	}

	public void insert(T val){
		Node newNode = new Node(val);

		Node pointer = root;
		while(pointer != null){
			// if(val < pointer.value){
			if(val.compareTo(pointer.value) < 0 ){
				if(pointer.left == null){
					pointer.left = newNode;
					break;
				} else {
					pointer = pointer.left;
				}
			} else {
				if(pointer.right == null){
					pointer.right = newNode;
					break;
				} else {
					pointer = pointer.right;
				}
			}
		}
		if(pointer == null){
			root = newNode;
		}
	}


	/*
	*        10
	*     5      15
	*   3   7  12   20
	* preOrder: 10 5 3 7 15 12 20
	*/
	public void preOrder(){
		preOrderTraversal(root);
	}

	private void preOrderTraversal(Node tree){
		if(tree != null) {
			// root.value // 10 打印自身
			System.out.print(tree.value);
			System.out.print(" ");

			// 打印10左子树
			preOrderTraversal(root.left)
			// root.left.value        // 5
			// root.left.left.value   // 3
			// root.left.right.value  // 7
			
			// 打印右子树
			preOrderTraversal(root.right)  
	        // root.right.value       // 15
	        // root.right.left.value  // 12
	        // root.right.right.value // 20
		}
	}


	public void inOrder(){}
	public void postOrder(){}
	public void level(){}

    	/*
	Delete:
	 1. 找到被删除的节点及其父节点
	 2. 三种删除分别处理
	*/
	public void delete(T val){
		if(root == null){
			return ;
		}

		// 1. 找到被删除的节点及其父节点
		Node parent = root;
		Node current = root;
		while(current != null){
			if(val.compareTo(current.value) == 0){
				break;
			} else if (val.compareTo(current.value) < 0){
				parent = current;
				current = current.left;
			} else {
				parent = current;
				current = current.right;
			}
		}
		//整个while结束之后有2种情况
		// 1. 找到了 current != null, parent也有
		// 2. 没找到 current == null
		if(current != null){
			// case 1: leaf node, 0 child
			if(current.left == null && current.right == null){
				// 1.1 root case
				if(current == root){
					root = null;
				}
				// 1.2 non-root case
				else {
					if(parent.left == current){
						parent.left = null;
					} else {
						parent.right = null;
					}
//					current.left = null;
//					current.right = null;
				}
			}
			// case 2: only 1 child
			else if(current.left == null || current.right == null){

			}
			// case 3: 2 children
			else {
				// option 1: 被删节点的左子树的最大值来替换
				// option 2: 被删节点的右子树的最小值来替换
				Node leftRoot = current.left;
				T maxValue = findLeftMaxAndDelete(leftRoot);
				current.value = maxValue;
			}
		}
	}

	private T findLeftMaxAndDelete(Node root){
		Node<T> parent = root;
		Node<T> current = root;
		while(current != null && current.right != null){
			parent = current;
			current = current.right;
		}
		//找到最大值
		if(current != null){
			// 删除操作
            if(current.left != null){
               parent.right = current.left;
            } else {
			   parent.right = null;
            }
            // parent.right = current.left ? current.left : null;
            
			return current.value;
		} else {
			return null;
		}
	}
}