Java实现二叉搜索树

package Tree;

/**
 * Created by ykanghe on 2016/9/8.
 */
public class BinSearchTree {
    //根节点
    Node root;

    //叶子节点
    private static class Node {
        public int iData;
        public int fData;
        public Node left;//左孩子
        public Node right;//右孩子

        Node(int iData, int fData) {
            this.fData = fData;
            this.iData = iData;
        }
    }

    /**
     * 向二叉树插入节点
     *
     * @param iData
     * @param fData
     */
    public void insert(int iData, int fData) {
        Node newNode = new Node(iData, fData);
        if (root == null) {//如果二叉树空，则插入是根节点
            root = newNode;
        } else {//否则从二叉树的根开始遍历
            Node i = root;//定义游标，从根
            Node parent;//每次遍历的父节点
            while (true) {
                parent = i;
                if (iData < i.iData) {
                    i = i.left;//如果插入的值比该节点小，则为该节点的做孩子
                    if (i == null) {//如果该节点的左孩子为空，则该未知就是插入的值
                        parent.left = newNode;
                        return;
                    }
                } else if (iData > i.iData) {
                    i = i.right;
                    if (null == i) {
                        parent.right = newNode;
                        return;
                    }
                } else {
                    return;
                }
            }
        }
    }

    /**
     * 查找某个节点
     *
     * @return
     */
    public Node find(int iData) {
        Node i = root;
        if (null != i) {
            while (i.iData != iData) {
                if (i.iData > iData) {
                    i = i.left;
                } else {
                    i = i.right;
                }
                if (null == i) {
                    return null;
                }
            }
        }
        return i;
    }

    /**
     * 先序遍历
     *
     * @param root
     */
    public void preOrderTravel(Node root) {
        if (null != root) {
            System.out.print(root.iData);
            preOrderTravel(root.left);//遍历左子树
            preOrderTravel(root.right);//遍历左子树
        }
    }

    /**
     * 中序遍历
     *
     * @param root
     */
    public void inOrder(Node root) {
        if (null != root) {
            inOrder(root.left);//遍历左子树
            System.out.print(root.iData);
            inOrder(root.right);//遍历左子树
        }
    }

    /**
     * 查找最小节点
     *
     * @return
     */
    public Node findMinNode() {
        Node i = root;
        Node l = null;
        if (i.left == null) {
            return root;
        } else {
            while (null != i) {
                l = i;
                i = i.left;
            }
            return l;
        }
    }

    /**
     * 查找二叉树最大节点
     *
     * @return
     */
    public Node findMaxNode() {
        Node i = root;
        Node l = null;
        if (null == i.right) {
            return i;
        } else {
            while (null != i) {
                l = i;
                i = i.right;
            }
            return l;
        }
    }
}