一個簡單的二叉查找樹實現

一個二叉樹實現例子，僅實現add操作，未添加delete操作，待後期添加吧。

/**
 * <p>
 * 二叉樹
 * </p>
 * 
 * @author Vicky
 * @date 2015-8-10
 */
public class BinarySearchTree {
    private Node root;
    private int num;// 節點數量
    private int index;// 用於遍歷

    public BinarySearchTree() {
        super();
    }

    public BinarySearchTree(Node root) {
        super();
        this.root = root;
        this.num++;
    }

    public Node getRoot() {
        return root;
    }

    /**
     * 二叉查找樹添加節點
     * 
     * @param node
     * @return
     */
    public BinarySearchTree addNode(Node node) {
        this.num++;
        if (null == root) {
            root = node;
            return this;
        }
        addNode(node, root);
        return this;
    }

    /**
     * 遞歸插入節點
     * 
     * @param node
     * @param parent
     */
    private void addNode(Node node, Node parent) {
        if (node.getVal() > parent.getVal()) {
            if (null == parent.getRight()) {
                parent.setRight(node);
            } else {
                addNode(node, parent.getRight());
            }
        } else if (node.getVal() < parent.getVal()) {
            if (null == parent.getLeft()) {
                parent.setLeft(node);
            } else {
                addNode(node, parent.getLeft());
            }
        } else {
            return;
        }
    }

    /**
     * 中序遍歷
     */
    public int[] inorderTraversal() {
        if (this.num == 0) {
            return null;
        }
        this.index = 0;
        int[] vals = new int[this.num];
        inorderTraversal(getRoot(), vals);
        return vals;
    }

    /**
     * 遞歸遍歷
     * 
     * @param node
     * @param vals
     */
    private void inorderTraversal(Node node, int[] vals) {
        if (null == node) {
            return;
        }
        inorderTraversal(node.getLeft(), vals);
        vals[index++] = node.getVal();
        inorderTraversal(node.getRight(), vals);
    }

    @Override
    public String toString() {
        return "BSTree [root=" + root + "]";
    }
}

/**
 * <p>
 * 節點
 * </p>
 * 
 * @author Vicky
 * @date 2015-8-10
 */
class Node {
    private final int val;
    private Node left;
    private Node right;

    public Node(int val) {
        this(val, null, null);
    }

    public Node(int val, Node left, Node right) {
        super();
        this.val = val;
        this.left = left;
        this.right = right;
    }

    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 int getVal() {
        return val;
    }

    @Override
    public String toString() {
        return "Node [left=" + left + ", right=" + right + ", val=" + val + "]";
    }
}

一個測試類

import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
import java.util.Set;

/**
 * <p>
 * 二叉查找樹測試類
 * </p>
 * 
 * @author Vicky
 * @date 2015-8-10
 */
public class BinarySearchTreeTest {
    public static void main(String[] args) {
        BinarySearchTree tree = buildTree();
        int[] vals = tree.inorderTraversal();
        System.out.println(Arrays.toString(vals));

        for (int i = 0; i < 10; i++) {
            addNode(tree);
            vals = tree.inorderTraversal();
            System.out.println(Arrays.toString(vals));
        }
    }

    /**
     * 構造一顆二叉樹
     * 
     * @return
     */
    public static BinarySearchTree buildTree() {
        Random ran = new Random();
        Set<Integer> set = new HashSet<Integer>();
        for (int i = 0; i < 20; i++) {
            set.add(ran.nextInt(500));
        }
        BinarySearchTree tree = new BinarySearchTree();
        Iterator<Integer> ite = set.iterator();
        while (ite.hasNext()) {
            tree.addNode(new Node(ite.next()));
        }
        return tree;
    }

    public static BinarySearchTree addNode(BinarySearchTree tree) {
        Random ran = new Random();
        tree.addNode(new Node(ran.nextInt(1000)));
        return tree;
    }
}