Day15--数据结构与算法（Java)二叉树层次遍历，翻转，对称

最新推荐文章于 2024-07-09 16:46:46 发布

敲代码中……

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量228

点赞数

分类专栏： leetcode题库文章标签： java 算法数据结构力扣

本文链接：https://blog.csdn.net/qq_52698263/article/details/128331552

版权

leetcode题库专栏收录该内容

38 篇文章 3 订阅

订阅专栏

117.填充每个节点的下一个右侧节点指针II

一、二叉树层序遍历

102.二叉树的层序遍历
107.二叉树的层次遍历II
199.二叉树的右视图
637.二叉树的层平均值
429.N叉树的层序遍历
515.在每个树行中找最大值
116.填充每个节点的下一个右侧节点指针
117.填充每个节点的下一个右侧节点指针II
104.二叉树的最大深度
111.二叉树的最小深度
102.二叉树的层序遍历

力扣题目链接

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>>resList=new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
    checkFun(root);
    return resList;
    }
    public void checkFun(TreeNode root)
    {
    if(root==null)
    return ;
    Queue<TreeNode>queue=new LinkedList<>();
    queue.offer(root);
    while(!queue.isEmpty())
    {
        List<Integer>list=new ArrayList<>();
        int size=queue.size();
        while(size>0){
        TreeNode node=queue.poll();
         list.add(node.val);
         if(node.left!=null)  queue.offer(node.left);
         if(node.right!=null) queue.offer(node.right);
         size--;
        }    
        resList.add(list);
    }
    }
}

107.二叉树的层次遍历 II

力扣题目链接

相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>>resList=new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
    checkFun(root);
    return resList;
    }
    public void checkFun(TreeNode root)
    {
    if(root==null)  return;
    Queue<TreeNode> queue=new LinkedList<>();
    queue.offer(root);
    List<List<Integer>>result=new ArrayList<List<Integer>>();
    while(!queue.isEmpty())
    {
        List<Integer>list=new LinkedList<>();
        int size=queue.size();

        for(int i=0;i<size;i++)
        {
            TreeNode node=queue.poll();
            list.add(node.val);
            if(node.left!=null)  queue.offer(node.left);
            if(node.right!=null) queue.offer(node.right);
        }
        result.add(list);
    }
    for(int i=result.size()-1;i>=0;i--)
    {
        resList.add(result.get(i));
    }
    }
}

199.二叉树的右视图

力扣题目链接

层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。if(i==size-1) {list.add(node.val); }

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
    List<Integer>list=new ArrayList<>();
    Deque<TreeNode>deque=new LinkedList<>();
    if(root==null)
    return list;
    deque.offerLast(root);
    while(!deque.isEmpty())
    {
        int size=deque.size();
       for(int i=0;i<size;i++)
       {
           TreeNode node=deque.pollFirst();
           if(node.left!=null) deque.offerLast(node.left);
           if(node.right!=null) deque.offerLast(node.right);
           if(i==size-1)
           {
               list.add(node.val);
           }
       }
    }
    return list;
    }
}

637.二叉树的层平均值

力扣题目链接

本题就是层序遍历的时候把一层求个总和在取一个均值。在原来的基础上添加以下句子。

 {sum=sum+node.val;
       }
        list.add(sum/size);

429.N叉树的层序遍历

力扣题目链接

这道题依旧是模板题，只不过一个节点有多个孩子了。把原来左子树和右子树的判断条件改为孩子的判断条件。

 List<Node>children=node.children;
           if(children==null||children.size()==0)
           {
               continue;
           }
           for(Node child:children)
           {
               if(child!=null)
               {
                   deque.offerLast(child);
               }
           }
       }
       list.add(level);

515.在每个树行中找最大值

力扣题目链接

层序遍历，取每一层的最大值

添加以下句子

 int max=Integer.MIN_VALUE;
       for(int i=0;i<size;i++)
       {
         max=Math.max(max,node.val);
       }
       list.add(max);
    }

在JDK中，整形类型是有范围的，最大值为Integer.MAX_VALUE，即2147483647，最小值为Integer.MIN_VALUE -2147483648。
对整形最大值加1，2147483648（越界了），那么此时值为多少呢？结果是-2147483648，即是Integer.MIN_VALUE。
类似的，对Integer.MIN_VALUE取反或者取绝对值呢？仍为Integer.MIN_VALUE，因为值为-2147483648，绝对值2147483648超过Integer.MAX_VALUE 2147483647。
所以就有以下结果
Integer.MAX_VALUE + 1 = Integer.MIN_VALUE
Math.abs(Integer.MIN_VALUE) = Integer.MIN_VALUE （绝对值）
Long，short，byte的结论是相同的。

116.填充每个节点的下一个右侧节点指针

力扣题目链接

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        Queue<Node>queue=new LinkedList<>();
        if(root==null)  
        return root;
        queue.offer(root);

        while(queue.size()!=0)
        {
            int size=queue.size();

            Node cur=queue.poll();
            if(cur.left!=null) queue.offer(cur.left);
            if(cur.right!=null) queue.offer(cur.right);
        
        for(int i=1;i<size;i++)
        {
            Node next=queue.poll();
            if(next.left!=null) queue.offer(next.left);
            if(next.right!=null) queue.offer(next.right);
            cur.next=next;
            cur=next;
        }
        }
       return root;
    }
}

117.填充每个节点的下一个右侧节点指针II

力扣题目链接

这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道

可以直接把116的答案复制过去。

104.二叉树的最大深度

力扣题目链接

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。

while(!deque.isEmpty())
    {
       
     depth++;
    }

111.二叉树的最小深度

力扣题目链接

相对于 104.二叉树的最大深度，本题还也可以使用层序遍历的方式来解决，思路是一样的。

需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点。

添加以下句子

 if(node.left==null&&node.right==null) return depth;

二、226.翻转二叉树

力扣题目链接

注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！建议拿纸画一画，就理解了

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
    if(root==null)  return root;
    swap(root);
    invertTree(root.left);
    invertTree(root.right);
    return root;
    }
    public void swap(TreeNode root)
    {
        TreeNode tempNode=root.left;
        root.left=root.right;
        root.right=tempNode;
    }
}

迭代法，在层次遍历的基础上加上交换函数

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {return null;}
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.offer(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            while (size-- > 0) {
                TreeNode node = deque.poll();
                swap(node);
                if (node.left != null) {deque.offer(node.left);}
                if (node.right != null) {deque.offer(node.right);}
            }
        }
        return root;
    }

    public void swap(TreeNode root) {
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

三、101. 对称二叉树

力扣题目链接

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
    return  compare(root.left,root.right);
    }
    public boolean compare(TreeNode left,TreeNode right)
    {
    if(left!=null&&right==null)  return false;
    if(left==null&&right!=null)  return false;
    if(left==null&&right==null)  return true;
    if(left.val!=right.val)  return false;
    
    boolean outNode=compare(left.left,right.right);
    boolean inNode=compare(left.right,right.left);
    return outNode&&inNode;
    }
}