用java语言设计顺序循环队列类
2024-05-19 03:47
1. 用java语言设计顺序循环队列类
代码如下：
import java.io.Serializable;import java.util.Arrays;public class LoopQueue implements Serializable { /** * @Fields serialVersionUID : TODO */ private static final long serialVersionUID = -3670496550272478781L; private int DEFAULT_SIZE = 10; private int capacity;// 保存数组的长度 private Object[] elementData;// 定义一个数组用于保存循环队列的元素 private int front = 0;// 队头 private int rear = 0;// 队尾 // 以默认数组长度创建空循环队列 public LoopQueue() { capacity = DEFAULT_SIZE; elementData = new Object[capacity]; } // 以一个初始化元素来创建循环队列 public LoopQueue(T element) { this(); elementData[0] = element; rear++; } /** * 以指定长度的数组来创建循环队列 * * @param element * 指定循环队列中第一个元素 * @param initSize * 指定循环队列底层数组的长度 */ public LoopQueue(T element, int initSize) { this.capacity = initSize; elementData = new Object[capacity]; elementData[0] = element; rear++; } // 获取循环队列的大小 public int size() { if (isEmpty()) { return 0; } return rear > front ? rear - front : capacity - (front - rear); } // 插入队列 public void add(T element) { if (rear == front && elementData[front] != null) { throw new IndexOutOfBoundsException("队列已满的异常"); } elementData[rear++] = element; // 如果rear已经到头，那就转头 rear = rear == capacity ? 0 : rear; } // 移除队列 public T remove() { if (isEmpty()) { throw new IndexOutOfBoundsException("空队列异常"); } // 保留队列的rear端的元素的值 T oldValue = (T) elementData[front]; // 释放队列的rear端的元素 elementData[front++] = null; // 如果front已经到头，那就转头 front = front == capacity ? 0 : front; return oldValue; } // 返回队列顶元素，但不删除队列顶元素 public T element() { if (isEmpty()) { throw new IndexOutOfBoundsException("空队列异常"); } return (T) elementData[front]; } // 判断循环队列是否为空队列 public boolean isEmpty() { // rear==front且rear处的元素为null return rear == front && elementData[rear] == null; } // 清空循环队列 public void clear() { // 将底层数组所有元素赋为null Arrays.fill(elementData, null); front = 0; rear = 0; } public String toString() { if (isEmpty()) { return "[]"; } else { // 如果front = rear，有效元素为front->capacity之间、0->front之间的 else { StringBuilder sb = new StringBuilder("["); for (int i = front; i queue = new LoopQueue("aaaa", 3); // 添加两个元素 queue.add("bbbb"); queue.add("cccc"); // 此时队列已满 System.out.println(queue); // 删除一个元素后，队列可以再多加一个元素 queue.remove(); System.out.println("删除一个元素后的队列：" + queue); // 再次添加一个元素，此时队列又满 queue.add("dddd"); System.out.println(queue); System.out.println("队列满时的长度：" + queue.size()); // 删除一个元素后，队列可以再多加一个元素 queue.remove(); // 再次加入一个元素，此时队列又满 queue.add("eeee"); System.out.println(queue); }}
2. Java设计一个名为Queue的类用于存储整数。像栈一样，队列具有元素。在栈中，元素以“后进先出”的方式
参考代码和注释如下
简单测试了下,如果有问题接着在讨论
public class Queue { private int[] elements; public static final int DEFAULT_CAPACITY =8;//默认长度8 private int size = 0; public Queue() { elements = new int[DEFAULT_CAPACITY]; } public Queue(int capacity) { elements = new int[capacity]; } public void enqueue(int v) { if (size >= elements.length) {// 数组扩容 int[] temp = new int[elements.length * 2]; System.arraycopy(elements, 0, temp, 0, elements.length); elements = temp; } elements[size++] = v; } public int dequeue() {// 先进先出 if (empty()) { throw new RuntimeException("异常"); } int x = elements[0];// 先把第一个元素保存出来 // 左移一位 // int[] temp = new int[elements.length]; // System.arraycopy(elements,1, temp, 0, elements.length-1); // elements = temp; // 左移一位 for (int i = 0; i < elements.length - 1; i++) { elements[i] = elements[i + 1]; } elements[elements.length - 1] = 0;// 外面一般访问不了elements 后面的元素可以不用归零,但是归零了感觉舒服点 size--; return x; } public boolean empty() { return size == 0; } public int getSize() { return size; }}输出
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
3. java作业 第一题：用ArrayList和LinkedList实现先进先出队列Queue。自定义class Queue。
帮小学生写作业是要拿钱的。。。
4. Java使用LinkedList来模拟一个队列(先进先出的特性)
import java.util.LinkedList;public class Demo01 { private LinkedList linkedList; public Demo01() { linkedList = new LinkedList(); } public void put(Object object) { linkedList.add(object); } public Object get() { Object object = null; if (linkedList.size() != 0) { object = linkedList.get(0); linkedList.remove(0); } return object; } public boolean isEmpty() { if (linkedList.size() != 0) { return true; } else { return false; } } public static void main(String[] args) { Demo01 demo01 = new Demo01(); demo01.put("1"); demo01.put("2"); System.out.println(demo01.get()); System.out.println(demo01.get()); System.out.println(demo01.isEmpty()); }}结果：
1
2
false
5. 大家帮帮我做这几道JAVA编程题~~谢谢
1、Queue
import java.util.LinkedList;
public class Queue {
LinkedList queue;
public Queue() {
queue = new LinkedList();
}
void add(Object o) {
queue.addLast(o);
}
Object get() {
Object o = null;
if (!queue.isEmpty()) {
o = queue.getFirst();
queue.removeFirst();
}
return o;
}
public static void main(String[] args){
Queue q=new Queue();
System.out.println(q.get());
q.add("1");
System.out.println(q.get());
q.add("2");
q.add("3");
System.out.println(q.get());
q.add("4");
q.add("5");
System.out.println(q.get());
System.out.println(q.get());
System.out.println(q.get());
System.out.println(q.get());
}
}
2、
function process(){
cardid=document.getElementById("cardid").value;
idexp="^[0-9]{18}$";//18位身份证正则表达式
var patrn=new RegExp(idexp);
if(patrn.test(cardid)){
year=cardid.substring(6,10);
month=cardid.substring(10,12);
day=cardid.substring(12,14);
alert("您的生日为:"+year+"年"+month+"月"+day+"日。");
}
else{
alert("身份证号码错!");
}
}
身份证号:
3、counter.jsp
6. 自己设计一个队列 java
public class SyncStack {
private int rear;//队尾
private int front;//队头
private Product[] queArray;//队列
public SyncStack(int s) {
front = 0;
queArray = new Product[s];
rear = -1;
}
public synchronized void push(Product product) {
while (rear == queArray.length - 1) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notifyAll();
queArray[rear + 1] = product;
rear++;
}
public synchronized Product pop() {
while (front == rear + 1) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
front++;
this.notifyAll();
return queArray[front-1];
}
}
7. java 用什么实现 FIFO队列？
java使用数据结构来实现FIFO先进先出的队列，实例如下：
/* * To change this template, choose Tools | Templates * and open the template in the editor. */package linkedlisttest;import java.util.ArrayList;import java.util.Deque;import java.util.LinkedList;import java.util.List;/** * * @author Vicky.H * @email eclipser@163.com */public class FIFOTest { /** * @param args the command line arguments */ public static void main(String[] args) { FIFO fifo = new FIFOImpl(5); for (int i = 0; i polls = fifo.setMaxSize(3); for (A a : polls) { System.out.println("\thead:" + a); } System.out.println("剩余数据"); for (A a : fifo) { System.out.println("\thead:" + a); } System.out.println(fifo.size()); }}interface FIFO extends List, Deque, Cloneable, java.io.Serializable { /** * 向最后添加一个新的，如果长度超过允许的最大值，则弹出一个 * */ T addLastSafe(T addLast); /** * 弹出head，如果Size = 0返回null。而不同于pop抛出异常 * @return */ T pollSafe(); /** * 获得最大保存 * * @return */ int getMaxSize(); /** * 设置最大存储范围 * * @return 返回的是，因为改变了队列大小，导致弹出的head */ List setMaxSize(int maxSize);}class FIFOImpl extends LinkedList implements FIFO { private int maxSize = Integer.MAX_VALUE; private final Object synObj = new Object(); public FIFOImpl() { super(); } public FIFOImpl(int maxSize) { super(); this.maxSize = maxSize; } @Override public T addLastSafe(T addLast) { synchronized (synObj) { T head = null; while (size() >= maxSize) { head = poll(); } addLast(addLast); return head; } } @Override public T pollSafe() { synchronized (synObj) { return poll(); } } @Override public List setMaxSize(int maxSize) { List list = null; if (maxSize (); synchronized (synObj) { while (size() > maxSize) { list.add(poll()); } } } this.maxSize = maxSize; return list; } @Override public int getMaxSize() { return this.maxSize; }}class A { private String name; public A() { } public A(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "A{" + "name=" + name + '}'; }}
8. 栈、队列中“先进先出”，“后进先出”的含义
先进先出（FIFO，first-in，first-out）为处理从队列或堆栈发出的程序工作要求的一种方法，它使最早的要求被最先处理。后进先出，从栈中取出数据项的顺序与将它们插入栈的顺序相反。 FIFO由6个功能块组成，它们是存储体、写计数器（WP）、读计数器（RP）、满逻辑IN_FULL、空逻辑IN_EMPTY和选择逻辑SELECT。这是一个同步的FIFO。在时钟脉冲的上升沿作用下，当WR=0且FULL=0时，DIN的数据将压入FIFO堆栈。 在通常情况下，RP所指出的单元内容总是放于DOUT的输出数据线上，只是在RD=0且EMPTY=0时，RP的内容才改变而指向FIFO的下一个单元，下一个单元的内容替换当前内容并从DOUT输出。 应注意，在任何时候DOUT上都有一个数据输出，而不像RAM那样，只有在读有效时才有数据输出，平时为三态输出。 扩展资料 LIFO与FIFO存储器一样没有外部地址码输入端，而是由内部的指针指示存取的地址。LIFO只需一个指针。复位时，指针指向最末一个单元（栈底）。每写入一个数据，指针减1。当指针值减为0时，表示LIFO充满数据。 每读出一个数据，指针加1。当指针值为最大值(即指向栈底)时，说明LIFO中没有数据了。通常把LIFO（堆栈）的写入操作叫压入，读出操作叫弹出。 参考资料来源：百度百科-后进先出存储列表 参考资料来源：百度百科-先进先出
最新文章
热门文章
推荐阅读