树

高度 深度 层

二叉树

前序遍历 中序遍历 后序遍历 深度遍历 广度遍历

完全二叉树

满二叉树

树的高度h=log2(n)

二叉查找树

中序遍历为从大到小排列 ,二叉排序树O(n) 查找 时间复杂度 o(h) 树的高度 o(n) - O(log(n))

平衡二叉查找树

AVG树

红黑树

堆

完全二叉树

存储方式

数组

##链表

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }

    public void setValue(int x) {
        val = x;
    }
}

public class BiTree {
    public TreeNode root = null;

    public BiTree(int[] args, int i) {
        root = preCreate(args, i);
        root = stackCreate(args);
    }

    private TreeNode preCreate(int[] args, int i) {
        TreeNode node = null;
        if (i < args.length) {
            int value = args[i];
            node = new TreeNode(value);
            node.left = preCreate(args, 2 * i + 1);
            node.right = preCreate(args, 2 * i + 2);
        }
        return node;
    }

    private TreeNode stackCreate(int[] args) {
        LinkedList q = new LinkedList();
        int i = 0;
        TreeNode root = new TreeNode(args[0]);
        q.offer(root);
        while (!q.isEmpty()) {
            TreeNode node = (TreeNode) q.poll();
            if (i < args.length / 2) {
                TreeNode left = new TreeNode(args[i * 2 + 1]);
                TreeNode right = new TreeNode(args[i * 2 + 2]);
                node.left = left;
                node.right = right;
                q.offer(left);
                q.offer(right);
                i++;
            }
        }
        return root;
    }

    public void preOrder(TreeNode root) {
        if (root != null) {
            showData(root);
            preOrder(root.left);
            preOrder(root.right);
        }
    }

    public void inOrder(TreeNode root) {
        if (root != null) {
            inOrder(root.left);
            showData(root);
            inOrder(root.right);
        }
    }

    public void postOrder(TreeNode root) {
        if (root != null) {
            postOrder(root.left);
            postOrder(root.right);
            showData(root);
        }
    }

    private void showData(TreeNode node) {
        System.out.println(node.val);
    }

    public void noRecursionPreOrder(TreeNode node) {
        Stack stack = new Stack();
        if (node != null) {
            stack.push(node);
            while (!stack.empty()) {
                node = (TreeNode) stack.pop();
                showData(node);
                if (node.right != null) {
                    stack.push(node.right);
                }
                if (node.left != null) {
                    stack.push(node.left);
                }
            }
        }
    }

    // 寻找最深左节点,入栈;
    // 出栈,输出
    // 指向右节点
    public void noRecursionInOrder(TreeNode node) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = node;
        while (p != null || stack.size() > 0) {
            while (p != null) {
                stack.push(p);
                p = p.left;
            }
            if (stack.size() > 0) {
                p = stack.pop();
                showData(p);
                p = p.right;
            }
        }
    }


    public void noRecursionPostOrder(TreeNode node) {
        Stack<TreeNode> stack = new Stack();
        TreeNode p = node;
        TreeNode prev = null;
        while (p!= null || stack.size() > 0) {
            if (p!= null) {
                stack.push(p);
                p = p.left;
            }
            while (stack.size() > 0) {
                if (stack.peek().right == null || stack.peek().right == prev) {
                    TreeNode w = stack.pop();
                    showData(w);
                    prev = w;
                } else {
                    stack.push(stack.peek().right);
                    break;
                }
            }
        }
    }

    //利用栈, 根右左出栈,队列首插入,得到结果.
    public void noRecursionPostOrder2(TreeNode node) {

    }

    public void noRecursionLevelOrder(TreeNode node) {
        LinkedList<TreeNode> l = new LinkedList<TreeNode>();
        TreeNode p = node;
        l.offer(p);
        while (l.size() > 0) {
            p = l.poll();
            showData(p);
            if (p.left != null) {
                l.offer(p.left);
            }
            if (p.right != null) {
                l.offer(p.right);
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        BiTree tree = new BiTree(arr, 0);
//        tree.preOrder(tree.root);
//        tree.inOrder(tree.root);
//        tree.postOrder(tree.root);
//        System.out.println();
//        tree.noRecursionPreOrder(tree.root);
//        tree.noRecursionInOrder(tree.root);
//        tree.noRecursionPostOrder(tree.root);
        tree.noRecursionLevelOrder(tree.root);
    }
}