算法通关:013:设计循环队列总结

文章目录

总结

代码

java 复制代码
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;

/**
 * @Author: ggdpzhk
 * @CreateTime: 2024-08-01
 * 622
 */
public class _013_QueueSrackAndCircularQueue {
    //直接用java内部事项
    //其实内部就是双向链表,常数操作慢

    public static class Queue1{
        public Queue<Integer> queue = new LinkedList<>();

        //调用任何方法之前,先判断队列内是否有东西
        public boolean isEmpty() {
            return queue.isEmpty();
        }

        //向队列中加入num,加到尾
        public void offer(int num){
            queue.offer(num);
        }

        //从队列拿数,从头部拿
        public int poll(){
            return queue.poll();
        }
        //返回队列元素,但是不弹出
        public int peek(){
            return queue.peek();
        }

        //返回队列大小,(目前队列有几个数)
        public int size(){
            return queue.size();
        }
    }


    //用数组当 队列,范围是这样的  [)
    public static class Queue2{
        public int[] queue;
        public int l ;
        public int r ;

        //加入操作的总次数上限时多少一定要明确
        public Queue2(int n){
            queue = new int[n];
            l = 0;
            r = 0;
        }
        //调用任何方法前,先看队列是否为空
        public boolean isEmpty(){
            return l == r;
        }
        //向队列中加入num
        public void offer(int num){
            queue[r++] = num;//先用再++
        }
        //队列中弹出一个数,从头部弹出
        public int poll(){
            return queue[l++];
        }

        //返回队列元素
        public int peek(){
            return queue[l];
        }
        //返回队列大小
        public int size(){
            return r - l;
        }
    }

    //栈
    //直接用Java内部的实现
    //其实就是动态数组,但是常数时间不好
    public static class Stack1(){
        public Stack<Integer> stack = new Stack<>();

        //调用方法前先判空
        public boolean isEmpty(){
            return stack.isEmpty();
        }
        //进栈
        public void push(int num){
            stack.push(num);
        }
        //出栈
        public int pop(){
            return stack.pop();
        }
        //返回栈顶元素但是不弹出
        public int peek(){
            return stack.peek();
        }
        public int size(){
            return stack.size();
        }
    }


    //用数组来当栈 [)
    /*实际刷题时更常见的写法,常数时间好,
     * 如果可以确定 加入 操作 的总次数不超过n,那么可以用
     * 一般笔试、面试都会有一个明确的数据量,所以这是最常用的方式*/

    public static class Stack2{

        public int[] stack;
        public int size;
        public Stack2(int n){
            stack = new int[n];
            size = 0;
        }

        public boolean isEmpty(){
            return size == 0;
        }

        public void push(int num){
            stack[size++] = num;
        }
        public int pop(){
             return stack[--size];
        }
        //寻找栈顶元素,但是不出栈。栈底元素就是size[0]
        public int peek(){
            return stack[size-1];
        }
        public int size(){
            return size;
        }
    }


    //循环设计队列
    class MyCircularQueue{
        public int[] queue;

        public int l, r, size, limit;

        //方法,新建一个循环队列(用数组的形式)
        //同时在队列里的数字个数不要超过k
        public MyCircularQueue(int k){
            queue = new int[k];
            l = r = size = 0;
            limit = k;
        }
        public boolean isEmpty(){
            return size == 0;
        }
        public boolean isFull(){
            return size == limit;
        }

        public boolean enQueue(int num){

            //如果队列满了,什么也不做,返回false
            //如果队列没满,就加入value,返回true
            if(isFull()){
                return false;
            }else{
                queue[r] = num;
                r = r == limit - 1 ? 0 : (r + 1);//这个比取模要好懂
                size++;
                return true;
            }
        }

        public boolean deQueue(){
            if(isEmpty()){
                return false;
            }else{
                l = l == limit - 1 ? 0 : (l + 1);
                size--;
                return true;
            }
        }
        //返回队列头部数字
        public int Front(){
            if(isEmpty()){
                return -1;
            }else {
                return queue[l];
            }
        }
        //返回尾部数字
        public int Rear(){
            if(isEmpty()){
                return -1;
            }else{
                /*新加入的数字是放在r位置上的
                * 并且是循环队列
                * 所以 队尾的位置就应该在r-1  或者  limit-1 的位置*/
                int last = r == 0 ? (limit-1) : (r - 1);//不太好表示,所以引入last
                return queue[last];
            }
        }
    }
}
相关推荐
jiao_mrswang19 分钟前
leetcode-18-四数之和
算法·leetcode·职场和发展
qystca28 分钟前
洛谷 B3637 最长上升子序列 C语言 记忆化搜索->‘正序‘dp
c语言·开发语言·算法
薯条不要番茄酱28 分钟前
数据结构-8.Java. 七大排序算法(中篇)
java·开发语言·数据结构·后端·算法·排序算法·intellij-idea
今天吃饺子33 分钟前
2024年SCI一区最新改进优化算法——四参数自适应生长优化器,MATLAB代码免费获取...
开发语言·算法·matlab
是阿建吖!34 分钟前
【优选算法】二分查找
c++·算法
王燕龙(大卫)38 分钟前
leetcode 数组中第k个最大元素
算法·leetcode
不去幼儿园2 小时前
【MARL】深入理解多智能体近端策略优化(MAPPO)算法与调参
人工智能·python·算法·机器学习·强化学习
Mr_Xuhhh2 小时前
重生之我在学环境变量
linux·运维·服务器·前端·chrome·算法
盼海3 小时前
排序算法(五)--归并排序
数据结构·算法·排序算法
网易独家音乐人Mike Zhou6 小时前
【卡尔曼滤波】数据预测Prediction观测器的理论推导及应用 C语言、Python实现(Kalman Filter)
c语言·python·单片机·物联网·算法·嵌入式·iot