二叉搜索树的查找，插入，前序遍历，中序遍历，后序遍历

大学学的数据结构的都忘光了，重新学习~~~
暂时先写了二叉树的find insert ， 三种递归遍历
啊好想刷题啊5555555555555

/**
 * simple tree node
 */
public class Node {
    public int data;
    public Node leftChild; //left child
    public Node rightChild; //right child
}

/**
 * simple tree
 */

public class Tree {
    private Node root; // root node

    public void insert(int value){
        // pre data to new node
        Node newNode = new Node();
        newNode.data = value;

        // if tree don't have node , new node should become to root node
        if (root == null){
            root = newNode;
        }else {
            // if tree have child node , init current node to save root node, init parent save the last non-null node
            Node current = root;
            Node parent;

            //traverse
            while (true){
                parent = current;
                // if insert value small than current.data, join into leftchild
                if (value < current.data){
                    current = current.leftChild;

                    if (current == null){
                        parent.leftChild = newNode;
                        return;
                    }
                }else {
                    current = current.rightChild;
                    if (current == null){
                        parent.rightChild = newNode;
                        return;
                    }
                }
            }
        }
    }

    // search
    public Node find(int searchKey){
        // if don't have tree node , return this method;
        if (root == null){
            return null;
        }

        Node current = root;
        //traverse
        while (current.data != searchKey){
            if (searchKey < current.data){
                current = current.leftChild;
            }else{
                current = current.rightChild;
            }

            if (current == null){
                return null;
            }
        }

        return current;
    }

    /**
     * //Order traversal by recursive call, if array is
     *               4
     *             3   6
     *           1  5
     * and then traversal will order to 13546
     * @param node
     */
    public void inOrderTraverse(Node node){
        while (node != null){
            inOrderTraverse(node.leftChild);
            System.out.println("ndoe.value " + node.data);
            inOrderTraverse(node.rightChild);
        }
    }


    /**
     * //Order traversal by recursive call, if array is
     *               4
     *             3   6
     *           1  5
     * and then traversal will order to 43156
     * @param node
     */
    public void preOrderTraverse(Node node){
        while (node != null){
            System.out.println("ndoe.value " + node.data);
            preOrderTraverse(node.leftChild);
            preOrderTraverse(node.rightChild);
        }
    }


    /**
     * //Order traversal by recursive call, if array is
     *               4
     *             3   6
     *           1  5
     * and then traversal will order to 13564
     * @param node
     */
    public void postOrderTraverse(Node node){
        while (node != null){
            preOrderTraverse(node.leftChild);
            preOrderTraverse(node.rightChild);
            System.out.println("ndoe.value " + node.data);
        }
    }
}