Java实现栈和队列

栈:LIFO(后进先出)

队列:FIFO(先进先出)

栈的顺序存储结构实现:

/**
 * 基于数组实现的顺序栈
 * @param <E>
 */
public class Stack<E> {
    private Object[] data = null;
    private int maxSize=0;   //栈容量
    private int top =-1;  //栈顶指针

    /**
     * 构造函数:根据给定的size初始化栈
     */
    Stack(){
        this(10);   //默认栈大小为10
    }

    Stack(int initialSize){
        if(initialSize >=0){
            this.maxSize = initialSize;
            data = new Object[initialSize];
            top = -1;
        }else{
            throw new RuntimeException("初始化大小不能小于0:" + initialSize);
        }
    }

    //判空
    public boolean empty(){
        return top==-1 ? true : false;
    }

    //进栈,第一个元素top=0;
    public boolean push(E e){
        if(top == maxSize -1){
            throw new RuntimeException("栈已满,无法将元素入栈!");
        }else{
            data[++top]=e;
            return true;
        }
    }

    //查看栈顶元素但不移除
    public E peek(){
        if(top == -1){
            throw new RuntimeException("栈为空!");
        }else{
            return (E)data[top];
        }
    }

    //弹出栈顶元素
    public E pop(){
        if(top == -1){
            throw new RuntimeException("栈为空!");
        }else{
            return (E)data[top--];
        }
    }

    //返回对象在堆栈中的位置,以 1 为基数
    public int search(E e){
        int i=top;
        while(top != -1){
            if(peek() != e){
                top --;
            }else{
                break;
            }
        }
        int result = top+1;
        top = i;
        return result;
    }
}

栈的链式存储结构实现:

public class LinkStack<E> {
    //链栈的节点
    private class Node<E>{
        E e;
        Node<E> next;

        public Node(){}
        public Node(E e, Node next){
            this.e = e;
            this.next = next;
        }
    }

    private Node<E> top;   //栈顶元素
    private int size;  //当前栈大小

    public LinkStack(){
        top = null;
    }

    //当前栈大小
    public int length(){
        return size;
    }

    //判空
    public boolean empty(){
        return size==0;
    }

    //入栈:让top指向新创建的元素,新元素的next引用指向原来的栈顶元素
    public boolean push(E e){
        top = new Node(e,top);
        size ++;
        return true;
    }

    //查看栈顶元素但不删除
    public Node<E> peek(){
        if(empty()){
            throw new RuntimeException("空栈异常!");
        }else{
            return top;
        }
    }

    //出栈
    public Node<E> pop(){
        if(empty()){
            throw new RuntimeException("空栈异常!");
        }else{
            Node<E> value = top; //得到栈顶元素
            top = top.next; //让top引用指向原栈顶元素的下一个元素
            value.next = null;  //释放原栈顶元素的next引用
            size --;
            return value;
        }
    }
}

基于LinkedList实现的栈结构:

import java.util.LinkedList;

/**
 * 基于LinkedList实现栈
 * 在LinkedList实力中只选择部分基于栈实现的接口
 */
public class StackList<E> {
    private LinkedList<E> ll = new LinkedList<E>();

    //入栈
    public void push(E e){
        ll.addFirst(e);
    }

    //查看栈顶元素但不移除
    public E peek(){
        return ll.getFirst();
    }

    //出栈
    public E pop(){
        return ll.removeFirst();
    }

    //判空
    public boolean empty(){
        return ll.isEmpty();
    }

    //打印栈元素
    public String toString(){
        return ll.toString();
    }
}

队列的顺序存储结构实现

public class Queue<E> {
    private Object[] data=null;
    private int maxSize; //队列容量
    private int front;  //队列头,允许删除
    private int rear;   //队列尾,允许插入

    //构造函数
    public Queue(){
        this(10);
    }

    public Queue(int initialSize){
        if(initialSize >=0){
            this.maxSize = initialSize;
            data = new Object[initialSize];
            front = rear =0;
        }else{
            throw new RuntimeException("初始化大小不能小于0:" + initialSize);
        }
    }

    //判空
    public boolean empty(){
        return rear==front?true:false;
    }

    //插入
    public boolean add(E e){
        if(rear== maxSize){
            throw new RuntimeException("队列已满,无法插入新的元素!");
        }else{
            data[rear++]=e;
            return true;
        }
    }

    //返回队首元素,但不删除
    public E peek(){
        if(empty()){
            throw new RuntimeException("空队列异常!");
        }else{
            return (E) data[front];
        }
    }

    //出队
    public E poll(){
        if(empty()){
            throw new RuntimeException("空队列异常!");
        }else{
            E value = (E) data[front];  //保留队列的front端的元素的值
            data[front++] = null;     //释放队列的front端的元素
            return value;
        }
    }

    //队列长度
    public int length(){
        return rear-front;
    }
}

循环队列的顺序存储结构实现

import java.util.Arrays;

public class LoopQueue<E> {
    public Object[] data = null;
    private int maxSize; // 队列容量
    private int rear;// 队列尾,允许插入
    private int front;// 队列头,允许删除
    private int size=0; //队列当前长度

    public LoopQueue() {
        this(10);
    }

    public LoopQueue(int initialSize) {
        if (initialSize >= 0) {
            this.maxSize = initialSize;
            data = new Object[initialSize];
            front = rear = 0;
        } else {
            throw new RuntimeException("初始化大小不能小于0:" + initialSize);
        }
    }

    // 判空
    public boolean empty() {
        return size == 0;
    }

    // 插入
    public boolean add(E e) {
        if (size == maxSize) {
            throw new RuntimeException("队列已满,无法插入新的元素!");
        } else {
            data[rear] = e;
            rear = (rear + 1)%maxSize;
            size ++;
            return true;
        }
    }

    // 返回队首元素,但不删除
    public E peek() {
        if (empty()) {
            throw new RuntimeException("空队列异常!");
        } else {
            return (E) data[front];
        }
    }

    // 出队
    public E poll() {
        if (empty()) {
            throw new RuntimeException("空队列异常!");
        } else {
            E value = (E) data[front]; // 保留队列的front端的元素的值
            data[front] = null; // 释放队列的front端的元素
            front = (front+1)%maxSize;  //队首指针加1
            size--;
            return value;
        }
    }

    // 队列长度
    public int length() {
        return size;
    }

    //清空循环队列
    public void clear(){
        Arrays.fill(data, null);
        size = 0;
        front = 0;
        rear = 0;
    }
}

队列的链式存储结构实现

public class LinkQueue<E> {
    // 链栈的节点
    private class Node<E> {
        E e;
        Node<E> next;

        public Node() {
        }

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }
    }

    private Node front;// 队列头,允许删除
    private Node rear;// 队列尾,允许插入
    private int size; //队列当前长度 

    public LinkQueue() {
        front = null;
        rear = null;
    }

    //判空
      public boolean empty(){
          return size==0;
      }

      //插入
      public boolean add(E e){
          if(empty()){    //如果队列为空
              front = new Node(e,null);//只有一个节点,front、rear都指向该节点
              rear = front;
          }else{
              Node<E> newNode = new Node<E>(e, null);
              rear.next = newNode; //让尾节点的next指向新增的节点
              rear = newNode; //以新节点作为新的尾节点
          }
          size ++;
          return true;
      }

      //返回队首元素,但不删除
      public Node<E> peek(){
          if(empty()){
              throw new RuntimeException("空队列异常!");
          }else{
              return front;
          }
      }

      //出队
      public Node<E> poll(){
          if(empty()){
              throw new RuntimeException("空队列异常!");
          }else{
              Node<E> value = front; //得到队列头元素
              front = front.next;//让front引用指向原队列头元素的下一个元素
              value.next = null; //释放原队列头元素的next引用
              size --;
              return value;
          }
      }

      //队列长度
      public int length(){
          return size;
      }
}

基于LinkedList实现队列结构

/**
 * 使用java.util.Queue接口,其底层关联到一个LinkedList(双端队列)实例.
 */
import java.util.LinkedList;
import java.util.Queue;

public class QueueList<E> {
    private Queue<E> queue = new LinkedList<E>();

    // 将指定的元素插入此队列(如果立即可行且不会违反容量限制),在成功时返回 true,
    //如果当前没有可用的空间,则抛出 IllegalStateException。
    public boolean add(E e){
        return queue.add(e);
    }

    //获取,但是不移除此队列的头。
    public E element(){
        return queue.element();
    }

    //将指定的元素插入此队列(如果立即可行且不会违反容量限制),当使用有容量限制的队列时,
    //此方法通常要优于 add(E),后者可能无法插入元素,而只是抛出一个异常。
    public boolean offer(E e){
        return queue.offer(e);
    }

    //获取但不移除此队列的头;如果此队列为空,则返回 null
    public E peek(){
        return queue.peek();
    }

    //获取并移除此队列的头,如果此队列为空,则返回 null
    public E poll(){
        return queue.poll();
    }

    //获取并移除此队列的头
    public E remove(){
        return queue.remove();
    }

    //判空
    public boolean empty() {
        return queue.isEmpty();
    }
}
时间: 2024-09-30 01:43:04

Java实现栈和队列的相关文章

java实现栈与队列

一.栈 栈是一种特殊的线性表.其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行.(先进后出) 访问权限:栈限制了访问权限,只可以访问尾节点,也就是最后添加的元素 即栈顶的元素 1 /** 2 * 栈 先进后出 3 * @author Administrator 4 * 5 */ 6 public class MyStack { 7 private long [] arr; 8 private int top; 9 public MyStack(){ 10 arr=new long[

算法(第四版)学习笔记之java实现栈和队列(链表实现)

下压堆栈(链表实现): import java.util.Iterator; public class LinkedStack<Item> implements Iterable<Item> { public class Node { Item item; Node next; } private Node frist; private int N = 0; public boolean isEmpty() { return N == 0; } public int size()

java实现栈(可以无限put)

一直想用java实现栈.队列,可是没时间,马上要找实习了,就复习了一下算法,实现了一个简单的栈,代码还是有问题的,有兴趣的兄弟帮忙改正 问题:多线程的话pop和push只能有一个方法被执行需要加互斥变量 import java.util.Arrays; public class Stack<Item> { private transient Object[] data;// 存储数据 private int top;// 表示栈顶元素 private int oldCapacity; publ

栈和队列的面试题Java实现

栈和队列的面试题Java实现 二.栈和队列: 面试的时候,栈和队列经常会成对出现来考察.本文包含栈和队列的如下考试内容: (1)栈的创建 (2)队列的创建 (3)两个栈实现一个队列 (4)两个队列实现一个栈 (5)设计含最小函数min()的栈,要求min.push.pop.的时间复杂度都是O(1) (6)判断栈的push和pop序列是否一致 1.栈的创建: 我们接下来通过链表的形式来创建栈,方便扩充. 代码实现: 1 public class Stack { 2 3 public Node he

栈和队列常见题型(java版)

直接上干货..... 栈和队列常见题型: 实现栈和实现队列. 两个栈实现一个队列. 设计栈,使得pop,push和min时间复杂度为O(1). 滑动窗口的最大值. 栈的进出序列. 实现栈和实现队列 主要包括:栈,队列,循环队列. package com.sywyg; /** * 实现栈 * 数组应该是Object类型的 * 注意top的设置影响出栈和获取栈顶元素. * size也可以用top代替 */ class MyStack<E>{ // 栈元素个数 private int size; /

Java数据结构和算法之栈与队列

二.栈与队列 1.栈的定义 栈(Stack)是限制仅在表的一端进行插入和删除运算的线性表. (1)通常称插入.删除的这一端为栈顶(Top),另一端称为栈底(Bottom). (2)当表中没有元素时称为空栈. (3)栈为后进先出(Last In First Out)的线性表,简称为LIFO表. 栈的修改是按后进先出的原则进行. 每次删除(退栈)的总是当前栈中"最新"的元素,即最后插入(进栈)的元素,而最先插入的是被放在栈的底部,要到最后才能删除. 图1 [示例]元素是以a1,a2,-,a

Java数据结构与算法(第四章栈和队列)

本章涉及的三种数据存储类型:栈.队列和优先级队列. 不同类型的结构 程序员的工具 数组是已经介绍过的数据存储结构,和其他结构(链表.树等等)一样,都适用于数据应用中作数据记录. 然而,本章要讲解的是数据结构和算法更多的是作为程序员的工具来运用.它们组要作为构思算法的辅助工具,而不是完全的数据存储工具.这些数据结构的生命周期比那些数据库类型的结构要短的多.在程序操作执行期间它们才被创建,通常它们去执行某项特殊的任务,当完成之后,它们就被销毁. 受限访问 在数组中,只要知道下标就可以访问数据项.或顺

java 栈和队列的模拟--java

栈的定义:栈是一种特殊的表这种表只在表头进行插入和删除操作.因此,表头对于栈来说具有特殊的意义,称为栈顶.相应地,表尾称为栈底.不含任何元素的栈称为空栈. 栈的逻辑结构:假设一个栈S中的元素为an,an-1,..,a1,则称a1为栈底元素,an为栈顶元 素.栈中的元素按a1 ,a2,..,an-1,an的次序进栈.在任何时候,出栈的元素都是栈顶元素.换句话说,栈的修改是按后进先出的原则进行的.因此,栈又称为后进先出(Last In First Out)表,简称为LIFO表.所以,只要问题满足LI

浅析栈与队列在java中的基本应用

一.前提 摘自java程序设计教程(华盛顿大学/斯坦福大学著,陈志等译)-机械工业出版社 1.1栈/队列基础 像线性表一样,栈与队列中存储一组有序的值.这类数据结构至少需要支持下面几种操作: 将值放入数据结构中(添加操作): 将值从数据结构中取出(删除操作): 检查数据结构中是否还有值(判断数据结构是否为空). 栈与队列很相似:都是以某种特定的顺序存储元素序列.栈是一种先进先出/LIFO(LAST IN FIRST OUT)的结构,也就是最后保存到结构中的元素会最先被访问.队列则是一种先进先出/