Java实现二叉排序树及遍历

package test;

import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Stack;

import org.apache.poi.util.SystemOutLogger;

public class BST {
	Node root = null;
	private class Node{
		private int key;
		private String value;
		private int N;
		private Node left,right;
		Node(int key, String value, int n) {
			this.key = key;
			this.value = value;
			this.N= n;
		}
	}
	public static void main(String[] args) {
		BST bst = new BST();
		bst.put(3, "three");
		bst.put(6, "six");
		bst.put(1, "one");
		bst.put(8, "eight");
		bst.put(2, "two");
		bst.put(7, "seven");
		System.out.println(bst.size());
		System.out.println(bst.min());
		System.out.println(bst.max());
		System.out.println(bst.floor(4));
		System.out.println("inOrder");
		bst.inOrder();
		System.out.println("inOrder2");
		bst.inOrder2();
		//bst.delete(7);
		//bst.inOrder();
		System.out.println("perOrder");
		bst.perOrder();
		System.out.println("perOrder2");
		bst.perOrder2();
		System.out.println("postOrder");
		bst.postOrder();
		System.out.println("postOrder2");
		bst.postOrder2();
		
	}
	int size() {
		if(root == null)
			return 0;
		return root.N;
	}
	int size(Node node) {
		return node==null?0:node.N;
	}
	public void put(int key, String value) {
		root = put(root, key, value);
	}
	public Node put(Node node, int key, String value) {
		if(node == null) {
			node = new Node(key, value, 1);
			return node;
		}else {
			if(node.key > key) {
				node.left = put(node.left, key, value);
				//node.N++;
			}else if(node.key < key){
				node.right = put(node.right, key, value);
				//node.N++;
			}else {
				node.value = value;
			}
		}
		node.N = size(node.left) + size(node.right) + 1;
		return node;
	}
	
	public Node deleteMin(Node node) {
		if(node == null)
			return node;
		if(node.left == null) {
			return node.right;
		}
		if(node.left != null) {
			node.left = deleteMin(node.left);
		}
		return node;
	} 
	
	public void delete(int key){
	    root = delete(root, key);
	}
	public Node delete(Node node, int key) {
		//Node n = get(key);
		if(node == null)
			return null;
		if(node.key == key) {
			//左右子树均为空
			if(node.left == null && node.right == null) {
				return null;
			}else if(node.left == null) {
				node = node.right;
			}else if(node.right == null){
				node = node.left;
			}else {
				Node tmp = node;
				node = min(node.right);
				node.right = deleteMin(node.right);
				node.left = tmp.left;
			}
		}
		if(node.key > key) {
			node.left = delete(node.left, key);
		}else {
			node.right = delete(node.right, key);
		}
		node.N = size(node.left) + size(node.right) + 1;
		return node;
	}
	
	
	
	public int min() {
		return min(root).key;
	}
	public Node min(Node node) {
		if(node.left == null)
			return node;
		else {
			do {
				node = node.left;
			}while(node.left != null);
			return node;
		}
	}
	public int max() {
		return max(root).key;
	}
	public Node max(Node node) {
		if(node.right == null)
			return node;
		else {
			do {
				node = node.right;
			}while(node.right != null);
			return node;
		}
	}
	public int floor(int key) {
		return floor(root, key)==null ?0 : floor(root, key).key;
	}
	
	public Node floor(Node node, int key) {
		if(node == null)
			return node;
		Node t = null;
		if(node.key == key)
			return node;
		if(node.key < key) {
			t = floor(node.right, key);
		}else {
			t = floor(node.left, key);
		}
		if(t == null)
			return node;
		else
			return t;
	}
	public Node get(int key) {
		return get(root, key);
	}
	public Node get(Node node, int key) {
		if(node == null || node.key == key)
			return node;
		else {
			if(node.key > key) {
				return get(node.left, key);
			}else {
				return get(node.right, key);
			}
		}
	}
	public int select(int k) {
		Node ret = select(root, k);
		if(ret == null)
			return -9999;
		return ret.key;
	}
	public Node select(Node node, int k) {
		if(node == null)
			return null;
		int t = size(node.left);
		if(t == k) {
			return node;
		}else if(t < k) {
			return select(node.right, k-t-1);
		}else{
			return select(node.left, k);
		}
	}
	public void perOrder() {
		preOrder(root);
	}
	public void preOrder(Node node) {
		if(node != null) {
			System.out.println(node.value);
			preOrder(node.left);
			preOrder(node.right);
		}
	}
	
	public void perOrder2() {
		Stack<Node> stack = new Stack<>();
		Node node = root;
		if(node != null) {
			stack.push(node);
			System.out.println(node.value);
			while(node.left != null) {
				node = node.left;
				stack.push(node);
				System.out.println(node.value);
			}
		}
		while(!stack.isEmpty()) {
			Node n = stack.pop();
			if(n.right != null) {
				stack.push(n.right);
				System.out.println(n.right.value);
				n = n.right;
				while(n.left != null) {
					n = n.left;
					stack.push(n);
					System.out.println(n.value);
				}
			}
		}
	}
	
	public void inOrder() {
		inOrder(root);
	}
	public void inOrder(Node node) {
		if(node != null) {
			inOrder(node.left);
			System.out.println(node.value);
			inOrder(node.right);
		}
	}
	public void inOrder2() {
		Stack<Node> stack = new Stack<>();
		Node node = root;
		while(node != null) {
			stack.push(node);
			node = node.left;
		}
		while(!stack.isEmpty()) {
			Node n = stack.pop();
			System.out.println(n.value);
			if(n.right != null) {
				stack.push(n.right);
				n = n.right;
				while(n.left != null) {
					n = n.left;
					stack.push(n);
				}
			}
		}
	}
	
	public void postOrder() {
		postOrder(root);
	}
	public void postOrder(Node node) {
		if(node != null) {
			postOrder(node.left);
			postOrder(node.right);
			System.out.println(node.value);
		}
	}
	
	public void postOrder2() {
		LinkedList<Node> ll = new LinkedList<>();
		Stack<Node> stack = new Stack<>();
		Node node = root;
		if(node != null) {
			stack.push(node);
			ll.add(node);
			//System.out.println(node.value);
			while(node.right != null) {
				node = node.right;
				stack.push(node);
				ll.add(node);
				//System.out.println(node.value);
			}
		}
		while(!stack.isEmpty()) {
			Node n = stack.pop();
			if(n.left != null) {
				stack.push(n.left);
				ll.add(n.left);
				//System.out.println(n.left.value);
				n = n.left;
				while(n.right != null) {
					n = n.right;
					stack.push(n);
					ll.add(n);
					//System.out.println(n.value);
				}
			}
		}
		Collections.reverse(ll);
		for (Node n : ll) {
			System.out.println(n.value);
		}
	}
}