数据结构之队列及Java实现

原创 2018年04月17日 20:31:00

一、队列的基本介绍

队列也是一种特殊的线性表,特点是先进先出,只能在表的一端进行插入,在另一端进行删除。向队列中插入元素的过程称为入队(Enqueue),删除元素的过程称为出队(Dequeue),并把允许入队的一端称为队尾,允许出的的一端称为队头,没有任何元素的队列则称为空队。其一般结构如下所示:

二、队列的Java实现

与栈的实现相似,队列也有两种实现方式,分别基于数组和基于链表。由于队列是被限制的线性表,所以不能提供线性表中的方法如:获取指定索引处的元素、查找元素的位置、向指定索引处插入元素、删除索引处的元素等。
队列的常用操作如下所示:

  • 初始化:创建空队列
  • 获取队列的长度:返回队列元素的个数
  • 加入元素:向队列的rear端插入元素
  • 删除元素:在队列的front端删除元素
  • 判断队列是否为空:已空返回true,否则返回false

下面分别介绍两种方式的实现:
1.基于数组的队列


public class ArrayQueue<T> {
    private int MaxSize;
    private T data[];
    private int front;
    private int rear;
    //构造函数初始化
    public ArrayQueue(int size){
        MaxSize = size;
        data = (T[]) new Object[MaxSize];
        front = 0;
        rear = 0;
    }
    //添加元素,加到队尾
    public boolean add(T value){
        if(value == null){
            return false;
        }
        if(rear > MaxSize -1){
            return false;
        }
        data[rear] = value;
        rear++;
        return true;
    }
    //队列长度
    public int length(){
        return rear-front;
    }
    //判断是否为空
    public boolean isEmpty(){
        if(length() == 0){
            return true;
        }
        return false;
    }
    //删除元素,删除队头节点
    public T del(){
        T tmp = null;
        if(isEmpty()){
            return tmp;
        }
        tmp = data[front];
        data[front] = null;
        front++;
        return tmp;
    }
    //队列元素遍历
    public String toString(){
        String str = "";
        for(int i=front;i<rear;i++){
            str = str + data[i] + " ";
        }
        return str;
    }
    public static void main(String args[]){
        ArrayQueue<String> aq = new ArrayQueue<String>(3);
        //添加元素测试
        aq.add("qwer");
        aq.add("asdf");
        aq.add("zxcv");
        //队列已满测试
        System.out.println(aq.add("uiop"));
        System.out.println(aq.toString());
        //队列删除测试
        aq.del();
        System.out.println(aq.toString());
        aq.del();
        System.out.println(aq.toString());
    }


}

测试结果:

false
qwer asdf zxcv 
asdf zxcv 
zxcv 

2.基于链表的队列


public class NodeQueue<T> {
    class Node<T>{
        Node<T> next = null;
        T data = null;
        public Node(T value){
            this.data = value;
        }
    }
    Node<T> front = null;
    Node<T> rear = null;
    public NodeQueue(){
        front = null;
        rear = null;
    }
    //添加节点到队尾,如果队列为空头结点和尾节点都只向新节点
    public void add(T value){
        if(value == null){
            return;
        }
        if(front == null){
            front = new Node<T>(value);
            rear = front;
        }
        else{
            Node<T> n = new Node<T>(value);
            rear.next = n;
            rear = n;
        }
    }
    //返回队列的长度
    public int length(){
        if(front == null){
            return 0;
        }
        int num = 1;
        Node<T> cur = front;
        while(cur.next!=null){
            num++;
            cur = cur.next;
        }
        return num;
    }
    //删除节点,将队头的节点删除
    public boolean del(){
        if(length()==0){
            return false;
        }
        Node n = front.next;
        front = n;
        return true;
    }
    //打印队列内容
    public String toString(){
        String str = "";
        Node<T> cur; 
        for(cur = front;cur!=null;cur=cur.next){
            str = str + cur.data + " ";
        }
        return str;
    }
    public static void main(String args[]){
        NodeQueue<String> nq = new NodeQueue<String>();
        //添加节点测试
        System.out.println(nq.length());
        nq.add("qwer");
        nq.add("asdf");
        nq.add("zxcv");
        System.out.println(nq.toString());
        System.out.println(nq.length());
        //删除节点测试
        nq.del();
        System.out.println(nq.toString());
        System.out.println(nq.length());
    }


}

测试结果:

0
qwer asdf zxcv 
3
asdf zxcv 
2
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/xdzhouxin/article/details/79980289

数据结构(Java)——队列的实现

队列是一种线性集合,其元素从一端加入,从另一端删除。因此队列是按照先进先出方式处理的,从队列中删除元素的次序与往队列里放置元素的的次序是一样的。 由于队列是一种线性集合,因此可以像处理栈一样,把队列实...
  • zhangyifei521
  • zhangyifei521
  • 2015-11-16 19:19:07
  • 396

【数据结构+Java】Java实现简单队列、循环队列操作

Java实现简单队列、循环队列操作1.简单队列package queue; import java.util.Scanner; /** * 队列节点 * @author wsz * @date...
  • qq_33560169
  • qq_33560169
  • 2018-01-18 22:04:47
  • 168

java数据结构与算法之(Queue)队列设计与实现

队列的抽象数据类型 顺序队列的设计与实现 链式队列的设计与实现 队列的简单应用 优先队列的设置与实现...
  • javazejian
  • javazejian
  • 2016-12-04 10:05:06
  • 13472

【数据结构】堆栈、队列的原理及java实现

栈(stack)又名堆栈,它是一种先进后出(FILO)的线性表。其限制是仅允许在表的一端进行插入和删除运算。 队列 是一种先进先出的线性表。其限制仅在表的一端(尾端)进行插入,另一端(首端)进行删除的...
  • jianyuerensheng
  • jianyuerensheng
  • 2016-04-21 19:21:47
  • 4837

数据结构——队列(Java实现)

编程实现对循环链队列的入队和出队操作。 ⑴根据输入的队列长度n和各元素值建立一个带头结点的循环链表表示的队列(循环链队列),并且只设一个尾指针来指向尾结点,然后输出队列中各元素值。 ⑵将数据元...
  • qq_18860653
  • qq_18860653
  • 2016-11-21 16:59:08
  • 780

【JAVA数据结构】先进先出队列

队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的...
  • silk_bar
  • silk_bar
  • 2016-09-21 22:11:00
  • 2730

【数据结构】之队列的java实现(一)

队列的定义: 队列(Queue)是只允许在一端进行插入,而在另一端进行删除的运算受限的线性表。 (1)允许删除的一端称为队头(Front)。 (2)允许插入的一端称为队尾(Rear)。 (3)当队列...
  • wuwenxiang91322
  • wuwenxiang91322
  • 2013-10-04 09:31:22
  • 19429

java数据结构之链式队列的实现

今天介绍一下数据结构中的链式队列,和线形队列相同的是它也有队头front,和队尾rear。 规则和线形队列相同也是先进先出(FIFO),队尾进,队头出。 下面看具体的链式队列的具体实现案例: pack...
  • linzhiqiang0316
  • linzhiqiang0316
  • 2016-06-03 21:45:44
  • 1210

数据结构的Java实现——栈和队列

栈(Stack)作为一个先进后出(FILO) 的线性结构,只支持在栈顶的插入和弹出。队列(Queue)作为一个先进先出(FIFO) 的线性结构,支持在队首获取元素,在对尾插入元素。 栈的实现: p...
  • baoyiming1991
  • baoyiming1991
  • 2011-03-21 22:35:00
  • 6116

java数据结构队列(Queue)之个人理解

1. 队列定义   队列(Queue)是只允许在一端进行插入,而在另一端进行删除的运算受限的线性表。 (1)允许删除的一端称为队头(Front)。 (2)允许插入的一端称为队尾(Rear...
  • u010268227
  • u010268227
  • 2016-11-09 21:20:25
  • 1252
收藏助手
不良信息举报
您举报文章:数据结构之队列及Java实现
举报原因:
原因补充:

(最多只允许输入30个字)