队列、栈 2023年11月8日总结

@Override
    public boolean offer(E e) {
        Node<E> added=new Node<>(e,head);
        tail.next=added;
        tail=added;
        return true;
    }

//队列尾指针插入元素，头指针删除元素

环形数组（tail+1）%数组长度==head 说明环形数组已满，其实空了一个元素，但如果head==tail则无法判断数组是满还是空；

（可以添加第三个变量来减少那个位置的缺失，不够时间复杂度增高）

二进制除法

商是高位

余数是除数几位余数就几位，相当于右移

与运算       

按位与运算 2的n次方与2的n次方-1按位与运算位0

102. 二叉树的层序遍历 - 力扣（LeetCode）

/**
 * 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>> levelOrder(TreeNode root) {
        
        List<List<Integer>> lists=new LinkedList<>();
        if(root==null){
            return lists;
        }
        Queue<TreeNode> queue=new  LinkedList<>(); 
        queue.offer(root);
        int c1=1;
        while(!queue.isEmpty()){
            List<Integer> list=new LinkedList<>();
            
            int c2=0;
            for(int i=0;i<c1;i++){
                TreeNode node=queue.poll();
                list.add(node.val);
                if(node.left!=null){
                    queue.offer(node.left);
                    c2++;
                }
                if(node.right!=null){
                    queue.offer(node.right);
                    c2++;
                }
                
            }
            lists.add(list);
            c1=c2;
        }
        return lists;

    }
}

   栈

队列

20. 有效的括号 - 力扣（LeetCode）

class Solution {
    public static boolean  isValid(String s){
        if(s==null)return true;
        
        Stack<Character> stack=new Stack<>();
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            //先将所有右括号入栈
            if(c=='('){
                stack.push(')');
            }
            else if(c=='['){
                stack.push(']');
            }else if(c=='{'){
                stack.push('}');
            }else{
                if(!stack.isEmpty()&&stack.peek()==c) {//非空才能判断是否可以出栈，右括号比左括号多会出现这种情况
                    stack.pop();
                }else{
                    return false;
                }
            }
        }
        if(stack.isEmpty()){
            return true;
        }else{
            return false;
        }
    }
}

后缀表达式求值

150. 逆波兰表达式求值 - 力扣（LeetCode）

LInkedList实现队列(Queue)和堆栈(Stack)_linkedlist stack-CSDN博客(LinkeList可以实现队列和栈内的方法)

class Solution {
    public int evalRPN(String[] tokens){
        LinkedList<Integer> stack=new LinkedList<>();
   
        for (String s : tokens) {
            switch(s){
                case  "+":
                    Integer p1 = stack.pop();
                    Integer p2 = stack.pop();
                    stack.push(p1+p2);  
                    break;
                case  "-":
                    Integer p3 = stack.pop();
                    Integer p4 = stack.pop();
                    stack.push(p4-p3);
                    break;
                case  "*":
                    Integer p5 = stack.pop();
                    Integer p6 = stack.pop();
                    stack.push(p6*p5);
                    break;
                case  "/":
                    Integer p7= stack.pop();
                    Integer p8 = stack.pop();
                    stack.push(p8/p7);
                    break;
                default:stack.push(Integer.parseInt(s));// 通过Integer包装类将数组内的数字压入栈中   
            }
          
        }


          return stack.pop();
}
}

Java将中缀表达式转化为底层的后缀表达式

后缀表达式如下