226翻转二叉树 101 对称二叉树

226反转二叉树

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

中心思想就是，遍历节点，对每个节点swap，所以遍历的顺序很重要，

可以层序遍历，可以DFS，所以二叉树遍历的算法非常重要

//递归法：

// class Solution {
//     public TreeNode invertTree(TreeNode root) {

//         return inverNode(root);


//     }

//     public TreeNode inverNode(TreeNode node){
//         if (node==null||(node.left==null&&node.right==null)) return node;
//         TreeNode temp;
//         temp=node.left;
//         node.left=inverNode(node.right);
//         node.right=inverNode(temp);
//         return node;
//     }
// }

BFS:

class Solution {
    public TreeNode invertTree(TreeNode root) {
                //用BFS
        Deque<TreeNode> nodeDeque=new LinkedList();
        if(root==null){return root;}
        nodeDeque.add(root);
        while(!nodeDeque.isEmpty()){
            int len=nodeDeque.size();
            while(len>0){
                TreeNode temp=nodeDeque.poll();
                    swapNode(temp);
                    if(temp.left!=null){
                    nodeDeque.add(temp.left);}
                    if(temp.right!=null)
                    nodeDeque.add(temp.right);
                    len--;
            }

        }return root;
        


    }
    public TreeNode swapNode(TreeNode node){
            if(node==null) return node;
            TreeNode temp=node.left;
            node.left=node.right;
            node.right=temp;
            return node;
    } 
}

class Solution {
    public TreeNode invertTree(TreeNode root) {

        //DFS ;遍历每一个节点，然后swap。
        Stack<TreeNode> stack=new Stack();
        //前序
        if(root==null){return root;}
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode temp=stack.pop();
            swap(temp);
            if(temp.left!=null){
            stack.push(temp.left);}
            if(temp.right!=null)
            stack.push(temp.right);
        }
        return root;


    }

    public void swap(TreeNode node){
            if(node==null){return ;}
        TreeNode temp=node.left;
        node.left=node.right;
        node.right=temp;
    }
}

101 对称二叉树

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
    public boolean isSymmetric(TreeNode root) {
                return same(root.left,root.right);

    }

    public boolean same(TreeNode leftNode,TreeNode rightNode){
            boolean res=false;
        if(leftNode==null&&rightNode==null){return true;}
        else if(leftNode==null&&rightNode!=null){return false;}
        else if(leftNode!=null&&rightNode==null){return false;}
        else if(leftNode.val==rightNode.val){
            res=same(leftNode.left, rightNode.right)&&same(leftNode.right, rightNode.left); 
        }
        return res;
    }

}

---

 637二叉树的层均值

 力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        Deque<TreeNode> deque=new LinkedList();
        List<Double> res=new ArrayList<Double>();
        if(root==null){
            return res;
        }
        double sum=0;
        int lent=0;
        deque.offer(root);
        while(!deque.isEmpty()){
            sum=0;
            int len=deque.size();
            lent=len;
            while(len>0){
            TreeNode temp=deque.poll();
            sum+=(temp.val);
            if(temp.left!=null){
                deque.offer(temp.left);
            }
            if(temp.right!=null){
                deque.offer(temp.right);
            }
            len--;
            }

            res.add(sum/lent);

        }
        return res;

    }
}

这个题主要是要注意double和int的转换，之前直接用

sum+=temp.val/lent

 答案就不对，

---

 429 N叉树的层序遍历

 力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        
        //终止条件换成children!=null
        Deque<Node> deque=new LinkedList();
        if(root==null){return new ArrayList();}
        deque.offer(root);
        List<List<Integer>> res=new ArrayList();
        while(!deque.isEmpty()){
            List<Integer> tempRes=new ArrayList();
            int len=deque.size();
            while(len>0){
                Node temp=deque.poll();
                tempRes.add(temp.val);
                if(!temp.children.isEmpty()){
                    for(Node nodes:temp.children){
                        deque.offer(nodes);
                    }
                }
                len--;
            }res.add(tempRes);
        }
        return res;
        
    
    }
    
}

---

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        //大顶堆放每层的元素
        Deque<TreeNode> que=new LinkedList();
        if(root==null){return new ArrayList();}
        que.offer(root);
        List<Integer> res=new ArrayList();
        while(!que.isEmpty()){
            int len=que.size();
            PriorityQueue<TreeNode> tempQ=new PriorityQueue(
                new Comparator<TreeNode>(){
                    public int compare(TreeNode t1,TreeNode t2){
                        return -t1.val+t2.val;
                    }
                }
            );

            while(len>0){
                TreeNode temp=que.poll();
                tempQ.add(temp);
                if(temp.left!=null){
                    que.add(temp.left);
                }
                if(temp.right!=null){
                    que.add(temp.right);
                }

                len--;
            }
            res.add(tempQ.poll().val);


        }
return res;

    }
}

 

---

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

class Solution {
    public Node connect(Node root) {
        Deque<Node> que=new LinkedList();
        if(root==null){
            return root;
        }
        que.offer(root);
        List<Node> list=new ArrayList();
        while(!que.isEmpty()){
            int len=que.size();
            while(len>0){
                
                Node temp=que.poll();
                if(temp.left!=null){
                  que.offer(temp.left);
                }
                if(temp.right!=null){
                  que.offer(temp.right);
                }
                temp.next=que.peek(); 
                if(len==1){temp.next=null;}
                len--;
            }


        }
        return root;    



        


    }
}