栈和队列

最新推荐文章于 2021-04-15 17:34:51 发布
最新推荐文章于 2021-04-15 17:34:51 发布
阅读量240 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 栈 队列 数组 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Autumn03/article/details/78931980
版权

栈，后进先出
队列，先进先出
1.数组实现栈

public class MyStack<E> {

    private Object[] stack;
    private int size;
    public MyStack(){
        stack=new Object[10];
    }

    public boolean isEmpty(){
        return size==0;
    }
    public E peek(){
        if(isEmpty()){
            return null;
        }
        return(E) stack[size-1];
    }
    public E pop(){
        E e=peek();
        stack[size-1]=null;
        size--;
        return e;
    }
    public E push(E item){
        ensureCapacity(size+1);
        stack[size++]=item;
        return item;
    }
    public void ensureCapacity(int size){
        int len=stack.length;
        if(size>len){
            int newLen=10;
            stack=Arrays.copyOf(stack,newLen);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyStack<Integer> s=new MyStack<Integer>();
        s.push(1);
        s.push(2);
        System.out.println("栈中元素个数"+s.size);
        System.out.println("栈顶元素"+s.pop());
        System.out.println("栈中元素个数"+s.size);
        System.out.println("栈顶元素"+s.pop());
    }

}
/*
栈中元素个数2
栈顶元素2
栈中元素个数1
栈顶元素1
*/

2.链表实现栈

class Node<E>{
    Node<E> next=null;
    E data;
    public Node(E data){
        this.data=data;
    }
}

public class LinkedListStack<E> {
    Node<E> top=null;
    public boolean isEmpty(){
        return top==null;
    }
    public void push(E data){
        Node<E> newNode=new Node<E>(data);
        newNode.next=top;
        top=newNode;
    }
    public E pop(){
        if(this.isEmpty()){
            return null;
        }
        E data=top.data;
        top=top.next;
        return data;
    }
    public E peek(){
        if(isEmpty()){
            return null;
        }
        return top.data;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyStack<Integer> s=new MyStack<Integer>();
        s.push(1);
        s.push(2);
        System.out.println("栈顶元素"+s.pop());

    }

}

注意：该实现不是线程安全的，下面程序会讲到，要实现线程安全的栈，需要对入栈和出栈进行同步

3.用O(1)的时间复杂度求栈中最小元素

利用o(1)时间复杂度求栈中最小元素，遍历栈的时间复杂度为O(n)；由于每次压栈和出栈都有可能改变栈中的min，增加一个存放min的栈。
空间换取时间：实现时使用两个栈结构，一个存储数据，一个存储栈的最小元素；如果当前入栈的元素比原来栈中的最小值还小，则把这个值压入保存最小值元素栈中；出栈时，如果当前出栈的元素恰好为当前栈中的min，保存最小值的栈顶元素也出栈

public class StackMin {

    MyStack<Integer> elem;
    MyStack<Integer> min;
    public StackMin(){
        elem=new MyStack<Integer>();
        min=new MyStack<Integer>();
    }
    public void push(int data){
        elem.push(data);
        if(min.isEmpty()){
            min.push(data);
        }
        else{
            if(data<min.peek()){
                min.push(data);
            }
        }
    }
    public int pop(){
        int topData=elem.peek();
        elem.pop();
        if(topData==this.min()){
            min.pop();
        }
        return topData;
    }
    public int min(){
        if(min.isEmpty()){
            return Integer.MAX_VALUE;
        }
        else{
            return min.peek();
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StackMin s=new StackMin();
        s.push(1);
        s.push(2);
        s.push(0);
        s.push(5);
        s.push(7);
//      for(int i=0;i<5;i++){
//          System.out.println(s.pop());
//      }
        System.out.println("栈min"+s.min());
    }

}

4.链表实现队列

public class MyQueue<E> {

    private Node<E> head=null;
    private Node<E> tail=null;
    public boolean isEmpty(){
        return head==tail;
    }

    public void put(E data){
        Node<E> newNode=new Node<E>(data);
        if(head==null&&tail==null){
            head=newNode;
            tail=newNode;
        }
        else{
            tail.next=newNode;
            tail=newNode;
        }
    }

    public E pop(){
        if(this.isEmpty()){
            return null;
        }
        E data=head.data;
        head=head.next;
        return data;
    }

    public int size(){
        Node<E> tmp=head;
        int n=0;
        while(tmp!=null){
            n++;
            tmp=tmp.next;
        }
        return n;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyQueue<Integer> q=new MyQueue<Integer>();
        q.put(1);
        q.put(2);
        q.put(3);
        System.out.println("队列长度"+q.size());
        System.out.println("队首元素"+q.pop());
        System.out.println("队首元素"+q.pop());

    }

}

5.数组实现队列

public class MyQueueArray <E>{
    private LinkedList<E> list=new LinkedList<E>();
    private int size=0;
    public synchronized void put(E e){
        list.addLast(e);
        size++;
    }
    public synchronized E pop(){
        size--;
        return list.removeFirst();
    }
    public synchronized boolean empty(){
        return size==0;
    }
    public synchronized int size(){
        return size;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyQueueArray<Integer> q=new MyQueueArray<Integer>();
        q.put(8);
        q.put(2);
        q.put(3);
        System.out.println("队列长度"+q.size());
        System.out.println("队首元素"+q.pop());
        System.out.println("队首元素"+q.pop());

    }

}

6.利用两个栈模拟队列操作

利用Java类库提供的Stack来实现：

package stack;
/*
 * 两个栈实现队列：A为入栈，B为出栈
 * 入栈，入A即可
 * 出栈，如果B不为空，直接弹出B中数据
 * 如果B空，依次弹出A中的数据放入B中，再弹出B中的数据
 */
import java.util.Stack;

public class StackQueue<E> {
    private Stack<E> sa=new Stack<E>();
    private Stack<E> sb=new Stack<E>();
    public synchronized void put(E e){
        sa.push(e);
    }
    public synchronized E pop(){
        if(sb.isEmpty()){
            while(!sa.isEmpty()){
                sb.push(sa.pop());
            }
        }
        return sb.pop();
    }
    public synchronized boolean empty(){
        return sa.isEmpty()&&sb.isEmpty();
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StackQueue<Integer> sq=new StackQueue<Integer>();
        sq.put(2);
        sq.put(8);
        sq.put(5);
        System.out.println("队列首元素"+sq.pop());
        System.out.println("队列首元素"+sq.pop());

    }

}

7.利用两个队列实现栈

Queue是一个接口，已知的实现类有：ArrayDeque，LinkedList，SynchronousQueue等

package stack;
/*
 * 利用两个队列实现栈
 * q1入队列，q2出队列，s为栈
 * 要压栈，入队列q1即可
 * 弹栈，如果q1中只有一个元素，让q1中的元素出队列并输出即可
 * 如果q1不只一个元素，q1中所有元素出队列，入队列q2，最后一个元素不入队列q2输出该元素，然后将q2所有元素入q1
 */

import java.util.*;

public class QueueStack<Integer>{

    private LinkedList<Integer> q1=new LinkedList<Integer>();
    private LinkedList<Integer> q2=new LinkedList<Integer>();

    public synchronized void push(Integer item){
        q1.addLast(item);
    }

    public synchronized Integer pop(){
        Integer re=null;
        if(sSize()!=0){
            if(!q1.isEmpty()){
                toAnother();
                re=q1.removeFirst();
            }
            else{
                toAnother();
                re=q2.removeFirst();
            }
        }
        return re;
    }

    public void toAnother(){
        if(!q1.isEmpty()){
            while(q1.size()>1){
                q2.add(q1.removeFirst());
            }
        }
        else if(!q2.isEmpty()){
            while(q2.size()>1){
                q1.add(q2.removeFirst());
            }
        }
    }

    public int sSize(){
        return q1.size()+q2.size();
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        QueueStack stack=new QueueStack();  
        stack.push(1);  
        stack.push(2);  
        stack.push(3);  
        stack.push(4);  
        System.out.println(stack.pop());  
        System.out.println(stack.pop());  
        stack.push(5);  
        stack.push(6);  
        System.out.println(stack.pop());  
        System.out.println(stack.pop());  
        System.out.println(stack.pop());  
        System.out.println(stack.pop());  
        System.out.println(stack.pop()); 
    }
}
Autumn匆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
栈 队列
冷月
08-24 459
栈 顺序栈 共享栈 链式栈 队列 顺序队列 链式队列
栈队列
wyy的博客
04-15 127
//栈 //public class Stack extends Vector 已经过时 Stack stack = new Stack(); //双端队列 可以作为栈来使用 push() 入栈 pop() 出栈 peek() 获取栈顶元素 Deque deque ; //ArrayDeque 底层是数组 LinkedList 底层是链表 //队列 Queue queue; //ArrayDeque 底层是数组 LinkedList 底层是链表 //表 List list ; //模拟摞盘子 De
堆栈、队列
AIBAIKE的博客
09-21 291
堆：程序员自己分配释放 栈：系统自动分配和释放，类似一个桶，先进后出 队列：特殊线性表，只能在队尾进行插入，队首进行删除   堆本质可以看做是一颗完全二叉树，满足根节点大于或者小于两个子节点，但子节点之间没有大小要求，这个和二叉树排序不一样，二叉树排序是左结点&lt;根节点&lt;右结点...
栈 &队列
苏帕AI
03-24 214
1、栈1.1定义：栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 ---来自百度百科栈分为栈顶和栈尾。在进行操作时。只允许...
数据结构栈和队列
04-08
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
Python实现栈和队列的简单操作方法示例
09-18
主要介绍了Python实现栈和队列的简单操作方法,结合实例形式详细分析了Python栈和队列的原理与简单实现技巧,需要的朋友可以参考下
栈和队列PPT
05-23
栈和队列PPT课件，想要了解栈和队列的同学，可以下载一下。
入门小白学数据结构与算法（3）——栈和队列
小景的博客
11-01 276
一、 栈——一种数据遵从“后进先出”的线性表 1.1 基本概念： 1.仅限定在表尾（栈顶）进行插入和删除操作 2.把允许插入和删除的一端（表尾）称为栈顶，另一端叫做栈底，不含任何元素的叫做空栈 3.先进的数据放在底，栈的插入又叫入栈，栈的删除叫做出栈。 理解：其实栈就是一种特殊的线性表（顺序表，链表），只是数据的操作只允许在表尾（栈顶） 1.2 存储结构 分为顺序存储和链式存储，常用的为顺序存储 1.3栈的相关代码操作——栈顶栈底指针形式 栈的定义 typedef int Elemtype; typedef
栈与队列
mozhan的专栏
02-21 173
1 栈的定义 栈是限定仅在表尾进行插入和删除操作的线性表。允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈，栈又称为后进先出(Last In First Out)的线性表，简称LIFO结构。 栈是一个线性表，栈元素具有线性关系，即前驱后继关系，栈的表尾是指栈顶，而不是栈底。栈底是固定的，最先进栈的只能在栈底，栈的插入操作，叫作进栈，栈的删除操作，叫作出栈。 2 ...
数据结构栈和队列实验
最新发布
10-08
数据结构中的栈和队列是两种重要的数据结构。栈（Stack）是一种具有特殊限制的线性数据结构，它遵循LIFO（后进先出）原则，即最后进入的元素首先被访问或删除。栈有两个基本操作：压入（push）和弹出（pop）。队列...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值