算法技巧-队列

已于 2022-09-01 15:40:50 修改
阅读量192 收藏
点赞数
分类专栏： leetCode 算法 文章标签： 算法 leetcode java
于 2022-09-01 00:46:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41282486/article/details/126617075
版权

例 1：二叉树的层次遍历

题解：

/**
 * 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>> res = new ArrayList<>();
        if (null == root) {
            return res;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (queue.size() > 0) {

            int number = queue.size();
            List<Integer> list = new ArrayList<>();

            for (int i = 0; i < number; i ++) {
                
                TreeNode curNode = queue.poll();
                list.add(curNode.val);

                if (null != curNode.left) {
                    queue.offer(curNode.left);
                }

                if (null != curNode.right) {
                    queue.offer(curNode.right);
                }

            }
            
            res.add(list);
        }

        return res;
    }
}

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

题解：

/*
// 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) {

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

        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);

        while (queue.size() > 0) {

            int number = queue.size();

            for (int i = 0; i < number; i ++) {
                Node curNode = queue.poll();

                if (number - 1 != i) {
                    curNode.next = queue.peek();
                }

                if (null != curNode.left) {
                    queue.offer(curNode.left);
                }

                if (null != curNode.right) {
                    queue.offer(curNode.right);
                }
            }
        }

        return root;
    }
}

662. 二叉树最大宽度

题解：

/**
 * 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 {
    private class Pair {

        private TreeNode node;
        
        private int id;

        public Pair(TreeNode node, int id) {
            this.node = node;
            this.id = id;
        }
    }
    public int widthOfBinaryTree(TreeNode root) {

        int ans = 0;
        Queue<Pair> queue = new LinkedList<>();
        queue.offer(new Pair(root, 1));

        while (queue.size() > 0) {
            int curSize = queue.size();
            int start = -1;
            int end = -1;

            for (int i = 0; i < curSize; i ++) {

                Pair curPair = queue.poll();
                if (-1 == start) {
                    start = curPair.id;
                }

                end = curPair.id;

                if (null != curPair.node.left) {
                    queue.offer(new Pair(curPair.node.left, curPair.id << 1));
                }

                if (null != curPair.node.right) {
                    queue.offer(new Pair(curPair.node.right, (curPair.id << 1) + 1));
                }
            }

            ans = Math.max(ans, end - start + 1);
        }

        return ans;
    }
}

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

题解：

/**
 * 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>> zigzagLevelOrder(TreeNode root) {

        List<List<Integer>> res = new ArrayList<>();
        if (null == root) {
            return res;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        boolean isOrderLeft = true;

        while (!queue.isEmpty()) {

            int size = queue.size();
            Deque<Integer> deque = new LinkedList<>();

            for (int i = 0; i < size; i ++) {

                TreeNode curNode = queue.poll();

                if (isOrderLeft) {
                    deque.offerLast(curNode.val);
                } else {
                    deque.offerFirst(curNode.val);
                }

                if (null != curNode.left) {
                    queue.offer(curNode.left);
                }

                if (null != curNode.right) {
                    queue.offer(curNode.right);
                }
            }

            isOrderLeft = !isOrderLeft;
            res.add(new ArrayList<>(deque));
        }

        return res;

    }
}

107. 二叉树的层序遍历 II

题解：

/**
 * 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>> levelOrderBottom(TreeNode root) {

        List<List<Integer>> res = new ArrayList<>();
        if (null == root) {
            return res;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {

            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i ++) {

                TreeNode curNode = queue.poll();
                
                list.add(curNode.val);

                if (null != curNode.left) {
                    queue.offer(curNode.left);
                }

                if (null != curNode.right) {
                    queue.offer(curNode.right);
                }
            }

            res.add(0, list);
        }

        return res;
    }
}

622. 设计循环队列

题解：

class MyCircularQueue {

    int size;
    int k;
    int head;
    int tail;
    int[] data;

    public MyCircularQueue(int k) {
        size = 0;
        head = -1;
        tail = 0;
        this.k = k;
        data = new int[k];
    }
    
    public boolean enQueue(int value) {
        if (this.isFull()) {
            return false;
        }
        data[tail] = value;
        tail = (tail + 1) % k;
        size ++;
        if (-1 == head) {
            head = 0;
        }
        return true;
    }
    
    public boolean deQueue() {
        if (this.isEmpty()) {
            return false;
        }
        head = (head + 1) % k;
        size --;
        return true;
    }
    
    public int Front() {
        if (this.isEmpty()) {
            return -1;
        }
        
        return data[head];
    }
    
    public int Rear() {
        if (this.isEmpty()) {
            return -1;
        }
        if (0 == tail) {
            return data[k - 1];
        } else {
            return data[tail - 1];
        }
    }
    
    public boolean isEmpty() {
        return 0 == this.size;
    }
    
    public boolean isFull() {
        return this.k == this.size;
    }
}

在取模的时候，如果需要向前移动，不要写成 (i - 1) % capacity，注意一定要加上 capacity 之后再取模，否则在 i = 0 的时候就出错了。

pre = (i - 1 + capacity) % capacity

单调队列（解决区间最值问题）

例 3：滑动窗口的最大值
class Solution {

    private Deque<Integer> deque = new ArrayDeque<>();

    private void push(int val) {

        while (!deque.isEmpty() && deque.getLast() < val) {
            deque.removeLast();
        }
        deque.addLast(val);

    }

    private void pop(int val) {

        if(!deque.isEmpty() && deque.getFirst() == val) {
            deque.removeFirst();
        }
    }

    public int[] maxSlidingWindow(int[] nums, int k) {
        final int n = nums.length;
        int[] ans = new int[n - k + 1];

        for (int i = 0; i < n; i ++) {

            this.push(nums[i]);

            if (i < k - 1) {
                continue;
            }

            ans[i - k + 1] = deque.getFirst();
            this.pop(nums[i - k + 1]);
        }

        return ans;
    }
}
例 4：捡金币游戏

题解：

class Solution {

    private Deque<Integer> deque = new ArrayDeque<>();

    private void push(int val) {
        while (!deque.isEmpty() && deque.getLast() < val) {
            deque.removeLast();
        }
        deque.addLast(val);
    }

    private void pop(int val) {
        if (!deque.isEmpty() && deque.getFirst() == val) {
            deque.removeFirst();
        }
    }

    public int maxResult(int[] nums, int k) {
        final int n = nums.length;
        int[] dp = new int[n];
        dp[0] = nums[0];
        this.push(dp[0]);

        for (int i = 1; i < n; i ++) {
            int temp = deque.getFirst() + nums[i];
            this.push(temp);
            dp[i] = temp;
            if (i - k >= 0) {
                this.pop(dp[i - k]);
            } 
        }

        return dp[n - 1];
    }
}
远腾飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法技巧-栈
寂寞风中一匹狼的博客
08-31 188
栈
算法常见技巧
qq_38056518的博客
09-15 357
算法技巧 1、回溯算法 （1）全排列 public List<List<Integer>> permute(int[] nums) { int len; if(nums == null || (len = nums.length) == 0){ return null; } // 这里面是结果，没什么好介绍的 List<List<Integer>> ans = new LinkedList<>(); // 这里是路径
数据结构与算法分析 四、树
ziggy7的博客
11-14 214
4.1 基本知识 树叶、深度、高度 树叶：没有儿子的节点 深度：从根到该节点的长度 高度：从该节点到一片树叶的最长路径的长 树的实现 兄弟法 struct TreeNode{ datatype data; TreeNode *FirstChild; //第一个孩子 TreeNode *NextSibling; //下一兄弟 } 数组法 class Node { public: int val; vector<Node*> children; Node() {}
二叉树非递归前中后遍历
qq_32284397的博客
09-28 113
#include<iostream> #include<stack> using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int _val) :val(_val),left(NULL),right(NULL) {} }; void preOrder(TreeNode *root); void postOrder(TreeNode *
算法之队列
m0_59392076的博客
05-26 310
队列介绍 1、队列是一个有序列表，可以用数组或者链表实现。 2、遵循先入后出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 数组模拟队列思路： 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中maxSize是该队列的最大容量。 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则是随着数据输入而改变，如图所示: 代码实现 pac...
算法：队列
xuzhimolol的博客
06-16 459
算法的系列文章中，之前咱们已经聊过了「 数组和链表 」、「 堆栈 」，今天咱们再来继续看看「 队列 」这种数据结构。「 队列 」和「 堆栈 」比较类似，都属于线性表数据结构，并且都在操作上受到一定规则约束，都是非常常用的数据类型，咱们掌握得再熟练也不为过。 一、「 队列 」是什么？ 队列（queue）是一种先进先出的、操作受限的线性表。 队列这种数据结构非常容易理解，就像我们平时去超市买东西，在收银台结账的时候需要排队，先去排队的就先结账出去，排在后面的就后结账，有其他人再要过来结账，必须排在队.
算法一看就懂之「 队列 」
Java笔记虾
08-31 926
算法的系列文章中，之前咱们已经聊过了「 数组和链表 」、「 堆栈 」，今天咱们再来继续看看「 队列 」这种数据结构。「 队列 」和「 堆栈 」比较类似，都属于线性表数据结...
基础算法+链表-队列-栈+面试必备+思维训练+编码能力训练
08-07
【链表】 ...总结来说，链表、队列和栈是基础的算法和数据结构，熟练掌握它们对于IT从业者，尤其是面试者，具有极大的价值。通过不断练习，不仅可以提升技术实力，还能增强应对面试和工作中问题的能力。
算法笔记-胡凡
09-26
胡凡的《算法笔记》还包含了数据结构的部分，如数组、链表、栈、队列、树（二叉树、平衡树如AVL树和红黑树）、哈希表等。理解并能灵活运用这些数据结构，对于编写高效代码至关重要。 在解题技巧方面，笔记中可能...
约瑟夫环-队列.rar
09-29
约瑟夫环（Josephus Problem）是一个著名的...它在计算机科学教育中被广泛使用，帮助学生理解队列的概念和模拟循环操作的技巧。同时，约瑟夫环问题也常常出现在面试和编程竞赛中，作为考察编程能力和逻辑思维的题目。
算法设计-实验三-动物园搬家.docx
最新发布
09-06
《算法设计：动物园搬家问题与Python...此问题的解决对于提升Python编程技巧，理解和实践算法设计思想具有重要意义。无论是初学者还是经验丰富的开发者，都能够从中受益，增强对算法和编程的理解，提高解决问题的能力。
算法图解-python,算法图解python3
09-10
通过阅读《算法图解-python,算法图解python3》，读者不仅可以掌握Python编程技巧，还能深入理解算法背后的逻辑，从而具备解决实际问题的能力。这本书适合自学，也适合作为教学参考，对于提升编程思维和技能大有裨益...
算法入门之队列
zzf1233的博客
09-21 447
队列和栈及其类似，队列在现实生活中的例子就是隧道，单通道一条线，先进去的先出来，后进去的后出来。在算法中的队列也是这样队列中从队头位置出队，从队尾入队，队列中的元素永远是先入先出FIFO（简称First In First Out）。队列的实现方式同样有两种数组和链表，实现队列的结构图如下（上面是数组实现，下面是链表实现）
队列算法
bobi的博客
02-29 905
单向队列：数组内元素key和value绑定，即使元素被取出，也无法在该位置继续存放数据 思路分析 1、定义结构体存储队列 2、front初始化-1 3、rear初始化-1 4、分别定义AddQueue、GetQueue、GetQueue Tip： 若初始化为0：指针rear先赋值再+1，使得rear比真实数据大1，（第0位先被占用，rear=1）当rear=max时才停止，容易发生index...
数据结构与算法—队列图文详解
bamiaochou2245的博客
08-16 309
前言 栈和队列是一对好兄弟，前面我们介绍过数据结构与算法—栈详解，那么栈的机制相对简单，后入先出，就像进入一个狭小的山洞，山洞只有一个出口，只能后进先出(在外面的先出去)。而队列就好比是一个隧道，后面的人跟着前面走，前面人先出去(先入先出)。日常的排队就是队列运转形式的一个描述！ 所以队列的核心理念就是：先进先出！ 队列的概念：队列是一种特殊的线性表，特殊之处在于它...
算法 --- 队列
Gerald的博客
09-26 494
算法学习 栈、队列、链表 解密QQ号 -- 队列    先对队列来一个定义：队列是一种特殊的线性结构，它只允许在队列的首部（head）进行删除操作，这称为“出队”，而在队列的尾部（tail）进行插入操作，这称为“入队”。当队列中没有元素时（即 head == tail），这称为空队列。    队列遵守“先进先出”原则！    举个例子！    当你问一个女生要QQ号的时候，那个女生并不...
算法（9）队列
白首少年的博客
12-16 280
队列是一种先进先出（first in first out）的数据结构，重要的元素有 头，尾， 队列长度。队列的操作基本有四种， 验空（isEmpty），验满（isFull），出队（deQueue）,入队（enQueue）。         实现队列有两种方法，数组和链表。这里数组的程序是我自己写的，链表的则是参考《C++ primer plus》P471上的代码。         关于用数组
[力扣] 动态规划（DP）问题分类汇总
寂寞风中一匹狼的博客
08-11 1697
动态规划是算法面试的一个重点，在力扣上有很多这类题目，题目是刷不完的，将动态规划的全部类型题目刷一遍可以达到事半功倍的效果。 1.线性动态规划 1.1 子序列系列： 题目一：最长上升子序列（300. 最长上升子序列） 题解：注意这里要求的子序列不是连续的，使用动态规划，dp[i]表示的是以下标i的数字作为结尾不连续最长上升子序列的长度，动态转移方程：dp[i] = max{dp[j] + 1, (0 <= j < i,a[j] < a[i]},dp表的初始状态为1，最后统计表中的最大值即为

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值