leetcode-simple+medium+difficult-共25题-04

76.删除字符串中的所有相邻重复项

package com.lxh.simple;
import java.util.Stack;

/**
 * @Author： Tiger
 * @Description： 删除字符串中的所有相邻重复项
 * 1. 时间43ms 击败25.35% 内存39.3MB 击败30.23%
 * 2. 附 String.copyValueOf(char[] data, int offset, int count)：(注意是字符数组)
 *    str1 = str1.copyValueOf(char[] data, int offset, int count)
 *    它使用指定的偏移量和计数值仅将指定的字符复制到字符串。
 *    offset是需要复制字符的初始索引，count是要复制的字符数。
 * @Date： 下午 14:43 2021/11/10 0010
 **/
public class RemoveAllAdjacentDuplicates1047 {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        StringBuilder result = new StringBuilder();
        stack.push('0');

        for (char ch : s.toCharArray()) {
            if (ch != stack.peek()) {
                stack.push(ch);
            }else {
                stack.pop();
            }
        }

        while (stack.peek() != '0') {
            result.append(stack.pop());
        }

        s = new String(result.reverse());
        return s;
    }
}

/*
class Solution {
    public String removeDuplicates(String s) {
        char[] chars = s.toCharArray();
        int slow = 0, fast = 0;
        while (fast < chars.length) {
            chars[slow] = chars[fast];
            //前后值相同，slow回退，下一次循环时会被fast指向的元素覆盖
            if (slow > 0 && chars[slow] == chars[slow - 1]) {
                slow--;
            } else {
                slow++;
            }
            fast++;
        }
        //String.copyValueOf(chars, 0, slow) 将chars字符数组中从0开始数到slow位置的字符串复制出来
        return String.copyValueOf(chars, 0, slow);
    }
}*/

77.用栈操作构建数组

package com.lxh.simple;

import java.util.LinkedList;
import java.util.List;

/**
 * @Author： Tiger
 * @Description： 用栈操作构建数组
 * 1. 时间0ms 击败100% 内存38.5MB 击败65.34%
 * @Date： 下午 15:31 2021/11/10 0010
 **/
public class BuildArrayWithStackOperations1441 {
    public List<String> buildArray(int[] target, int n) {
        List<String> result = new LinkedList<>();
        int j = 0;
        for (int i = 1; i <= n; i++) {
            if (i != target[j]) {
                result.add("Push");
                result.add("Pop");
            }else {
                result.add("Push");
                j++;
            }
            if (j == target.length)
                break;
        }
        return result;
    }
}

78.商品折扣后的最终价格

package com.lxh.simple;

import java.util.Stack;

/**
 * @Author： Tiger
 * @Description： 商品折扣后的最终价格
 * 1. 时间3ms 击败44.83% 内存38.6MB 击败32.50%
 * @Date： 下午 15:59 2021/11/10 0010
 **/
public class FinalPricesWithSpecialDiscount1475 {
    public int[] finalPrices(int[] prices) {
        int[] result = new int[prices.length];
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < prices.length; i++) {
            while (!stack.empty() && prices[i] <= prices[stack.peek()]) {
                int prev = stack.pop();
                result[prev] = prices[prev] - prices[i];
            }
            stack.push(i);
        }
        while (!stack.empty()) {
            int prev = stack.pop();
            result[prev] = prices[prev];
        }
        return result;
    }
}

79.整理字符串

package com.lxh.simple;

import java.util.Stack;

/**
 * @Author： Tiger
 * @Description： 整理字符串
 * 1. 时间3ms 击败34.67% 内存38.6MB 击败16.09%
 * @Date： 下午 16:16 2021/11/10 0010
 **/
public class MakeTheStringGreat1544 {
    public String makeGood(String s) {
        StringBuilder str = new StringBuilder();
        Stack<Character> stack = new Stack<>();
        for (char ch : s.toCharArray()) {
            if (!stack.empty() && (ch - 32 == stack.peek() || ch + 32 == stack.peek())) {
                stack.pop();
            }else {
                stack.push(ch);
            }
        }
        while (!stack.empty()) {
            str.append(stack.pop());
        }
        return str.reverse().toString();
    }

    public static void main(String[] args) {
        MakeTheStringGreat1544 mtsg1544 = new MakeTheStringGreat1544();
        String s1 = "leEeetcode";
        System.out.println(mtsg1544.makeGood(s1));
    }
}

/* 时间1ms 栈会慢一点 其他方法或许会更快一点
class Solution {
    public String makeGood(String s) {
        StringBuilder sb = new StringBuilder();
        for (char ch: s.toCharArray()
        ) {
            if (sb.length()>0 && Math.abs(ch - sb.charAt(sb.length()-1))==32){
                //删除字符
                sb.deleteCharAt(sb.length()-1);
            } else {
                sb.append(ch);
            }
        }
        return sb.toString();
    }
}*/

80.逆波兰表达式求值

package com.lxh.medium;

import java.util.Stack;

/**
 * @Author： Tiger
 * @Description： 逆波兰表达式求值
 * 1. 时间5ms 击败91.02% 内存38.2MB 击败32.62%
 * @Date： 下午 17:03 2021/11/10 0010
 **/
public class EvaluateReversePolishNotation0150 {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for (String token : tokens) {
            switch (token) {
                case "+":
                case "-":
                case "*":
                case "/":
                    int num1 = stack.pop();
                    int num2 = stack.pop();
                    int num = getResult(num2, num1, token);
                    stack.push(num);
                    break;
                default:
                    stack.push(Integer.parseInt(token));
            }
        }
        return stack.peek();
    }

    private int getResult(int num1, int num2, String token) {
        switch (token) {
            case "+":
                return num1 + num2;
            case "-":
                return num1 - num2;
            case "*":
                return num1 * num2;
            case "/":
                return num1 / num2;
        }
        return -1;
    }

}

81.基本计算器

package com.lxh.medium;

import java.util.Stack;

/**
 * @Author： Tiger
 * @Description： 基本计算器
 * 1. 时间28ms 击败8.91% 内存39.9MB 击败50.18% 实现了后缀表达式＋中缀表达式的计算
 * @Date： 下午 19:13 2021/11/10 0010
 **/
public class BasicCalculatorII0227 {
    public int calculate(String s) {
        Stack<Integer> stackNum = new Stack<>();
        Stack<Character> stackOps = new Stack<>();
        String t = "";

        for (int i = 0; i < s.length(); i++) {
            switch (s.charAt(i)) {
                case '+':
                case '-':
                    stackNum.push(Integer.parseInt(t));
                    while (!stackOps.empty()) {
                        getStack(stackNum, stackOps);
                    }
                    stackOps.push(s.charAt(i));
                    t = "";
                    break;
                case '*':
                case '/':
                    stackNum.push(Integer.parseInt(t));
                    while (!stackOps.empty() && (stackOps.peek() == '*' || stackOps.peek() == '/')) {
                        getStack(stackNum, stackOps);
                    }
                    stackOps.push(s.charAt(i));
                    t = "";
                    break;
                case ' ':
                    break;
                default:
                    t += s.charAt(i);
            }
        }
        stackNum.push(Integer.parseInt(t));
        while (!stackOps.empty()) {
            getStack(stackNum, stackOps);
        }
        int sum = 0;
        int count = 1;
        while (!stackNum.empty()) {
            sum += stackNum.pop()*count;
            count *= 10;
        }
        return sum;
    }

    private int getResult(int num1, int num2, char token) {
        switch (token) {
            case '+':
                return num1 + num2;
            case '-':
                return num1 - num2;
            case '*':
                return num1 * num2;
            case '/':
                return num1 / num2;
            default:
                return 0;
        }
    }

    private void getStack(Stack<Integer> stackNum, Stack<Character> stackOps) {
        int num1 = stackNum.pop();
        int num2 = stackNum.pop();
        char token = stackOps.pop();
        int num = getResult(num2, num1, token);
        stackNum.push(num);
    }

    public static void main(String[] args) {
        BasicCalculatorII0227 bcii0227 = new BasicCalculatorII0227();
        String s = "1*2-3/4+5*6-7*8+9/10";
        System.out.println(bcii0227.calculate(s));
    }
}

82.每日温度

package com.lxh.medium;

import java.util.Stack;

/**
 * @Author： Tiger
 * @Description： 每日温度
 * 1. 时间37ms 击败40.46% 内存47.6MB 击败82.25%
 * @Date： 下午 13:02 2021/11/11 0011
 **/
public class DailyTemperatures0739 {
    public int[] dailyTemperatures(int[] temperatures) {
        Stack<Integer> stack = new Stack<>();
        int[] result = new int[temperatures.length];
        for (int i = 0; i < temperatures.length; i++) {
            while (!stack.empty() && temperatures[i] > temperatures[stack.peek()]) {
                int prev =  i - stack.peek();
                result[stack.pop()] = prev;
            }
            stack.push(i);
        }
        return result;
    }
}

83.行星碰撞

package com.lxh.medium;

import java.util.Stack;

/**
 * @Author： Tiger
 * @Description： 行星碰撞
 * 1. 时间 10ms 击败11.90% 内存39.3MB 击败25.97%
 * @Date： 下午 14:28 2021/11/11 0011
 **/
public class AsteroidCollision0735 {
    public int[] asteroidCollision(int[] asteroids) {
        Stack<Integer> stack = new Stack<>();
        for (int as : asteroids) {
            while (!stack.empty() && stack.peek() > 0 && stack.peek() < -as) {
                stack.pop();
            }

            if (!stack.empty() && as < 0 && stack.peek() == -as) {
                stack.pop();
            }else if (stack.empty() || stack.peek() < 0 || as > 0) {
                stack.push(as);
            }
        }
        return stack.stream().mapToInt(i->i).toArray();
    }
}

84.移掉K位数字

package com.lxh.medium;

import java.util.Stack;

/**
 * @Author： Tiger
 * @Description： 移掉K位数字
 * 1. 时间10ms 击败40.84% 内存39MB 击败25.50%
 * 2. 要学会对各种遇到的情况进行判断 尤其是一些边界问题
 * @Date： 下午 15:03 2021/11/11 0011
 **/
public class RemoveKDigits0402 {
    public String removeKdigits(String num, int k) {
        Stack<Character> stack = new Stack<>();
        StringBuilder result = new StringBuilder();

        if (num.length() == k)
            return "0";

        for (char ch : num.toCharArray()) {
            while (!stack.empty() && ch < stack.peek() && k > 0) {
                stack.pop();
                k--;
            }
            if (stack.empty() && ch == '0') {
                continue;
            }
            stack.push(ch);
        }

        while (k > 0 && !stack.empty()) {
            stack.pop();
            k--;
        }

        if (stack.empty())
            result.append(0);

        while (!stack.empty()) {
            result.append(stack.pop());
        }

        return new String(result.reverse());
    }

    public static void main(String[] args) {
        RemoveKDigits0402 rkd0402 = new RemoveKDigits0402();
        String s = "10200";
        System.out.println(rkd0402.removeKdigits(s, 1));
    }
}

85.链表中的下一个更大节点

package com.lxh.medium;

import com.lxh.list.ListNode;

import java.util.Stack;

/**
 * @Author： Tiger
 * @Description： 链表中的下一个更大节点
 * 1. 时间16ms 击败64.83% 内存42.7MB 击败44.65%
 * @Date： 下午 16:42 2021/11/11 0011
 **/
public class NextGreaterNodeInLinkedList1019 {
    public int[] nextLargerNodes(ListNode head) {
        ListNode cur = head;
        int len = 0;

        while (cur != null) {
            len++;
            cur = cur.next;
        }

        int i = 0;
        cur = head;
        int[] result = new int[len];

        while (cur != null) {
            result[i++] = cur.val;
            cur =cur.next;
        }

        return getNum(result);
    }

    private int[] getNum(int[] nums) {
        Stack<Integer> stack = new Stack<>();
        int[] reNum = new int[nums.length];

        for (int i = 0; i < nums.length; i++) {
            while (!stack.empty() && nums[i] > nums[stack.peek()]) {
                int prev = stack.pop();
                reNum[prev] = nums[i];
            }
            stack.push(i);
        }

        return reNum;
    }
}

86.无法吃午餐的学生数量

package com.lxh.simple;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 无法吃午餐的学生数量
 * 1. 时间2ms 击败27% 内存36MB 击败87.04%
 * @Date： 下午 17:09 2021/11/13 0013
 **/
public class NumberStudentsUnableEatLunch1700 {
    public int countStudents(int[] students, int[] sandwiches) {
        Queue<Integer> queue = new LinkedList<>();
        int i = 0;
        int j = 0;
        int count = 0;

        for (int stu : students) {
            queue.offer(stu);
        }

        while (!queue.isEmpty()) {
            if (queue.peek() == sandwiches[i]) {
                queue.poll();
                i++;
                count = 0;
            }else {
                int cur = queue.poll();
                queue.offer(cur);
                count++;
            }
            if (count == queue.size()) {
                return count;
            }
        }
        return 0;
    }
}

87.滑动窗口最大值

package com.lxh.difficult;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 滑动窗口最大值
 * 1. 超出时间限制 需要进一步思考
 * @Date： 下午 18:16 2021/11/13 0013
 **/
public class SlidingWindowMaximum0239 {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Queue<Integer> queue = new LinkedList<>();
        int[] count = new int[nums.length - k + 1];
        int i = 0;

        for (int num : nums) {
            queue.offer(num);
            if (queue.size() == k) {
                count[i++] = maxValue(queue, k);
                queue.poll();
            }
        }

        return count;
    }

    private int maxValue(Queue<Integer> queue, int k) {
        int max = Integer.MIN_VALUE;
        int flag = 0;
        while (flag < k) {
            int cur = queue.poll();
            if (cur >= max) {
                max = cur;
            }
            queue.offer(cur);
            flag++;
        }
        return max;
    }
}

88.相同的树

package com.lxh.simple;

import com.lxh.method.TreeNode;

/**
 * @Author： Tiger
 * @Description： 相同的树
 * 1. 时间0ms 击败100% 内存35.6MB 击败88.05% 递归算法 again
 * @Date： 下午 21:12 2021/11/13 0013
 **/
public class SameTree0100 {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) return true;
        if (p == null) return false;
        if (q == null) return false;
        if (p.val == q.val) {
            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
        } else {
            return false;
        }
    }
}

89.二叉树的最小深度

package com.lxh.simple;

import com.lxh.method.TreeNode;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 二叉树的最小深度
 * 1. 时间1ms 击败99.30% 内存57.9MB 击败89.79%
 * @Date： 下午 21:56 2021/11/13 0013
 **/
public class MinimumDepthBinaryTree0111 {
    public int minDepth(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        int minDep = 1;
        int cur = 0;
        int count = 1;

        if (root != null) {
            queue.offer(root);
        }else {
            return 0;
        }

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            count--;

            if (node.left == null && node.right == null) {
                return minDep;
            }

            if (node.left != null) {
                queue.offer(node.left);
                cur++;
            }

            if (node.right != null) {
                queue.offer(node.right);
                cur++;
            }

            if (count == 0) {
                minDep++;
                count = cur;
                cur = 0;
            }
        }

        return minDep;
    }
}

90.二叉树的右视图

package com.lxh.medium;

import com.lxh.method.TreeNode;

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 二叉树的右视图
 * 1. 时间1ms 击败83.26% 内存36.9MB 击败85.24%
 * @Date： 下午 22:25 2021/11/13 0013
 **/
public class BinaryTreeRightSideView0199 {
    public List<Integer> rightSideView(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();

        List<Integer> result = new LinkedList<>();

        if (root == null) {
            return result;
        }

        queue1.offer(root);

        while (!queue1.isEmpty()) {
            TreeNode node = queue1.poll();

            if (node.left != null) {
                queue2.offer(node.left);
            }

            if (node.right != null) {
                queue2.offer(node.right);
            }

            if (queue1.isEmpty()) {
                result.add(node.val);
                queue1 = queue2;
                queue2 = new LinkedList<>();
            }
        }

        return result;
    }
}

91.二叉树的层序遍历

package com.lxh.medium;

import com.lxh.method.TreeNode;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 二叉树的层序遍历
 * 1. 时间1ms 击败90.73% 内存38.5MB 击败80.72%
 * @Date： 下午 19:50 2021/11/14 0014
 **/
public class BinaryTreeLevelOrderTraversal0102 {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> temp = new ArrayList<>();

        if (root != null) {
            queue1.offer(root);
        }

        while (!queue1.isEmpty()) {
            TreeNode node = queue1.poll();
            temp.add(node.val);

            if (node.left != null) {
                queue2.offer(node.left);
            }

            if (node.right != null) {
                queue2.offer(node.right);
            }

            if (queue1.isEmpty()) {
                queue1 = queue2;
                queue2 = new LinkedList<>();

                result.add(temp);
                temp = new ArrayList<>();
            }
        }

        return result;
    }
}

92.二叉树的锯齿形层序遍历

package com.lxh.medium;

import com.lxh.method.TreeNode;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 二叉树的锯齿形层序遍历
 * 1. 时间1ms 击败93.35% 内存38.3MB 击败91.91%
 * @Date： 下午 20:10 2021/11/14 0014
 **/
public class BinaryTreeZigzagLevelOrderTraversal0103 {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> temp = new ArrayList<>();
        int depth = 1;

        if (root != null) {
            queue1.offer(root);
        }

        while (!queue1.isEmpty()) {
            TreeNode node = queue1.poll();
            temp.add(node.val);

            if (node.left != null) {
                queue2.offer(node.left);
            }

            if (node.right != null) {
                queue2.offer(node.right);
            }

            if (queue1.isEmpty()) {
                queue1 = queue2;
                queue2 = new LinkedList<>();
                if (depth % 2 == 0) {
                    temp = reverse(temp);
                }
                result.add(temp);
                temp = new ArrayList<>();
                depth++;
            }
        }

        return result;
    }

    private List<Integer> reverse(List<Integer> temp) {
        List<Integer> reverseTemp = new ArrayList<>();

        for (int i = temp.size() - 1; i >= 0; i--) {
            reverseTemp.add(temp.get(i));
        }

        return reverseTemp;
    }
}

93.二叉树的层序遍历II

package com.lxh.medium;

import com.lxh.method.TreeNode;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 二叉树的层序遍历II （倒着输出）
 * 1. 时间1ms 击败94.80% 内存38.6MB 击败42.41%
 * @Date： 下午 20:17 2021/11/14 0014
 **/
public class BinaryTreeLevelOrderTraversalII0107 {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> temp = new ArrayList<>();

        if (root != null) {
            queue1.offer(root);
        }

        while (!queue1.isEmpty()) {
            TreeNode node = queue1.poll();
            temp.add(node.val);

            if (node.left != null) {
                queue2.offer(node.left);
            }

            if (node.right != null) {
                queue2.offer(node.right);
            }

            if (queue1.isEmpty()) {
                queue1 = queue2;
                queue2 = new LinkedList<>();
                result.add(temp);
                temp = new ArrayList<>();
            }
        }

        return reverse(result);
    }

    private List<List<Integer>> reverse(List<List<Integer>> result) {
        List<List<Integer>> reverseResult = new ArrayList<>();

        for (int i = result.size() - 1; i >= 0; i--) {
            reverseResult.add(result.get(i));
        }

        return reverseResult;
    }
}

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

package com.lxh.medium;

import com.lxh.method.TreeNode;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 在每个树行中找最大值
 * 1. 时间3ms 击败17.02% 内存38.7MB 击败40.09%
 * 2. 附 递归解法
 * @Date： 下午 20:47 2021/11/14 0014
 **/
public class FindLargestValueEachTreeRow0515 {
    public List<Integer> largestValues(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        List<Integer> res = new ArrayList<>();
        int max = Integer.MIN_VALUE;

        if (root != null) {
            queue1.offer(root);
        }

        while (!queue1.isEmpty()) {
            TreeNode node = queue1.poll();
            max = Math.max(max, node.val);

            if (node.left != null) {
                queue2.offer(node.left);
            }

            if (node.right != null) {
                queue2.offer(node.right);
            }

            if (queue1.isEmpty()) {
                res.add(max);
                max = Integer.MIN_VALUE;
                queue1 = queue2;
                queue2 = new LinkedList<>();
            }
        }

        return res;
    }
}

/**
 * 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 {
    // List<List<Integer>> res = new ArrayList();
    List<Integer> res = new ArrayList();
    public void helper(TreeNode node,int deep){
        // if(res.size()<deep){
        //     res.add(new ArrayList());
        // }
        if(res.size()<deep){
            res.add(deep-1,node.val);
        }else{
            int max = (node.val>res.get(deep-1))?node.val:res.get(deep-1);
            res.set(deep-1,max);
        }

        if(node.left!=null){
            helper(node.left,deep+1);
        }
        if(node.right!=null){
            helper(node.right,deep+1);
        }
    }
    public List<Integer> largestValues(TreeNode root) {
        if(root==null) return res;
        helper(root,1);
        return res;
    }
}*/

95.二叉树的层平均值

package com.lxh.simple;

import com.lxh.method.TreeNode;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 二叉树的层平均值
 * 1. 时间3ms 击败28.88% 内存40.4MB 击败33.26%
 * @Date： 下午 21:14 2021/11/14 0014
 **/
public class AverageLevelsBinaryTree0637 {
    public List<Double> averageOfLevels(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        List<Double> res = new ArrayList<>();
        double average = 0;
        int flag = 0;
        int len = 0;

        if (root != null) {
            queue1.offer(root);
        }

        while (!queue1.isEmpty()) {

            TreeNode node = queue1.poll();
            average += node.val;

            if (node.left != null) {
                queue2.offer(node.left);
            }

            if (node.right != null) {
                queue2.offer(node.right);
            }

            if (queue1.isEmpty()) {
                if (flag == 0) {
                    res.add(average);
                }else {
                    res.add(average / len);
                }
                len = queue2.size();
                queue1 = queue2;
                queue2 = new LinkedList<>();
                flag = 1;
                average = 0;
            }
        }

        return res;
    }
}

96.单值二叉树

package com.lxh.simple;

import com.lxh.method.TreeNode;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 单值二叉树
 * 1. 时间0ms 击败100% 内存35.9MB 击败54.83%
 * @Date： 下午 21:44 2021/11/14 0014
 **/
public class UnivaluedBinaryTree0965 {
    public boolean isUnivalTree(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();

        if (root != null) {
            queue1.offer(root);
        }

        while (!queue1.isEmpty()) {
            TreeNode node = queue1.poll();

            if (node.left != null) {
                if (node.val != node.left.val) {
                    return false;
                }
                queue2.offer(node.left);
            }

            if (node.right != null) {
                if (node.val != node.right.val) {
                    return false;
                }
                queue2.offer(node.right);
            }

            if (queue1.isEmpty()) {
                queue1 = queue2;
                queue2 = new LinkedList<>();
            }
        }

        return true;
    }
}

97.最大层内元素和

package com.lxh.medium;

import com.lxh.method.TreeNode;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 最大层内元素和
 * 1. 时间12ms 击败11.15% 内存41.3MB 击败47.96%
 * 2. 附 3ms 的代码
 * @Date： 下午 22:03 2021/11/14 0014
 **/
public class MaximumLevelSumBinaryTree1161 {
    public int maxLevelSum(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        int sumPrev = 0;
        int sumMax = Integer.MIN_VALUE;
        int treeDepth = 0;
        int depth = 1;

        if (root != null) {
            queue1.offer(root);
        }

        while (!queue1.isEmpty()) {
            TreeNode node = queue1.poll();
            sumPrev += node.val;

            if (node.left != null) {
                queue2.offer(node.left);
            }

            if (node.right != null) {
                queue2.offer(node.right);
            }

            if (queue1.isEmpty()) {
                if (sumPrev > sumMax) {
                    sumMax = sumPrev;
                    treeDepth = depth;
                }
                queue1 = queue2;
                queue2 = new LinkedList<>();
                sumPrev = 0;
                depth++;
            }
        }

        return treeDepth;
    }
}

/**
 * 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;
 *     }
 * }
 */

/* 运行时间3ms
class Solution {
    int[] levelSum = new int[10001];
    int depth=0;//记录节点深度
    public void inorder(TreeNode node, int level) {
        if (node != null) {
            inorder(node.left, level + 1);
            levelSum[level] += node.val;
            inorder(node.right, level + 1);
            depth=Math.max(depth,level);
        }
    }
    public int maxLevelSum(TreeNode root) {
        inorder(root, 1);
        int maxIdx = depth;
        for (int i = depth; i>=1;i--){//从最深的那一块开始遍历
            if( levelSum[i] > levelSum[maxIdx])//和官方的三元运算符一样
                maxIdx=i;
            else if(levelSum[i]==levelSum[maxIdx])//题目要求如果和一样，则返回最小层数
                maxIdx=i;
        }
        return maxIdx;
    }
}*/

98.层数最深叶子节点的和

package com.lxh.medium;

import com.lxh.method.TreeNode;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author： Tiger
 * @Description： 层数最深叶子节点的和
 * 1. 时间10ms 击败6.86% 内存39.7MB 击败64.42%
 * 2. 本次使用的是广度优先搜索 可以考虑用下 深度优先搜素试一试
 * 3. 目前从很多题目来看 深度优先搜索（采用的递归）耗时最少
 * @Date： 下午 13:55 2021/11/15 0015
 **/
public class DeepestLeavesSum1302 {
    public int deepestLeavesSum(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        int lastSum = 0;
        int curSum = 0;

        if (root != null) {
            queue1.offer(root);
        }

        while (!queue1.isEmpty()) {
            TreeNode node = queue1.poll();
            curSum += node.val;

            if (node.left != null) {
                queue2.offer(node.left);
            }

            if (node.right != null) {
                queue2.offer(node.right);
            }

            if (queue1.isEmpty()) {
                lastSum = curSum;
                queue1 = queue2;
                queue2 = new LinkedList<>();
                curSum = 0;
            }
        }

        return lastSum;
    }
}

99.开幕式焰火

package com.lxh.simple;

import com.lxh.method.TreeNode;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;

/**
 * @Author： Tiger
 * @Description： 开幕式焰火
 * 1. 时间4ms 击败16.30% 内存37.9MB 击败93.72%
 * @Date： 下午 14:39 2021/11/15 0015
 **/
public class OpeningCeremonyFireworks0044 {
    public int numColor(TreeNode root) {
        Queue<TreeNode> queue1 = new LinkedList<>();
        Set<Integer> numColor = new HashSet<>();

        queue1.offer(root);

        while (!queue1.isEmpty()) {
            TreeNode node = queue1.poll();
            numColor.add(node.val);

            if (node.left != null) {
                queue1.offer(node.left);
            }

            if (node.right != null) {
                queue1.offer(node.right);
            }
        }

        return numColor.size();
    }
}

100.二叉树的中序遍历（前序和后续对于递归就是调换顺序）

package com.lxh.simple;

import com.lxh.method.TreeNode;

import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

/**
 * @Author： Tiger
 * @Description： 二叉树的中序遍历（前序和后续对于递归就是调换顺序）
 * 1. 递归 时间0ms 击败100% 内存36.5MB 击败78.86%
 * 2. 迭代 时间0ms 击败100% 内存36.5MB 击败80.65%
 * @Date： 下午 16:22 2021/11/15 0015
 **/
public class BinaryTreeInorderTraversal0094 {
    /* 递归
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> nodes = new LinkedList<>();
        dfs(root, nodes);
        return nodes;
    }

    private void dfs(TreeNode root, List<Integer> nodes) {
        if (root != null) {
            dfs(root.left, nodes);
            nodes.add(root.val);
            dfs(root.right, nodes);
        }
    }*/

    //非递归
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> nodes = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;

        while (cur != null || !stack.isEmpty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }

            cur = stack.pop();
            nodes.add(cur.val);
            cur = cur.right;
        }

        return nodes;
    }
}