BST

package BinarySearchTree;

import java.util.Stack;

public class BinarySearchTree {
	
	public Node root; //初始化 Node class
	
//	public Node find(int key) { //創建method "find" with data type being Node
//		
//	}
	
	//中序遍歷
	public void inorder_iterator(Node node) {
		if (node.leftchild != null) {  //node.leftchild = null <--node的左節支為空
			this.inorder_iterator(node.leftchild);
		}
		System.out.println(node.id + " ");
		if (node.rightchild != null) {
			this.inorder_iterator(node.rightchild);
		}
		}
	
	public void preorder_iterator(Node node ) {
		System.out.println(node.id + " ");
		
		if(node.leftchild != null) {
			this.preorder_iterator(node.leftchild);
		}
		
		if(node.rightchild != null) {
			this.preorder_iterator(node.rightchild);
		}
	}
	
	public void postorder_iterator(Node node) {
		if (node.leftchild != null) {
			postorder_iterator(node.leftchild);
		}
		if (node.rightchild != null) {
			postorder_iterator(node.rightchild);
		}
		System.out.println(node.id);
	}
	
	//non-recursion preorder_iterator
	public void nonre_preorder_iterator(Node node){
		if(node == null) {   //如果node為空 則return nothing
			return;
		}
		//step 1
		Stack st = new Stack();
		//step 2
		st.push(node);
		
		while (st.empty() != true) { //當stack不是空的時侯進行以下循環
		//step 3
		Node curr = (Node) st.pop(); //cast st.pop() 的數據轉化為 Node type
		System.out.println(curr.id);
		if (curr.rightchild != null) {
			st.push(curr.rightchild);
		}
		if (curr.leftchild != null) {
			st.push(curr.leftchild);
		}
		}
		
	}
	
	public int min_node() {
		if (root == null) {
			System.out.println("root not exists");
			return 0;
		}
		
		if (root.leftchild == null) {
			return root.id;
		}
		Node curr = root.leftchild;
		while (curr.leftchild != null) {
			curr = curr.leftchild;
		}
		return curr.id;   
	}
	
	//recursion min
	
	public int min(Node node) {
		Node min_code = min_node(node);
		return min_code.id;
	}
	
	private Node min_node(Node node) {
		if (node == null) {
			return null;
		}
		if (node.leftchild == null) {
			return node;
		}
		if (node.leftchild != null) {
			return min_node(node.leftchild);
		}
		return node;
	}
	
	public int max_node() {
		if(root==null) {
			return 0;
		}
		if(root.rightchild==null) {
			return root.id;
		}
		Node cur = root.rightchild;
		while(cur.rightchild!=null) {
			cur = cur.rightchild;
		}
		return cur.id;
	}

	
	
	public Node find(int key) {
		if (root == null) {
			System.out.println("The tree is empty");
			return null;
		}
		Node current = root;
		while (current.id != key) {
			if (key > current.id)
				current = current.rightchild;
			else
				current = current.leftchild;
			if (current == null)
				return null;
		}
		return current;
	}
	public boolean insert (Node node) {
		if(root == null) {   //當根節點為空時, 新插入的node成為根節點
 			root = node;
			return true;
		}
		if(this.find(node.id) != null) {
			System.out.println(node.id + " has already existed!");
			return false;
		}
		Node current = root;  //獲取根點
		while(current != null) {   
			if(node.id > current.id) {   //如果要插入的node.id大過根點
				if(current.rightchild == null) {
					current.rightchild = node;
					return true;
				}
				current = current.rightchild; //如果current的右節點不為空, 把當前節點的右節點作為節點
			}
			if(node.id < current.id) {
				if(current.leftchild == null) {
					current.leftchild = node;
					return true;
				}
				current = current.leftchild;
			}
			

			
			
		}
		return false;
	}
	
	public void delete_min(Node node) {
		if (find(node.id)==null) {
			System.out.println("Root node not existing!");
		}
		Node cur = node;
		while (cur.leftchild!= null) {
			cur = cur.leftchild;
		}
		
	}
	
	public boolean delete(int key) {
		if (root ==null) {              //如果BST為空
			System.out.println("The tree is empty");
			return false;
		}
		Node targetParent = root;   //初始化記錄父節點和子節點的node
		Node target = root;
		boolean isLeftChild = true;  //boolean來記錄是否左子節點
		while(target.id != key) {	//當要delete的id和current id不同時進行的循環
			if(key > target.id) {		//如key 大於現時的節點id時, 把現時的節點id移動至右子節點
				targetParent = target;
				target = target.rightchild;
				isLeftChild = false;
			}
			else {						//如key 小於現時的節點id時, 把現時的節點id移動至左節點
				targetParent = target;
				target = target.leftchild;
				isLeftChild = true;
			}
			if (target == null)		//此時如果移動至一個null的node時, 中止循環
				break;
		}
		if (target == null)    //找不到該節點
			return false;
		//after while loop, 現時的節點是target, 其父節點為targetParent
		
		//處理第一個情況: 節點沒有左右子節點
		if (target.leftchild==null && target.rightchild==null) {
			if(target.id==root.id) { //如現時的target節點在root節點位置, 將root設定為null
				root=null;
				return true;  //return true 發出delete function已被成功執行訊息
			}
			if (isLeftChild)  //isLeftChild是用來記錄該節點是否左或右子節點
				targetParent.leftchild = null;  //把要被delete節點的parent節點與被delete節點的連接delete 
			
			else 
				targetParent.rightchild = null;
			
		}
		//第二個情況: 節點只有一個節點
		//子節點為右節點
		else if(target.leftchild == null && target.rightchild != null) {
			if (key == root.id) {
				root = root.rightchild;
			}
			if (isLeftChild) {
				targetParent.leftchild = target.rightchild;
			}
			else 
				targetParent.rightchild = target.rightchild;
		}
		//子節點為左節點
		else if(target.leftchild != null && target.rightchild == null) {
			if (key == root.id) {   //when當時節點為root時
				root = root.leftchild; //root節點的左子點取代root成為新的root節點
				
			}
			if (isLeftChild) {
				targetParent.leftchild = target.leftchild;
			}
			else
				targetParent.rightchild = target.leftchild;
		}
		//被delete節點有左右兩點, 先找到後續節點, 再將後續節點插入被delete節點(target) 的位置
		else {
			Node followingNode = this.getFollowingNode(target);
			if (target.id == root.id) {
				root = followingNode;
			}
			else if (isLeftChild) {
				targetParent.leftchild = followingNode; 
			}
			else {
				targetParent.rightchild = followingNode;
			followingNode.leftchild = targetParent.leftchild;
			followingNode.rightchild = targetParent.rightchild;
			}
		}
		return true;
		}
		
		//後續節點的獲取方法

		private Node getFollowingNode(Node node2Del){
			Node nodeParent = node2Del;
			
			Node node = node2Del.rightchild;
			while (node.leftchild != null) {
				nodeParent = node;
				node = node.leftchild;
			}
			if(node.id != node2Del.rightchild.id)
				nodeParent.leftchild = node.rightchild;  //重新連接
			else 
				nodeParent.rightchild = node.rightchild;
			
			return node;
		}
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		BinarySearchTree BST = new BinarySearchTree();
		Node t1 = new Node (20, "first node");
		Node t2 = new Node (10, "second node");
		Node t3 = new Node (30, "third node");
		Node t4 = new Node (40, "forth node");
		
		BST.insert(t1);
		BST.insert(t2);
		BST.insert(t3);
		BST.insert(t4);
		
		BST.inorder_iterator(BST.root);
		System.out.println("以下是先序遍歷");
		BST.preorder_iterator(BST.root);
		System.out.println("以下是後序遍歷");
		BST.postorder_iterator(BST.root);
		System.out.println("以下是non-recursion iterator");
		BST.nonre_preorder_iterator(BST.root);
		
		System.out.println("以下是minNode");
		
		System.out.println(BST.min_node());
		System.out.println(BST.max_node());
		System.out.println(BST.min(BST.root));
		BST.delete(10);
		BST.delete(20);
		System.out.println(BST.min_node());
		
	}
	
	

}