二叉树每行最左（右）边节点-最优-性能优化

如何输出二叉树每行最左边节点，个人观念点，如何记录二叉树的深度，当前二叉树深度，只输出一个值，且为最左侧，其他都不输出，采用java的hashMap判断。

算法初探

首先定义一颗树

 static class Btree<T> {
        T data;
        Btree left;
        Btree right;

        public Btree(T data) {
            this.data = data;
        }
    }

其次添加遍历
一开始思维想法是能否先把左侧所有节点列出来，记录深度，此时已经有了深度出现，其他不会右侧的左侧树出现，则不会打印。因此真正的实现算法如下

  public static void printBtreeFirst(Btree<Integer> btree, int dept, Map<Integer, Integer> map) {
        if (btree == null) {
            return;
        }
        if (map.get(dept) == null) {
            map.put(dept, btree.data);
        }
        if (btree.left != null) {
            printBtreeFirst(btree.left, dept + 1, map);
        }
        if (btree.right != null) {
            printBtreeFirst(btree.right, dept + 1, map);
        }
    }

最后验证实验

  Btree btree = new Btree(1);
        btree.left = new Btree(2);
        btree.right = new Btree(3);
        btree.left.left = new Btree(4);
        btree.left.right = new Btree(5);
        btree.right.left = new Btree(6);
        btree.right.right = new Btree(7);
        btree.right.right.right = new Btree(8);
        Map<Integer, Integer> map = new HashMap<>();
        printBtreeFirst(btree, 1, map);
        map.values().forEach(item -> {
            System.out.print(item);
        });

至于最左还是最右，只需要调换一下递归位置即可！

算法优化

我们知道，递归可能充满未知，还有可能出现递归栈异常，非递归写法优化

/**
     * 定义结构体，存放当前节点深度
     *
     * @param <T>
     */
    static class Struct<T> {
        T tree;
        int dept;

        public Struct(T tree, int dept) {
            this.tree = tree;
            this.dept = dept;
        }
    }

    /**
     * 返回节点，自动扩容2的次方，最小内存，返回数据时，不存在数据即为0
     *
     * @param btree
     * @return
     */
    public static int[] printBtree(Btree<Integer> btree) {
        if (btree == null) {
            return new int[0];
        }
        int[] printData = new int[2 << 2];
        Stack<Struct<Btree<Integer>>> stack = new Stack<>();
        stack.push(new Struct(btree, 0));
        while (!stack.empty()) {
            Struct<Btree<Integer>> struct = stack.pop();
            if (printData.length <= struct.dept) {
                printData = Arrays.copyOf(printData, printData.length << 2);
            }
            if (printData[struct.dept] == 0) {
                printData[struct.dept] = struct.tree.data;
            }
            if (struct.tree.right != null) {
                stack.push(new Struct(struct.tree.right, struct.dept + 1));
            }
            if (struct.tree.left != null) {
                stack.push(new Struct(struct.tree.left, struct.dept + 1));
            }
        }
        return printData;
    }