队列和栈的问题

最新推荐文章于 2019-11-03 21:06:50 发布
最新推荐文章于 2019-11-03 21:06:50 发布
阅读量168 收藏
点赞数
原文链接：http://www.cnblogs.com/yft-javaNotes/p/10719905.html
版权
本文深入探讨了栈和队列这两种基本数据结构的实现与应用，包括使用数组实现固定大小的栈和队列，如何仅用队列结构实现栈结构，以及相反的实现方式。此外，还介绍了栈和队列的补充练习，如实现特殊栈的最小元素获取功能，以及解决猫狗队列问题的创新方法。
摘要由CSDN通过智能技术生成

一、用数组结构实现大小固定的栈

【核心思想】

　　栈结构是“后进先出”，有初始化栈、入栈、出栈、返回栈顶等功能，题目大意就是要求我们用数组实现栈的这些功能。

　　初始化栈：给定一个初始大小，创建一个栈。定义一个变量 size ，初始化为 0，用来记录栈中的元素数量。

　　入栈：如果 size 小于栈的大小，将要入栈的数放入数组的 size 位置上，size 加 1。否则报错。

　　出栈：如果 size 大于 0，返回数组（ size - 1 ） 位置上的数，size 减 1。否则报错。

　　返回栈顶：如果 size 大于 0，返回数组（size - 1）位置上的数。否则报错。

【代码实现】

public class ArrayToStack {
    private int[] arr;
    private int size;

    /**
     * 初始化栈
     * @param initSize
     */
    public ArrayToStack(int initSize) {
        if (initSize < 0) {
            throw new IllegalArgumentException("The init size is less than 0!");
        }
        arr = new int[initSize];
        size = 0;
    }

    /**
     * 入栈
     * @param obj
     */
    public void push(int obj) {
        //size等于数组长度（栈的大小）,说明栈已满,不能入栈
        if (size == arr.length) {
            throw new IndexOutOfBoundsException("The stack is full!");
        }
        arr[size++] = obj;
    }

    /**
     * 出栈
     * @return
     */
    public int pop() {
        //size等于0,说明栈空,不能出栈。
        if (size == 0) {
            throw new IndexOutOfBoundsException("The stack is empty!");
        }
        return arr[--size];
    }

    /**
     * 返回栈顶第一个元素
     * @return
     */
    public int peek() {
        //size等于0,说明栈空,所以没有栈顶。
        if (size == 0) {
            throw new IndexOutOfBoundsException("The stack is empty!");
        }
        return arr[size - 1];
    }

}

二、用数组结构实现大小固定的队列

【核心思想】

【实现代码】

public class ArrayToQueue {
    private Integer[] arr;
    private Integer size;
    private Integer start;
    private Integer end;

    /**
     * 初始化队列
     * @param initSize
     */
    public ArrayToQueue(int initSize) {
        if (initSize < 0) {
            throw new IllegalArgumentException("The init size is less than 0");
        }
        arr = new Integer[initSize];
        size = 0;
        start = 0;
        end = 0;
    }

    /**
     * 入队
     * @param obj
     */
    public void push(int obj) {
        if (size == arr.length) {
            throw new ArrayIndexOutOfBoundsException("The queue is full");
        }
        size++;
        arr[end] = obj;
        end = end == arr.length - 1 ? 0 : end + 1;
    }

    /**
     * 出队
     * @return
     */
    public Integer pop() {
        if (size == 0) {
            throw new ArrayIndexOutOfBoundsException("The queue is empty");
        }
        size--;
        int tmp = start;
        start = start == arr.length - 1 ? 0 : start + 1;
        return arr[tmp];
    }

    /**
     * 返回队列的第一个数
     * @return
     */
    public Integer peek() {
        if (size == 0) {
            return null;
        }
        //如果size不等于0,返回start指向的数
        return arr[start];
    }
} 

三、如何仅用队列结构实现栈结构？

【实现思路】

【代码实现】

/**
 * 仅用队列结构实现栈结构
 *
 * @author yi
 */
public class QueueToStack {
    private Queue<Integer> data;
    private Queue<Integer> help;

    public QueueToStack() {
        this.data = new LinkedList<Integer>();
        this.help = new LinkedList<Integer>();
    }

    /**
     * 正常push添加进入queue
     * @param value
     */
    public void push(int value) {
        data.add(value);
    }

    /**
     * 在pop的时候,pop只留下一个元素,并把pop出来的元素加入到help队列中
     * @return
     */
    public int pop() {
        if (data.isEmpty()) {
            throw new RuntimeException("栈为空");
        }
        while (data.size() > 1) {
            //把data中的元素"剪切"到help队列,直到data只剩下一个元素
            help.add(data.poll());
        }
        //最后一个入队的元素
        int res = data.poll();
        //交换help和data的引用指向
        swap();
        return res;
    }

    /**
     * 返回栈顶的第一个元素
     * @return
     */
    public int peek() {
        if (data.isEmpty()) {
            throw new RuntimeException("栈为空");
        }
        while (data.size() > 1) {
            help.add(data.poll());
        }
        int res = data.poll();
        help.add(res);
        swap();
        return res;
    }

    public void swap() {
        Queue<Integer> temp = help;
        help = data;
        data = temp;
    }
}

四、如何仅用栈结构实现队列结构？ 

 【实现思路】

　　

【代码实现】

/**
 * 仅用栈结构实现队列结构
 *
 * @author yi
 */
public class StackToQueue {
    private Stack<Integer> stackPush;
    private Stack<Integer> stackPop;

    public StackToQueue() {
        stackPush = new Stack<>();
        stackPop = new Stack<>();
    }

    /**
     * 入队
     * @param obj
     */
    public void push(int obj) {
        stackPush.push(obj);
    }

    /**
     * 出队
     * @return
     */
    public int poll() {
        if (stackPop.empty() && stackPush.empty()) {
            throw new RuntimeException("Queue is empty!");
        } else if (stackPop.empty()) {
            while (!stackPush.empty()) {
                stackPop.push(stackPush.pop());
            }
        }
        return stackPop.pop();
    }

    /**
     * 返回队列的第一个数
     * @return
     */
    public int peek() {
        if (stackPop.empty() && stackPush.empty()) {
            throw new RuntimeException("Queue is empty!");
        } else if (stackPop.empty()) {
            while (!stackPush.empty()) {
                stackPop.push(stackPush.pop());
            }
        }
        return stackPop.peek();
    }
}

五、栈的补充练习

　　实现一个特殊的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作。

【要求】

　　1．pop、push、getMin操作的时间复杂度都是O(1)。
　　2．设计的栈类型可以使用现成的栈结构。

【实现思路】

【代码实现】

public class MyStack {
    private Stack<Integer> stackData;
    private Stack<Integer> stackMin;

    public MyStack() {
        this.stackData = new Stack<>();
        this.stackMin = new Stack<>();
    }

    public void push(int newNum) {
        if (this.stackMin.isEmpty()) {
            this.stackMin.push(newNum);
        } else if (newNum < this.getMin()) {
            this.stackMin.push(newNum);
        } else {
            int newMin = this.stackMin.peek();
            this.stackMin.push(newMin);
        }
        this.stackData.push(newNum);
    }

    public int pop() {
        if (this.stackData.isEmpty()) {
            throw new RuntimeException("Your stack is empty");
        }
        this.stackMin.pop();
        return this.stackData.pop();
    }

    public int getMin() {
        if (this.stackMin.isEmpty()) {
            throw new RuntimeException("Your stack is empty.");
        }
        return this.stackMin.peek();
    }

    public static void main(String[] args) {
        MyStack stack = new MyStack();
        stack.push(3);
        System.out.println(stack.getMin());//3
        stack.push(5);
        System.out.println(stack.getMin());//3
        stack.push(1);
        System.out.println(stack.getMin());//1
        System.out.println(stack.pop());//1
        System.out.println(stack.getMin());//3
    }

}

六、队列的补充练习

6.1 猫狗队列问题

【题目】

　　宠物、狗和猫的类如下： 

public static class Pet {
    private String type;

    public Pet(String type) {
        this.type = type;
    }

    public String getPetType() {
        return this.type;
    }
}

public static class Dog extends Pet {
    public Dog() {
        super("dog");
    }
}

public static class Cat extends Pet {
    public Cat() {
        super("cat");
    }
}

【要求】

　　实现一种狗猫队列的结构，要求如下：

  1. 用户可以调用add方法将cat类或dog类的 实例放入队列中；
  2. 用户可以调用pollAll方法，将队列中所有的实例按照进队列 的先后顺序依次弹出；
  3. 用户可以调用pollDog方法，将队列中dog类的实例按照 进队列的先后顺序依次弹出；
  4. 用户可以调用pollCat方法，将队列中cat类的实 例按照进队列的先后顺序依次弹出；
  5. 用户可以调用isEmpty方法，检查队列中是 否还有dog或cat的实例；
  6.  用户可以调用isDogEmpty方法，检查队列中是否有dog 类的实例； 用户可以调用isCatEmpty方法，检查队列中是否有cat类的实例

【代码实现】

public class DogCatQueue_Code {
    /**
     * 以下的Pet、Dog、Cat类是用户提供的基础类,不能修改
     */
    public static class Pet {
        private String type;

        public Pet(String type) {
            this.type = type;
        }

        public String getPetType() {
            return this.type;
        }
    }

    public static class Dog extends Pet {
        public Dog() {
            super("dog");
        }
    }

    public static class Cat extends Pet {
        public Cat() {
            super("cat");
        }
    }

    /**
     * 为了不修改原来的基础类,我们自定义一个PetEnterQueue类,这个类才是放入到猫狗队列中去的对象
     * 保留原来的属性pet,并且新增一个count属性,将不同实例盖上时间戳
     */
    public static class PetEnterQueue {
        private Pet pet;
        private long count;

        public PetEnterQueue(Pet pet, long count) {
            this.pet = pet;
            this.count = count;
        }

        public Pet getPet() {
            return this.pet;
        }

        public long getCount() {
            return this.count;
        }

        public String getEnterPetType() {
            return this.pet.getPetType();
        }
    }

    /**
     * 我们实现的队列就是PetEnterQueue类的实例
     * 首先有一个不断累加的数据项count用来表示实例进队列的时间(不分cat还是dog)
     * 同时有两个队列，一个只存放Dog，另一个只存放Cat。
     */
    public static class DogCatQueue {
        private Queue<PetEnterQueue> dogQ;
        private Queue<PetEnterQueue> catQ;
        private long count;

        public DogCatQueue() {
            this.dogQ = new LinkedList<>();
            this.catQ = new LinkedList<>();
            this.count = 0;
        }

        public void add(Pet pet) {
            //如果pet是dog类型
            if (pet.getPetType().equals("dog")) {
                //在dog队列中添加信息:当前进入的是dog,并且当前数是count
                this.dogQ.add(new PetEnterQueue(pet, this.count++));
            } else if (pet.getPetType().equals("cat")) {
                this.catQ.add(new PetEnterQueue(pet, this.count++));
            } else {
                throw new RuntimeException("err, not dog or cat");
            }
        }

        /**
         * 弹出整体最早的
         * @return
         */
        public Pet pollAll() {
            if (!this.dogQ.isEmpty() && !this.catQ.isEmpty()) {
                //dog队列最早的dog最小,还是cat队列最早的cat最小
                //注意这里使用的是peek而不是poll
                //peek用于查询队列头部的元素;poll用于弹出队列中的头部元素
                if (this.dogQ.peek().getCount() < this.catQ.peek().getCount()) {
                    return this.dogQ.poll().getPet();
                } else {
                    return this.catQ.poll().getPet();
                }
            } else if (!this.dogQ.isEmpty()) {
                return this.dogQ.poll().getPet();
            } else if (!this.catQ.isEmpty()) {
                return this.catQ.poll().getPet();
            } else {
                throw new RuntimeException("err, queue is empty!");
            }
        }

        /**
         * 单独弹出dog
         * @return
         */
        public Dog pollDog() {
            if (!this.isDogQueueEmpty()) {
                return (Dog) this.dogQ.poll().getPet();
            } else {
                throw new RuntimeException("Dog queue is empty!");
            }
        }

        /**
         * 单独弹出cat
         * @return
         */
        public Cat pollCat() {
            if (!this.isCatQueueEmpty()) {
                return (Cat) this.catQ.poll().getPet();
            } else {
                throw new RuntimeException("Cat queue is empty!");
            }
        }

        public boolean isDogQueueEmpty() {
            return this.dogQ.isEmpty();
        }

        public boolean isCatQueueEmpty() {
            return this.catQ.isEmpty();
        }
    }

    public static void main(String[] args) {
        DogCatQueue test = new DogCatQueue();

        Pet dog1 = new Dog();
        Pet cat1 = new Cat();
        Pet dog2 = new Dog();
        Pet cat2 = new Cat();
        Pet dog3 = new Dog();
        Pet cat3 = new Cat();

        test.add(dog1);
        test.add(cat1);
        test.add(dog2);
        test.add(cat2);
        test.add(dog3);
        test.add(cat3);

        test.add(dog1);
        test.add(cat1);
        test.add(dog2);
        test.add(cat2);
        test.add(dog3);
        test.add(cat3);

        test.add(dog1);
        test.add(cat1);
        test.add(dog2);
        test.add(cat2);
        test.add(dog3);
        test.add(cat3);

        while (!test.isDogQueueEmpty()) {
            System.out.println(test.pollDog().getPetType());
        }
        while (!test.isCatQueueEmpty()) {
            System.out.println(test.pollCat().getPetType());
        }
    }
}

 

 

 

 

参考：https://blog.csdn.net/LYN9822/article/details/86530165

转载于:https://www.cnblogs.com/yft-javaNotes/p/10719905.html

VNOpU2015
关注
关于栈与队列的一些问题
呆子伯云
10-27 948
1、判断队列中，
栈与队列问题（主要是栈的使用）
a631278993的博客
05-15 428
转载请注明原文地址：http://www.cnblogs.com/ygj0930/p/6857537.html 一：问题概述 栈与队列的相关算法题，一般都是基于对栈、队列基本性质的熟练掌握的前提下，如何巧妙地组合、包装，以达到某种原来数据类型所没有的性质。比如：设计出一种能getMin()获取栈中最小值的栈、利用栈实现队列等等。问题的本意为考察栈、队列的基本性质与基本操作的...
栈和队列互相实现问题
小胡同的诗
07-30 214
由于栈是一种后进先出的数据结构，而队列是一种先进先出的数据结构，两者互相实现时要借助一个辅助的栈/队列，主要的思想还是根据两个相同的数据运算来达到互相实现。 1，两个栈实现队列 保证辅助栈为空，而数据栈来进行入队操作，这样在入队复杂度为O(1)O(1)O(1) 每次出队或者取队头的时候，由于该元素在栈底，借助辅助栈把它还原到栈顶，然后取出或删去，剩下的数据要记得还原！否则顺序就会改变了。复杂度...
Bailian4099 队列和栈【堆栈+队列】
海岛Blog
08-21 1024
4099:队列和栈 总时间限制: 1000ms 内存限制: 65536kB 描述 队列和栈是两种重要的数据结构，它们具有push k和pop操作。push k是将数字k加入到队列或栈中，pop则是从队列和栈取一个数出来。队列和栈的区别在于取数的位置是不同的。 队列是先进先出的：把队列看成横向的一个通道，则push k是将k放到队列的最右边，而pop则是从队列的最左边取出一个数。 栈是后进先出的：把...
队列和栈
weixin_30485379的博客
06-26 90
队列 一、什么是队列 图解 解释：我们的队列就像排队加油一样，谁在前面谁就先加油，这就满足队列的概念先进先出的。 概念：值允许在一端进行插入操作，而在另一端进行删除操作的线性表。一般的实现方法是通过链式表进行实现，所以也可叫链队列。 场景：我们的输入缓冲区接受键盘的输入就是按队列的形式输入和输出，大家可以看一下你们自己的输入法。 二、队列的实现代码 链式队列 <?ph...
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数组、链表、队列、栈数据结构特点，各自优点和缺点 数组和链表.pdf
04-18
数组、链表、队列、栈数据结构特点，各自优点和缺点 在计算机科学中，数据结构是指用于组织和存储数据的方式。常见的数据结构包括数组、链表、队列、栈等。每种数据结构都有其特点、优点和缺点，本文将对这些数据...
数据结构栈和队列解决迷宫问题
06-07
数据结构栈和队列解决迷宫问题 本文档详细介绍了利用栈和队列解决迷宫问题的步骤，对于初学者学习数据结构能很好的进行辅导。本文档主要涉及到数据结构的两个重要概念：栈和队列，并介绍了如何使用这两个数据结构来...
Java实现栈和队列面试题
09-03
栈和队列是数据结构中的基础概念，它们在编程中有着广泛的应用，特别是在Java面试中常常被用来测试候选人的算法和数据结构理解能力。下面我们将详细探讨这些知识点。 1. **栈的创建**： 栈是一种后进先出（LIFO）...
队列和栈类：双向链表、栈和队列的实现-matlab开发
06-01
在MATLAB环境中，数据结构的实现对于算法设计和问题解决至关重要。本项目专注于使用双向链表来实现队列和栈，这是一种高效且灵活的方法。双向链表允许在两端进行插入和删除操作，使得它们成为队列和栈的理想选择。...
队列与栈的区别
weixin_30897233的博客
12-24 112
1.队列先进先出，栈先进后出。2. 对插入和删除操作的"限定"。栈是限定只能在表的一端进行插入和删除操作的线性表。队列是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。 从"数据结构"的角度看，它们都是线性结构，即数据元素之间的关系相同。但它们是完全不同的数据类型。除了它们各自的基本操作集不同外，主要区别是对插入和删除操作的"限定"。 3.遍历数据速度不同。栈只能从头部取数...
栈和队列的相关问题
weixin_44077227的博客
05-18 1292
1. 什么是栈，栈有什么特性？ 抽象的数据类型栈的定义 栈是一种线性表,是一种有约束的线性结构 ,(限定仅在表位进行插入或者删除的线性表),因此对栈来说,表尾端称为栈顶(top),表头称为栈尾(bottom),不含元素的称为空栈 先进后出(FILO),或者后进先出(LIFO)的线性表 2. 栈和程序运行时的栈区有什么区别？ 我们这里说的栈是一种抽象的数据结构,是我们在描述数据时候抽象的一种方法,...
数据结构：队列与栈问题
Kobe51920的博客
11-03 1378
1.队列与栈（栈有记忆功能，队列删除,插入效率比较低下） 1. 队列删除元素是在队首进行，队列是现进现出，相对来说，队首元素是最先进入队列的，因此出队应该是在队首进行。队列其实就和我们平时排队一样的 2. 栈与队列是非线性结构，应该是线性结构，再确切点说是访问受限的线性表 线性链表是非线性结构，应该是线性结构 二叉树是线性结构，应该是非线性结构（层次结构 3. BFS需要...
队列与栈详解
qq_43096062的博客
08-30 849
队列（Queue）：是限定只能在表的一端进行插入和另一端删除操作的线性表 栈（Stack）：是限定之能在表的一端进行插入和删除操作的线性表 队列和栈的规则 队列：先进先出 栈：先进后出 队列和栈的遍历数据速度 队列：基于地址指针进行遍历，而且可以从头部或者尾部进行遍历，但不能同时遍历，无需开辟空间，因为在遍历的过程中不影响数据结构，所以遍历速度要快 栈：只能从顶部取数据，也就是说最先进入栈底的，需...
K：栈和队列的比较
diaosangwan0363的博客
01-05 98
栈和队列的相同点: 都是线性结构，即数据元素之间具有“一对一”的逻辑关系 都可以在顺序存储结构和链式存储结构上进行实现 在时间代价上，插入和删除操作都需常数时间；在空间代价上，情况相同 多链栈和多链队列的管理模式可以相同 栈和队列的不同点： 删除数据元素操作的位置不同。对于栈而言，其在一端插入数据元素，同时在该端删除数据元素，对于队列而言，其在一端插入数据元素，在另一端删除数据元素...
C++栈和队列
Bingo
08-19 3025
使用标准库的栈和队列时，先包含相关的头文件 #include #include 定义栈如下： stack stk; 定义队列如下： queue q; 栈提供了如下的操作
tornado-6.4.1-cp38-abi3-musllinux_1_2_i686.whl
11-04
tornado-6.4.1-cp38-abi3-musllinux_1_2_i686.whl
tornado-6.1-cp36-cp36m-manylinux2014_aarch64.whl
11-04
tornado-6.1-cp36-cp36m-manylinux2014_aarch64.whl
基于java的ssm停车位短租系统程序答辩PPT.pptx
最新发布
11-04
基于java的ssm停车位短租系统程序答辩PPT.pptx
栈和队列操作实现
"该资源是关于栈和队列的数据结构练习，包含C语言实现的代码，涉及栈的入栈、出栈以及队列的入队、出队等基本操作。" 在计算机科学中，栈（Stack）和队列（Queue）是两种基本的数据结构，它们在处理数据时遵循特定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值