JAVA数据结构--队列及优先队伍

注意优先队列在插入时已排序。故在删除,不是以原始插入数据为顺序的。

还要了解两种队列的优点缺少,适合应用的场合。。。

  1 class Queue
  2 {
  3     private int maxSize;
  4     private long[] queArray;
  5     private int front;
  6     private int rear;
  7     private int nItems;
  8
  9     public Queue(int s)
 10     {
 11         maxSize = s;
 12         queArray = new long[maxSize];
 13         front = 0;
 14         rear = -1;
 15         nItems = 0;
 16     }
 17     public void insert(long j)
 18     {
 19         if(rear == maxSize - 1)
 20             rear = -1;
 21         queArray[++rear] = j;
 22         nItems++;
 23         System.out.print("Insert value " + j + " into the queue,\t");
 24         System.out.print("nItems value is " + nItems);
 25         System.out.print("\trear value is " + rear);
 26         System.out.println("\tfront value is " + front);
 27     }
 28     public long remove()
 29     {
 30         long temp = queArray[front++];
 31         if(front == maxSize)
 32             front = 0;
 33         nItems--;
 34         System.out.print("Remove value " + temp + " from the queue,\t");
 35         System.out.print("nItems value is " + nItems);
 36         System.out.print("\trear value is " + rear);
 37         System.out.println("\tfront value is " + front);
 38         return temp;
 39     }
 40     public long peekFront()
 41     {
 42         return queArray[front];
 43     }
 44     public boolean isEmpty()
 45     {
 46         return (nItems == 0);
 47     }
 48     public boolean isFull()
 49     {
 50         return (nItems == maxSize);
 51     }
 52     public int size()
 53     {
 54         return nItems;
 55     }
 56 }
 57 class PriorityQ
 58 {
 59     private int maxSize;
 60     private long[] queArray;
 61     private int nItems;
 62
 63     public PriorityQ(int s)
 64     {
 65         maxSize = s;
 66         queArray = new long[maxSize];
 67         nItems = 0;
 68     }
 69     public void insert(long item)
 70     {
 71         int j;
 72
 73         if(nItems == 0)
 74             queArray[nItems++] = item;
 75         else
 76         {
 77             for(j = nItems - 1; j >= 0; j--)
 78             {
 79                 if(item > queArray[j])
 80                     queArray[j + 1] = queArray[j];
 81                 else
 82                     break;
 83             }
 84             queArray[j + 1] = item;
 85             nItems++;
 86             System.out.print("Insert item " + item + " into the priority queue,\t");
 87             System.out.println("nItems value is " + nItems);
 88         }
 89     }
 90     public long remove()
 91     {
 92         long temp = queArray[--nItems];
 93         System.out.print("Remove item " + temp + " from the priority queue,\t");
 94         System.out.println("nItems value is " + nItems);
 95         return temp;
 96     }
 97     public long peekMin()
 98     {
 99         return queArray[nItems - 1];
100     }
101     public boolean isEmpty()
102     {
103         return (nItems == 0);
104     }
105     public boolean isFull()
106     {
107         return (nItems == maxSize);
108     }
109 }
110 public class QueueApp {
111
112     /**
113      * @param args
114      */
115     public static void main(String[] args) {
116         // TODO Auto-generated method stub
117         System.out.println("Queue Operation:");
118         System.out.println("");
119         Queue myQueue = new Queue(20);
120
121         myQueue.insert(10);
122         myQueue.insert(20);
123         myQueue.insert(30);
124         myQueue.insert(40);
125
126         myQueue.remove();
127         myQueue.remove();
128         myQueue.remove();
129
130         myQueue.insert(50);
131         myQueue.insert(60);
132         myQueue.insert(70);
133         myQueue.insert(80);
134         myQueue.insert(90);
135         myQueue.insert(99);
136         System.out.println("");
137         System.out.println("Priority Queue Operation:");
138         System.out.println("");
139         PriorityQ myPQ = new PriorityQ(20);
140         myPQ.insert(200);
141         myPQ.insert(400);
142         myPQ.insert(100);
143         myPQ.insert(300);
144         myPQ.insert(500);
145
146         myPQ.remove();
147         myPQ.remove();
148
149         myPQ.insert(600);
150         myPQ.insert(700);
151
152
153
154     }
155
156 }

输出:

时间: 2025-01-24 14:19:14

JAVA数据结构--队列及优先队伍的相关文章

java数据结构与算法之双向循环队列的数组实现方法_java

本文实例讲述了java数据结构与算法之双向循环队列的数组实现方法.分享给大家供大家参考,具体如下: 需要说明的是此算法我并没有测试过,这里给出的相当于伪代码的算法思想,所以只能用来作为参考! package source; public class Deque { private int maxSize; private int left; private int right; private int nItems; private long[] myDeque; //constructor p

[数据结构] 队列

队列 队列是一种操作受限制的线性表,它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作.进行插入操作的端称为队尾,进行删除操作的端称为队头.  队列中没有元素时,称为空队列.在队列这种数据结构中,最先插入的元素将是最先被删除的元素:反之最后插入的元素将是最后被删除的元素,因此队列又称为"先进先出"(FIFO-first in first out)的线性表. 队列空的条件:front=rear 队列满的条件: rear = MAXSIZE 顺序队列 建立顺

PHP 数据结构队列(SplQueue)和优先队列(SplPriorityQueue)简单使用实例_php实例

队列这种数据结构更简单,就像我们生活中排队一样,它的特性是先进先出(FIFO). PHP SPL中SplQueue类就是实现队列操作,和栈一样,它也可以继承双链表(SplDoublyLinkedList)轻松实现. SplQueue类摘要如下: SplQueue简单使用如下: 复制代码 代码如下: $queue = new SplQueue();   /**  * 可见队列和双链表的区别就是IteratorMode改变了而已,栈的IteratorMode只能为:  * (1)SplDoublyL

java如何队列同步redis?

问题描述 java如何队列同步redis? 就是数据批量插入redis,然后再同步插入到数据库里面,怎么搞 解决方案 java redis使用之利用jedis实现redis消息队列0135 java redis使用之利用jedis实现redis消息队列java redis使用之利用jedis实现redis消息队列 解决方案二: 一般是数据先插入数据库,然后再利用触发器等把数据插入redis.或者用过期方式来从数据库同步数据到redis

编写一个JAVA的队列类

  根据这些特点,对队列定义了以下六种操作: enq(x) 向队列插入一个值为x的元素; deq() 从队列删除一个元素; front() 从队列中读一个元素,但队列保持不变; empty() 判断队列是否为空,空则返回真; clear() 清空队列; search(x) 查找距队首最近的元素的位置,若不存在,返回-1. Vector类是JAVA中专门负责处理对象元素有序存储和任意增删的类,因此,用Vector 可以快速实现JAVA的队列类. public class Queue extends

PHP 数据结构队列(SplQueue)和优先队列(SplPriorityQueue)简单使用实例

  这篇文章主要介绍了PHP 数据结构队列(SplQueue)和优先队列(SplPriorityQueue)简单使用实例,需要的朋友可以参考下 队列这种数据结构更简单,就像我们生活中排队一样,它的特性是先进先出(FIFO). PHP SPL中SplQueue类就是实现队列操作,和栈一样,它也可以继承双链表(SplDoublyLinkedList)轻松实现. SplQueue类摘要如下: SplQueue简单使用如下: 代码如下: $queue = new SplQueue(); /** * 可见

链表-关于数据结构队列问题

问题描述 关于数据结构队列问题 2C 用队列做一个模拟抢红包的小程序,但现在还没有思路,望前辈不吝啬赐教之,谢谢. 解决方案 数据结构之队列数据结构--队列实现舞伴配对问题数据结构-栈和队列

JAVA数据结构系列 栈

java数据结构系列之栈 手写栈 1.利用链表做出栈,因为栈的特殊,插入删除操作都是在栈顶进行,链表不用担心栈的长度,所以链表再合适不过了,非常好用,不过它在插入和删除元素的时候,速度比数组栈慢,因为它要维护自己的指针(Next)引用. package com.rsc.stack; import java.util.LinkedList; /** * 利用链表实现的栈 * @author 落雨 * http://ae6623.cn * @param <T> */ public class Li

java数据结构和算法 22只鞋子,拿多少次可以拿一双

问题描述 java数据结构和算法 22只鞋子,拿多少次可以拿一双 22只鞋子 5双运动鞋,4双凉鞋,2双礼服鞋放在看不到的盒子里, 一次拿一只 最少拿多少次可以拿一双鞋子(左右脚也要对应) 解决方案 假设已经拿了5只左脚的运动鞋,4只凉鞋,2只礼服鞋,那么再拿一只,一定可以组成一双鞋,所以是12次 解决方案二: 应该是12次,不信的话你在问其他人. 解决方案三: 最少几次?2最多几次?12.....