二叉树的创建和遍历（递归和非递归），查找最大值，树的高度

为什么80%的码农都做不了架构师？>>>   

/**
 *   链式结构
 * @author gao.mq
 *
 */
public class BuildLinkedTree {
    private Node root;

    public class Node {
        private Node left;
        private Node right;
        private int value;

        public Node(int value) {
            this.value = value;
        }
    }

//插入一个值

    public void insert(int value) {
        root = insert(root, value);
    }

    private Node insert(Node node, int value) {
        if (node == null) {
            node = new Node(value);
        }
        int cmp = value - node.value;
        if (cmp > 0) {
            node.right = insert(node.right, value);
        } else if (cmp < 0) {
            node.left = insert(node.left, value);
        } else {
            node.value = value;
        }
        return node;
    }

    /**
     * 先序遍历
     * 
     * @param node
     */
    public void preorder(Node node) {
        if (node != null) {
            System.out.println(node.value);
            preorder(node.left);
            preorder(node.right);
        }
    }

    /**
     * 中序遍历
     * 
     * @param node
     */
    public void midorder(Node node) {
        if (node != null) {
            midorder(node.left);
            System.out.println(node.value);
            midorder(node.right);
        }
    }

    /**
     * 后序遍历
     * 
     * @param node
     */
    public void postorder(Node node) {
        if (node != null) {
            postorder(node.left);
            postorder(node.right);
            System.out.println(node.value);
        }
    }

    /**
     * 查找树
     * 
     * @param i
     * @return
     */
    public int get(int i) {
        return get(root, i);
    }

    private int get(Node node, int value) {
        if (node == null) {
            return 0;
        }
        int cmp = node.value - value;
        if (cmp > 0) {
            return get(node.left, value);
        } else if (cmp < 0) {
            return get(node.right, value);
        } else {
            return node.value;
        }
    }

  /**
     * 先序非递归遍历
     */
    public void preorder_dev() {
        Node node = root;
        Stack s = new Stack();
        while (node != null || !s.isEmpty()) {
            while (node != null) {
                s.push(node);
                System.out.println(node.value);
                node = node.left;
            }
            if (!s.isEmpty()) {
                node = (Node) s.pop();
                node = node.right;
            }
        }
    }

/**
   * 中序非递归遍历
   */

    public void midorder_dev() {
        Node node = root;
        Stack s = new Stack();
        while (!s.isEmpty() || node != null) {
            while (node != null) {
                s.push(node);
                node = node.left;
            }
            node = (Node) s.pop();
            System.out.println(node.value);
            node = node.right;
        }
    }

/**
     * 树的高度
     * 
     * @param node
     * @return
     */
    public int hightTree(Node node) {
        // 递归结束条件
        if (node == null) {
            return 0;
        }
        int left = hightTree(node.left) + 1;
        int right = hightTree(node.right) + 1;
        return left > right ? left : right;
    }

   //查找树中最大元素的值

 public int max() {
        return max(root).value;
    }

    private Node max(Node root) {
        // 递归结束条件
        if (root.right == null) {
            return root;
        }
        return max(root.right);
    }

    public int floor(int value) {
        return floor(root, value).value;
    }

    /**
     * <pre>
     *   小于等于value的最大值
     *  思路：既然<=value 则肯定在左子树中，
     *   如果左子树有右子树，则在右子树中查找。
     *   右子树t不为null，则查找结点为t。否则为当前结点。
     * </pre>
     * 
     * @param root
     * @param value
     * @return
     */
    private Node floor(Node root, int value) {
        if (root == null) {
            return null;
        }
        int cmp = root.value - value;
        if (cmp == 0)
            return root;
        else if (cmp > 0) {
            return floor(root.left, value);
        }
        /**
         * 存在右子树时
         */
        Node t = floor(root.right, value);
        if (t != null)
            return t;
        else
            return root;
    }

    public static void main(String[] args) {
        BuildLinkedTree tree = new BuildLinkedTree();
        tree.insert(5);
        tree.insert(3);
        tree.insert(6);
        tree.insert(1);
        tree.insert(2);
        tree.insert(10);
        // tree.preorder(tree.root);
        // tree.midorder(tree.root);
        // tree.postorder(tree.root);
        System.out.print(tree.get(10));
    }

}

转载于:https://my.oschina.net/gaomq/blog/1359251