Java实现三种（顺序，链式，循环）队列
来源：互联网 发布：linux中vi显示行号 编辑：程序博客网 时间：2024/06/05 14:56
1.顺序队列的实现
package lang; import java.io.Serializable; import java.util.Arrays; /** * @ClassName: ArrayQueue * @Description: 顺序队列 * @date 2014年1月20日 下午3:46:19 * @param <T> */ public class ArrayQueue<T> implements Serializable{ /** * @Fields serialVersionUID : TODO */ private static final long serialVersionUID = 7333344126529379197L; private int DEFAULT_SIZE = 10; private int capacity;//保存数组的长度 private Object[] elementData;//定义一个数组用于保存顺序队列的元素 private int front = 0;//队头 private int rear = 0;//队尾 //以默认数组长度创建空顺序队列 public ArrayQueue() { capacity = DEFAULT_SIZE; elementData = new Object[capacity]; } //以一个初始化元素来创建顺序队列 public ArrayQueue(T element) { this(); elementData[0] = element; rear++; } public ArrayQueue(int initSize) { elementData = new Object[initSize]; } /** * 以指定长度的数组来创建顺序队列 * @param element 指定顺序队列中第一个元素 * @param initSize 指定顺序队列底层数组的长度 */ public ArrayQueue(T element, int initSize) { this.capacity = initSize; elementData = new Object[capacity]; elementData[0] = element; rear++; } /** * @Title: size * @Description: 获取顺序队列的大小 * @return */ public int size() { return rear - front; } /** * @Title: offer * @Description: 入队 * @param element */ public void offer(T element) { ensureCapacity(rear + 1); elementData[rear++] = element; } private void ensureCapacity(int minCapacity) { //如果数组的原有长度小于目前所需的长度 int oldCapacity = elementData.length; if (minCapacity > oldCapacity) { int newCapacity = (oldCapacity * 3) / 2 + 1; if (newCapacity < minCapacity) newCapacity = minCapacity; // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); } } /** * @Title: poll * @Description: 出队 * @return */ public T poll() { if (isEmpty()) { throw new IndexOutOfBoundsException("空队列异常"); } //保留队列的front端的元素的值 T oldValue = (T) elementData[front]; //释放队列的front端的元素 elementData[front++] = null; return oldValue; } /** * @Title: peek * @Description: 返回队列顶元素，但不删除队列顶元素 * @return */ public T peek() { if (isEmpty()) { throw new IndexOutOfBoundsException("空队列异常"); } return (T) elementData[front]; } /** * @Title: isEmpty * @Description: 判断顺序队列是否为空队列 * @return */ public boolean isEmpty() { return rear == front; } /** * @Title: clear * @Description: 清空顺序队列 */ public void clear() { //将底层数组所有元素赋为null Arrays.fill(elementData, null); front = 0; rear = 0; } public String toString() { if (isEmpty()) { return "[]"; } else { StringBuilder sb = new StringBuilder("["); for (int i = front; i < rear; i++) { sb.append(elementData[i].toString() + ", "); } int len = sb.length(); return sb.delete(len - 2, len).append("]").toString(); } } } 2. 链式队列的实现
package lang; import java.io.Serializable; /** * @ClassName: LinkQueue * @Description: 链式队列 * @date 2014年1月21日 下午3:24:38 * @param <T> */ public class LinkQueue<T> implements Serializable{ /** * @Fields serialVersionUID : TODO */ private static final long serialVersionUID = -6726728595616312615L; //定义一个内部类Node，Node实例代表链队列的节点。 private class Node { private T data;//保存节点的数据 private Node next;//指向下个节点的引用 //无参数的构造器 public Node() { } //初始化全部属性的构造器 public Node(T data, Node next) { this.data = data; this.next = next; } } private Node front;//保存该链队列的头节点 private Node rear;//保存该链队列的尾节点 private int size;//保存该链队列中已包含的节点数 /** * <p>Title: LinkQueue </p> * <p>Description: 创建空链队列 </p> */ public LinkQueue() { //空链队列，front和rear都是null front = null; rear = null; } /** * <p>Title: LinkQueue </p> * <p>Description: 以指定数据元素来创建链队列，该链队列只有一个元素</p> */ public LinkQueue(T element) { front = new Node(element, null); //只有一个节点，front、rear都指向该节点 rear = front; size++; } /** * @Title: size * @Description: 获取顺序队列的大小 * @return */ public int size() { return size; } /** * @Title: offer * @Description: 入队 * @param element */ public void offer(T element) { //如果该链队列还是空链队列 if (front == null) { front = new Node(element, null); rear = front;//只有一个节点，front、rear都指向该节点 } else { Node newNode = new Node(element, null);//创建新节点 rear.next = newNode;//让尾节点的next指向新增的节点 rear = newNode;//以新节点作为新的尾节点 } size++; } /** * @Title: poll * @Description: 出队 * @return */ public T poll() { Node oldFront = front; front = front.next; oldFront.next = null; size--; return oldFront.data; } /** * @Title: peek * @Description: 返回队列顶元素，但不删除队列顶元素 * @return */ public T peek() { return rear.data; } /** * @Title: isEmpty * @Description: 判断顺序队列是否为空队列 * @return */ public boolean isEmpty() { return size == 0; } /** * @Title: clear * @Description: 清空顺序队列 */ public void clear() { //将front、rear两个节点赋为null front = null; rear = null; size = 0; } public String toString() { //链队列为空链队列时 if (isEmpty()) { return "[]"; } else { StringBuilder sb = new StringBuilder("["); for (Node current = front; current != null; current = current.next) { sb.append(current.data.toString() + ", "); } int len = sb.length(); return sb.delete(len - 2, len).append("]").toString(); } } public static void main(String[] args) { LinkQueue<String> queue = new LinkQueue<String>("aaaa"); //添加两个元素 queue.offer("bbbb"); queue.offer("cccc"); System.out.println(queue); //删除一个元素后 queue.poll(); System.out.println("删除一个元素后的队列：" + queue); //再次添加一个元素 queue.offer("dddd"); System.out.println("再次添加元素后的队列：" + queue); //删除一个元素后，队列可以再多加一个元素 queue.poll(); //再次加入一个元素 queue.offer("eeee"); System.out.println(queue); } } 3. 循环队列的实现
package lang; import java.io.Serializable; import java.util.Arrays; /** * @ClassName: LoopQueue * @Description: 循环队列 * @date 2014年1月20日 下午3:47:14 */ public class LoopQueue<T> 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到rear之间的元素 if (front < rear) { StringBuilder sb = new StringBuilder("["); for (int i = front; i < rear; i++) { sb.append(elementData[i].toString() + ", "); } int len = sb.length(); return sb.delete(len - 2, len).append("]").toString(); } //如果front >= rear，有效元素为front->capacity之间、0->front之间的 else { StringBuilder sb = new StringBuilder("["); for (int i = front; i < capacity; i++) { sb.append(elementData[i].toString() + ", "); } for (int i = 0; i < rear; i++) { sb.append(elementData[i].toString() + ", "); } int len = sb.length(); return sb.delete(len - 2, len).append("]").toString(); } } } public static void main(String[] args) { LoopQueue<String> queue = new LoopQueue<String>("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); } } 阅读全文
0 0
- Java实现三种（顺序，链式，循环）队列
- java队列实现（顺序队列、链式队列、循环队列）
- java队列实现（顺序队列、链式队列、循环队列）
- Java实现链式队列，顺序队列，循环队列
- 数据结构Java实现07----队列：顺序队列&顺序循环队列、链式队列、顺序优先队列
- 数据结构Java实现07----队列：顺序队列&顺序循环队列、链式队列、顺序优先队列
- 数据结构Java实现07----队列：顺序队列&顺序循环队列、链式队列、顺序优先队列
- 数据结构Java实现07----队列：顺序队列&顺序循环队列、链式队列、顺序优先队列
- Java数据结构07----队列：顺序队列&顺序循环队列、链式队列、顺序优先队列
- c/c++实现顺序循环队列和链式队列
- 队列的顺序实现(循环数组)与链式实现
- JAVA实现数组队列，循环数组队列，链式队列
- 数据结构之java实现链式队列(三)
- 链式循环队列实现（C语言）
- Java队列（链式实现）
- 重温数据结构：队列的链式实现、顺序实现及循环队列
- C#实现循环顺序队列（队列）
- Java实现链式队列
- Java后端WebSocket的Tomcat实现
- 敏捷开发：IT人应该做的创新与变
- 二维数组矩阵转置
- ansible基本使用
- tar压缩解压缩命令详解
- Java实现三种（顺序，链式，循环）队列
- The absolute uri: http://java.sun.com/jsp/jstl/core cannot be resolved in either web.xml or the jar
- test2
- centos快速安装mysql
- C++ Qt学习教程1-50
- JAVA SkipList 跳表 的原理和使用例子
- Android 屏幕适配攻略（五）动态创建控件并设置控件的大小
- jstl标签库易犯错误
- [Azure]使用Powershell统计经典存储账号下容器中Blob的使用情况
