二叉搜索树（java实现）

package com.binarytree;

import java.util.LinkedList;

public class BSTree <K extends Comparable<K>,V>{
    
    public BSTree() {
        count = 0;
        root = null;
    }
    
    private int count;
    
    public int size() {
        return count;
    }
    
    public boolean isEmpty() {
        return count == 0;
    }
    
    private class Node {
        private K key;
        private V val;
        Node left,right;
        
        Node(K key,V val) {
            this.key = key;
            this.val = val;
            left = right;
        }
    }
    
    private Node root;
    
    public void insert(K key,V value) {
        root = insert(root,key,value);
    }
    
    private Node insert(Node node,K key,V value) {
        if (node == null) {
            count++;
            return new Node(key,value);
        }
        
        if (key.compareTo(node.key) == 0)
            node.val = value;
        else if(key.compareTo(node.key) < 0)
            node.left = insert(node.left,key,value);
        else
            node.right = insert(node.right,key,value);
        
        return node;
    }
    
    public V search(K key) {
        return search(root,key);
    }
    
    private V search(Node node,K key) {
        if (node == null) return null;
        
        if (key.compareTo(node.key) == 0)
            return node.val;
        else if (key.compareTo(node.key) < 0)
            return search(node.left,key);
        else
            return search(node.right,key);
    }
    
    public boolean contains(K key) {
        return contains(root,key);
    }
    
    private boolean contains(Node node,K key) {
        if (node == null) return false;
        
        if (key.compareTo(node.key) == 0)
            return true;
        else if (key.compareTo(node.key) < 0)
            return contains(node.left,key);
        else 
            return contains(node.right,key);
    }
    
    
    public void preOrder() {
        preOrder(root);
    }
    
    private void preOrder(Node node) {
        if (node != null) {
            System.out.println(node.key);
            preOrder(node.left);
            preOrder(node.right);
        }
    }
    
    public void inOrder() {
        midOrder(root);
    }
    
    private void midOrder(Node node) {
        if (node != null) {
            midOrder(node.left);
            System.out.println(node.key);
            midOrder(node.right);
        }
    }
    
    public void postOrder() {
        postOrder(root);
    }
    
    private void postOrder(Node node) {
        if (node != null) {
            postOrder(node.left);
            postOrder(node.right);
            System.out.println(node.key);
        }
    }
    
    public void levelOrder() {
        LinkedList<Node> list = new LinkedList<Node>();
        list.add(root);
        
        while (!list.isEmpty()) {
            Node node = list.remove();
            System.out.println(node.key);
            list.add(node.left);
            list.add(node.right);
        }
    }

}


package com.binarytree;

public class Main {

    public static void main(String[] args) {
        BSTree<Integer,String> bsTree = new BSTree();
        
        bsTree.insert(9, "1");
        bsTree.insert(5, "5");
        bsTree.insert(4, "4");
        bsTree.insert(7, "7");
        bsTree.insert(3, "3");
        
        bsTree.inOrder();
        
    }

}