leetcode记录10.23栈与层序二叉树

Deque接口

Deque是个接口，其实现类有：

• ArrayDeque，使用“数组”存储数据
• LinkedList，使用“链表”存储数据(双向链表实现)
• ConcurrentLinkedDeque，线程安全的LinkedList

• 数据检索多的用ArrayDeque；
• 数据需要频繁插入 、更新，则用LinkedList；
• 多线程操作使用ConcurrentLinkedDeque。

当做栈使用的时候,我们要使用

push和pop方法进行操作

当做队列使用的时候,我们要使用

offer和poll方法进行操作

Queue使用时要尽量避免Collection的add()和remove()方法，而是要使用offer()来加入元素，使用poll()来获取并移出元素。它们的优点是通过返回值可以判断成功与否，add()和remove()方法在失败的时候会抛出异常。 如果要使用前端而不移出该元素，使用element()或者peek()方法。

栈例题

剑指 Offer 31. 栈的压入、弹出序列 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        // Queue stack = new Queue();
  Deque<Integer> stack = new ArrayDeque<>();
        int j = 0;
        for (int e : pushed) {
            stack.push(e);
            while (j < popped.length&&!stack.isEmpty() && stack.peek()==(popped[j])) {
                stack.poll();
                j++;
            }
        }
        return j == popped.length;
    }
    
}

层序遍历例题

剑指 Offer 32 - I. 从上到下打印二叉树 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * 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) {
if(root==null){
    return new int[0];
}
        Deque<TreeNode> deque = new ArrayDeque<TreeNode>();
        deque.offer(root);
        ArrayList<Integer> list = new ArrayList<>();
        while (!deque.isEmpty()) {
            TreeNode e = deque.poll();
            list.add(e.val);
        if (e.left != null) {
                deque.offer(e.left);
            }
            if (e.right != null) {
                deque.offer(e.right);
            }
        }
        int[] ints = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            ints[i] = list.get(i);
        }
        return ints;

    }
}

剑指 Offer 32 - II. 从上到下打印二叉树 II - 力扣（LeetCode） (leetcode-cn.com)

/**
 * 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) {
    List<List<Integer>> ret = new ArrayList<>();
            if (root == null) {
                return new ArrayList<>();
            }
            Deque<TreeNode> dequew = new ArrayDeque<>();

            dequew.offer(root);

                      while (!dequew.isEmpty()) {
                Deque<TreeNode> dequen = new ArrayDeque<>();
                ArrayList<Integer> list = new ArrayList<Integer>();
                while (!dequew.isEmpty()) {
                    TreeNode node = dequew.poll();
                    list.add(node.val);
                    if (node.left != null) {
                        dequen.offer(node.left);
                    }
                    if (node.right != null) {
                        dequen.offer(node.right);
                    }
                }
                ret.add(list);
                dequew = dequen;
            }

            return ret;
    }
}

剑指 Offer 32 - III. 从上到下打印二叉树 III - 力扣（LeetCode） (leetcode-cn.com)

/**
 * 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) {
        List<List<Integer>> ret = new LinkedList<>();
        if(root == null){
            return ret;
        }
        //应该用i技术表示层数,技术左到右,偶数右到左
       
        Deque<TreeNode> deque = new ArrayDeque<>();
        deque.offer(root);
            int lever = 0;  
        while(!deque.isEmpty()){
            LinkedList<Integer> list = new LinkedList<>();
      
            int size = deque.size();
            for(int k = 0;k<size;k++){
                TreeNode node = deque.poll();
                    
                //单层
                if(lever%2!=0){
                    list.addFirst(node.val);
                }else{
                    list.addLast(node.val);
                }

                    if(node.left!=null){
                        deque.offer(node.left);
                    }    
                    if(node.right!=null){
                        deque.offer(node.right);
                    }
            }
            lever++;
            ret.add(list);
            
        }
        return ret;
    }
    
}