手撕二叉树

Posted 二九幂加八

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了手撕二叉树相关的知识,希望对你有一定的参考价值。

本篇涉及从上到下打印二叉树、二叉树深度

这两类题目,都是层序遍历,相对来说比较容易 以下共四道题目

分别来自于 

剑指 Offer 32 - I 

剑指 Offer 32 - II 

剑指 Offer 32 - III 

剑指 Offer 55 - I

剑指 Offer 32 - I

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] levelOrder(TreeNode root) {
        // 用集合(ArrayList集合,有序的)去添加层序遍历的结果,最后将集合再转为数组
        // 为什么不直接用int[]接收?节点数目不确定,如果你确定一个值,后面全0了啊,所以很自然的想到集合,动态分配
        List<Integer> ans = new ArrayList<>();
        // 先来判空,root如果为null的话,直接return一个空数组
        if (root==null) {
            return new int[0];
        }
        // 初始化队列
        Queue<TreeNode> q = new LinkedList<>();
        // 将root加入队列
        q.offer(root);
        // 如果不为空,就一直循环下去
        while (!q.isEmpty()) {
            // 利用队列的特性,先进先出,将头部依次弹出
            TreeNode cur = q.poll();
            // 把弹出来的这个节点先加入集合
            ans.add(cur.val);
            // 当然是先左后右了,顺序结构语句,所以先判断左节点是否为空
            if (cur.left != null) {
                q.offer(cur.left);
            }
            // 再判断右节点是否为空
            if (cur.right != null) {
                q.offer(cur.right);
            }
        }
        // 题目要求返回整型数组,那就再遍历一次吧
        int[] ints = new int[ans.size()];
        for (int i = 0; i < ans.size(); i++) {
            ints[i] = ans.get(i);
        }
        // 最终返回
        return ints;
    }
}

剑指 Offer 32 - II

手撕二叉树
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
     // 老规矩,根据返回类型new一个对象,这里返回的是List集合,不用再处理什么了,直接new吧
        List<List<Integer>> lists = new ArrayList<>();
        // 判断空
        if (root == null) {
         // 比之前返回数组好一点,直接返回lists即可
            return lists;
        }
        // 初始化队列
        Queue<TreeNode> queue = new LinkedList<>();
        // 将root加入队列,队列此时只有一个元素
        queue.offer(root);
        // 继续循环吧
        while (!queue.isEmpty()) {
         // 这个题,要按照行再存放在一个集合中,那么就new一个集合吧
            List<Integer> temp = new ArrayList<>();
            // 此时就不能盲目的添加了,要有条件的去判断,用for循环判断一层有多少节点
            // 第一次循环,只有root,循环一次遍退出,这时往队列加了两个元素(先认为是满二叉树)
            // 你想想,第二次,进入for循环的时候,之前可是往队列里加了两个元素,然后第三次又加了四个元素,这个for循环是关键
            for (int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                temp.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            // 一层节点添加完后,再加到lists集合中(lists便是那个集合套集合的对象)
            lists.add(temp);
        }
        // 最终返回lists
        return lists;
    }
}

剑指 Offer 32 - III

手撕二叉树
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
    
     // start
        List<List<Integer>> lists = new ArrayList<>();
        if (root == null) {
            return lists;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        // end
        
        while (!queue.isEmpty()) {
         // 选好合适的数据结构
         // 来个双端队列,来处理奇偶层——左到右遍历,右到左遍历
            LinkedList<Integer> temp = new LinkedList<>();
            for (int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                if (lists.size()%2==0) {
                 // 如果是偶数层,那么就addLast,在链表头部添加
                    temp.addLast(node.val);
                } else if(lists.size()%2==1) {
                 // 如果是奇数层,那么就addLast,在链表尾部添加
                    temp.addFirst(node.val);
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            lists.add(temp);
        }
        return lists;
    }
}

剑指 Offer 55 - I

不追求花式解题!

深度会想到什么?

我想到是一层一层的

一层一层的又想到什么?

想到层序遍历通过for循环可以控制行输出

所以模板就打通了

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
     // 用count记录一下深度吧,应该用depth吧,算了,代码已经写好了,不改了,无伤大雅
        int count = 0;
        // 先来判空,root如果为null的话,那深度就是0了
        if (root==null) {
            return count;
        }
        // 初始化队列
        Queue<TreeNode> q = new LinkedList<>();
        // 将root加入队列
        q.offer(root);
        // 如果不为空,就一直循环下去
        while (!q.isEmpty()) {
            // 判断树深,想一想,是不是得一行完了就记数(+1),一行一行的操作,那必须for循环控制一下
            for (int i = q.size(); i > 0; i--) {
                TreeNode cur = q.poll();
                if (cur.left != null) {
                    q.offer(cur.left);
                }
                if (cur.right != null) {
                    q.offer(cur.right);
                }
            }
            // 每层搞完以后+1一下,表示树深+1
            count++;
        }
        return count;
    }
}

感谢

感谢大家,可以看到这里,统一一个思路去写一类题目,这才是关键,我算法的知识储备不是很好,坚持练下去,只有练好数据结构与算法,才能写好代码,而不是CV大法。


以上是关于手撕二叉树的主要内容,如果未能解决你的问题,请参考以下文章

手撕二叉树的4种遍历:前序中序后序层序

手撕二叉树的4种遍历:前序中序后序层序

手撕二叉搜索树(Binary Search Tree)

手撕二叉搜索树(Binary Search Tree)

手撕二叉搜索树(Binary Search Tree)

风哥带你手撕算法之吃透二叉树(初版)