跳舞配对 销毁链式队列循环队列
点击联系发帖人
时间：2016-04-11 02:44
4962人阅读
数据结构（33）
双向顺序队列ArrayDeque和双向链式队列LinkedList，JDK已经包含，在此略。ArrayDeque包括顺序栈和顺序队列，LinkedList包含链式栈和链式队列。ArrayDeque和LinkedList都是线程不安全的。PriorityQueue优先队列也在JDK。
1.顺序队列的实现
import java.io.S
import java.util.A
* @ClassName: ArrayQueue
* @Description: 顺序队列
* @date 日 下午3:46:19
* @param &T&
public class ArrayQueue&T& implements Serializable{
* @Fields serialVersionUID : TODO
private static final long serialVersionUID = 9379197L;
private int DEFAULT_SIZE = 10;
//保存数组的长度
private Object[] elementD//定义一个数组用于保存顺序队列的元素
private int front = 0;//队头
private int rear = 0;//队尾
//以默认数组长度创建空顺序队列
public ArrayQueue() {
capacity = DEFAULT_SIZE;
elementData = new Object[capacity];
//以一个初始化元素来创建顺序队列
public ArrayQueue(T element) {
elementData[0] =
public ArrayQueue(int initSize) {
elementData = new Object[initSize];
* 以指定长度的数组来创建顺序队列
* @param element 指定顺序队列中第一个元素
* @param initSize 指定顺序队列底层数组的长度
public ArrayQueue(T element, int initSize) {
this.capacity = initS
elementData = new Object[capacity];
elementData[0] =
* @Title: size
* @Description: 获取顺序队列的大小
public int size() {
return rear -
* @Title: offer
* @Description: 入队
* @param element
public void offer(T element) {
ensureCapacity(rear + 1);
elementData[rear++] =
private void ensureCapacity(int minCapacity) {
//如果数组的原有长度小于目前所需的长度
int oldCapacity = elementData.
if (minCapacity & oldCapacity) {
int newCapacity = (oldCapacity * 3) / 2 + 1;
if (newCapacity & minCapacity)
newCapacity = minC
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
* @Title: poll
* @Description: 出队
public T poll() {
if (isEmpty()) {
throw new IndexOutOfBoundsException(&空队列异常&);
//保留队列的front端的元素的值
T oldValue = (T) elementData[front];
//释放队列的front端的元素
elementData[front++] =
return oldV
* @Title: peek
* @Description: 返回队列顶元素，但不删除队列顶元素
public T peek() {
if (isEmpty()) {
throw new IndexOutOfBoundsException(&空队列异常&);
return (T) elementData[front];
* @Title: isEmpty
* @Description: 判断顺序队列是否为空队列
public boolean isEmpty() {
return rear ==
* @Title: clear
* @Description: 清空顺序队列
public void clear() {
//将底层数组所有元素赋为null
Arrays.fill(elementData, null);
front = 0;
public String toString() {
if (isEmpty()) {
return &[]&;
StringBuilder sb = new StringBuilder(&[&);
for (int i = i & i++) {
sb.append(elementData[i].toString() + &, &);
int len = sb.length();
return sb.delete(len - 2, len).append(&]&).toString();
2. 链式队列的实现
import java.io.S
* @ClassName: LinkQueue
* @Description:
* @date 日 下午3:24:38
* @param &T&
public class LinkQueue&T& implements Serializable{
* @Fields serialVersionUID : TODO
private static final long serialVersionUID = -6312615L;
//定义一个内部类Node，Node实例代表链队列的节点。
private class Node {
private T//保存节点的数据
private N//指向下个节点的引用
//无参数的构造器
public Node() {
//初始化全部属性的构造器
public Node(T data, Node next) {
this.data =
this.next =
private N//保存该链队列的头节点
private N//保存该链队列的尾节点
//保存该链队列中已包含的节点数
* &p&Title: LinkQueue &/p&
* &p&Description: 创建空链队列 &/p&
public LinkQueue() {
//空链队列，front和rear都是null
* &p&Title: LinkQueue &/p&
* &p&Description: 以指定数据元素来创建链队列，该链队列只有一个元素&/p&
public LinkQueue(T element) {
front = new Node(element, null);
//只有一个节点，front、rear都指向该节点
* @Title: size
* @Description: 获取顺序队列的大小
public int size() {
* @Title: offer
* @Description: 入队
* @param element
public void offer(T element) {
//如果该链队列还是空链队列
if (front == null) {
front = new Node(element, null);
rear =//只有一个节点，front、rear都指向该节点
Node newNode = new Node(element, null);//创建新节点
rear.next = newN//让尾节点的next指向新增的节点
rear = newN//以新节点作为新的尾节点
* @Title: poll
* @Description: 出队
public T poll() {
Node oldFront =
front = front.
oldFront.next =
return oldFront.
* @Title: peek
* @Description: 返回队列顶元素，但不删除队列顶元素
public T peek() {
return rear.
* @Title: isEmpty
* @Description: 判断顺序队列是否为空队列
public boolean isEmpty() {
return size == 0;
* @Title: clear
* @Description: 清空顺序队列
public void clear() {
//将front、rear两个节点赋为null
public String toString() {
//链队列为空链队列时
if (isEmpty()) {
return &[]&;
StringBuilder sb = new StringBuilder(&[&);
for (Node current = current != 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. 循环队列的实现
import java.io.S
import java.util.A
* @ClassName: LoopQueue
* @Description: 循环队列
* @date 日 下午3:47:14
public class LoopQueue&T& implements Serializable{
* @Fields serialVersionUID : TODO
private static final long serialVersionUID = -2478781L;
private int DEFAULT_SIZE = 10;
//保存数组的长度
private Object[] elementD//定义一个数组用于保存循环队列的元素
private int front = 0;//队头
private int rear = 0;//队尾
//以默认数组长度创建空循环队列
public LoopQueue() {
capacity = DEFAULT_SIZE;
elementData = new Object[capacity];
//以一个初始化元素来创建循环队列
public LoopQueue(T element) {
elementData[0] =
* 以指定长度的数组来创建循环队列
* @param element 指定循环队列中第一个元素
* @param initSize 指定循环队列底层数组的长度
public LoopQueue(T element, int initSize) {
this.capacity = initS
elementData = new Object[capacity];
elementData[0] =
//获取循环队列的大小
public int size() {
if (isEmpty()) {
return rear & front ? rear - front : capacity - (front - rear);
//插入队列
public void add(T element) {
if (rear == front && elementData[front] != null) {
throw new IndexOutOfBoundsException(&队列已满的异常&);
elementData[rear++] =
//如果rear已经到头，那就转头
rear = rear == capacity ? 0 :
//移除队列
public T remove() {
if (isEmpty()) {
throw new IndexOutOfBoundsException(&空队列异常&);
//保留队列的rear端的元素的值
T oldValue = (T) elementData[front];
//释放队列的rear端的元素
elementData[front++] =
//如果front已经到头，那就转头
front = front == capacity ? 0 :
return oldV
//返回队列顶元素，但不删除队列顶元素
public T element() {
if (isEmpty()) {
throw new IndexOutOfBoundsException(&空队列异常&);
return (T) elementData[front];
//判断循环队列是否为空队列
public boolean isEmpty() {
//rear==front且rear处的元素为null
return rear == front && elementData[rear] ==
//清空循环队列
public void clear() {
//将底层数组所有元素赋为null
Arrays.fill(elementData, null);
front = 0;
public String toString() {
if (isEmpty()) {
return &[]&;
//如果front & rear，有效元素就是front到rear之间的元素
if (front & rear) {
StringBuilder sb = new StringBuilder(&[&);
for (int i = i & i++) {
sb.append(elementData[i].toString() + &, &);
int len = sb.length();
return sb.delete(len - 2, len).append(&]&).toString();
//如果front &= rear，有效元素为front-&capacity之间、0-&front之间的
StringBuilder sb = new StringBuilder(&[&);
for (int i = i & i++) {
sb.append(elementData[i].toString() + &, &);
for (int i = 0; i & 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);
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：193724次
积分：3020
积分：3020
排名：第7145名
原创：92篇
转载：146篇
评论：35条
(1)(1)(1)(2)(1)(2)(9)(16)(19)(37)(19)(11)(1)(22)(5)(8)(1)(4)(6)(10)(1)(10)(3)(1)(4)(1)(8)(1)(2)(21)(12)有序链式队列 - 推酷
有序链式队列
编写头文件
&&&&&&&&&&&
&&&&&&&&&&
存储下一个节点的地址
&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&
优先级排队
&&&&&&&&&&&&&&&&&&&&&
打印所有数据，递归
insertEnQueue
编写实现队列的代码
&stdlib.h&
&&&&&&&&&&&
确定要插入的位置
这里是尾部插入
这里相当于是
记录要删除的地址
优先级排队
//void sort(Queue *queueHead)
if (queueHead == NULL || queueHead-&pNext == NULL)
for (Queue *p1 = queueH p1 != NULL;p1 = p1-&pNext)
for (Queue *p2 = queueH p2 != NULL;p2 = p2-&pNext)
&&&&&&&&&&&&&
if (p1-&high & p2-&high)
&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&
temp.num = p1-&
&&&&&&&&&&&&&&&&&
p1-&num = p2-&
&&&&&&&&&&&&&&&&&
p2-&num = temp.
&&&&&&&&&&&&&&&&&
temp.high = p1-&
&&&&&&&&&&&&&&&&&
p1-&high = p2-&
&&&&&&&&&&&&&&&&&
交换节点数据
&&&&&&&&&&&&&&&&&
p2-&high = temp.
&&&&&&&&&&&&&
打印所有数据，递归
&%d,%d,%p,%p\n&
insertEnQueue
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
指向这个节点
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
循环到尾部
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
避免野指针
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&
编写主函数
&stdlib.h&
创建头结点
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
, 11, 16);
insertEnQueue
, 111, 19);
打印排序后的链式队列
已发表评论数()
已收藏到推刊！
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
没有分页内容
图片无法显示
视频无法显示
与原文不一致提问回答都赚钱
报名就送100现金×
> 问题详情
下列叙述中正确的是A)循环队列是队列的一种链式存储结构B)循环队列是一种逻辑结构C)循环队列是队
悬赏：0&&答案豆&&&&提问人：匿名网友&&&&提问收益：0.00答案豆&&&&&&
下列叙述中正确的是A)循环队列是队列的一种链式存储结构B)循环队列是一种逻辑结构C)循环队列是队列的一种顺序存储结构D)循环队列是非线性结构
发布时间：&&截止时间：
网友回答&(共1条)
19:59&&提问收益：0.00&答案豆&&
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&2.00元收益
回答悬赏问题预计能赚取&91.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&4.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&91.00元收益
回答悬赏问题预计能赚取&4.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&2.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&2.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&91.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&91.00元收益
回答悬赏问题预计能赚取&4.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&4.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&91.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&51.00元收益
回答悬赏问题预计能赚取&51.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&22.00元收益
回答悬赏问题预计能赚取&22.00元收益
你可能喜欢的
[] [] [] [] [] [] [] [] [] [] [] []
请先输入下方的验证码查看最佳答案
图形验证：数据结构跳舞搭配_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
数据结构跳舞搭配
上传于||暂无简介
阅读已结束，如果下载本文需要使用0下载券
想免费下载更多文档？
下载文档到电脑，查找使用更方便
还剩12页未读，继续阅读
你可能喜欢}
数据结构（33）
双向顺序队列ArrayDeque和双向链式队列LinkedList，JDK已经包含，在此略。ArrayDeque包括顺序栈和顺序队列，LinkedList包含链式栈和链式队列。ArrayDeque和LinkedList都是线程不安全的。PriorityQueue优先队列也在JDK。
1.顺序队列的实现
import java.io.S
import java.util.A
* @ClassName: ArrayQueue
* @Description: 顺序队列
* @date 日 下午3:46:19
* @param &T&
public class ArrayQueue&T& implements Serializable{
* @Fields serialVersionUID : TODO
private static final long serialVersionUID = 9379197L;
private int DEFAULT_SIZE = 10;
//保存数组的长度
private Object[] elementD//定义一个数组用于保存顺序队列的元素
private int front = 0;//队头
private int rear = 0;//队尾
//以默认数组长度创建空顺序队列
public ArrayQueue() {
capacity = DEFAULT_SIZE;
elementData = new Object[capacity];
//以一个初始化元素来创建顺序队列
public ArrayQueue(T element) {
elementData[0] =
public ArrayQueue(int initSize) {
elementData = new Object[initSize];
* 以指定长度的数组来创建顺序队列
* @param element 指定顺序队列中第一个元素
* @param initSize 指定顺序队列底层数组的长度
public ArrayQueue(T element, int initSize) {
this.capacity = initS
elementData = new Object[capacity];
elementData[0] =
* @Title: size
* @Description: 获取顺序队列的大小
public int size() {
return rear -
* @Title: offer
* @Description: 入队
* @param element
public void offer(T element) {
ensureCapacity(rear + 1);
elementData[rear++] =
private void ensureCapacity(int minCapacity) {
//如果数组的原有长度小于目前所需的长度
int oldCapacity = elementData.
if (minCapacity & oldCapacity) {
int newCapacity = (oldCapacity * 3) / 2 + 1;
if (newCapacity & minCapacity)
newCapacity = minC
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
* @Title: poll
* @Description: 出队
public T poll() {
if (isEmpty()) {
throw new IndexOutOfBoundsException(&空队列异常&);
//保留队列的front端的元素的值
T oldValue = (T) elementData[front];
//释放队列的front端的元素
elementData[front++] =
return oldV
* @Title: peek
* @Description: 返回队列顶元素，但不删除队列顶元素
public T peek() {
if (isEmpty()) {
throw new IndexOutOfBoundsException(&空队列异常&);
return (T) elementData[front];
* @Title: isEmpty
* @Description: 判断顺序队列是否为空队列
public boolean isEmpty() {
return rear ==
* @Title: clear
* @Description: 清空顺序队列
public void clear() {
//将底层数组所有元素赋为null
Arrays.fill(elementData, null);
front = 0;
public String toString() {
if (isEmpty()) {
return &[]&;
StringBuilder sb = new StringBuilder(&[&);
for (int i = i & i++) {
sb.append(elementData[i].toString() + &, &);
int len = sb.length();
return sb.delete(len - 2, len).append(&]&).toString();
2. 链式队列的实现
import java.io.S
* @ClassName: LinkQueue
* @Description:
* @date 日 下午3:24:38
* @param &T&
public class LinkQueue&T& implements Serializable{
* @Fields serialVersionUID : TODO
private static final long serialVersionUID = -6312615L;
//定义一个内部类Node，Node实例代表链队列的节点。
private class Node {
private T//保存节点的数据
private N//指向下个节点的引用
//无参数的构造器
public Node() {
//初始化全部属性的构造器
public Node(T data, Node next) {
this.data =
this.next =
private N//保存该链队列的头节点
private N//保存该链队列的尾节点
//保存该链队列中已包含的节点数
* &p&Title: LinkQueue &/p&
* &p&Description: 创建空链队列 &/p&
public LinkQueue() {
//空链队列，front和rear都是null
* &p&Title: LinkQueue &/p&
* &p&Description: 以指定数据元素来创建链队列，该链队列只有一个元素&/p&
public LinkQueue(T element) {
front = new Node(element, null);
//只有一个节点，front、rear都指向该节点
* @Title: size
* @Description: 获取顺序队列的大小
public int size() {
* @Title: offer
* @Description: 入队
* @param element
public void offer(T element) {
//如果该链队列还是空链队列
if (front == null) {
front = new Node(element, null);
rear =//只有一个节点，front、rear都指向该节点
Node newNode = new Node(element, null);//创建新节点
rear.next = newN//让尾节点的next指向新增的节点
rear = newN//以新节点作为新的尾节点
* @Title: poll
* @Description: 出队
public T poll() {
Node oldFront =
front = front.
oldFront.next =
return oldFront.
* @Title: peek
* @Description: 返回队列顶元素，但不删除队列顶元素
public T peek() {
return rear.
* @Title: isEmpty
* @Description: 判断顺序队列是否为空队列
public boolean isEmpty() {
return size == 0;
* @Title: clear
* @Description: 清空顺序队列
public void clear() {
//将front、rear两个节点赋为null
public String toString() {
//链队列为空链队列时
if (isEmpty()) {
return &[]&;
StringBuilder sb = new StringBuilder(&[&);
for (Node current = current != 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. 循环队列的实现
import java.io.S
import java.util.A
* @ClassName: LoopQueue
* @Description: 循环队列
* @date 日 下午3:47:14
public class LoopQueue&T& implements Serializable{
* @Fields serialVersionUID : TODO
private static final long serialVersionUID = -2478781L;
private int DEFAULT_SIZE = 10;
//保存数组的长度
private Object[] elementD//定义一个数组用于保存循环队列的元素
private int front = 0;//队头
private int rear = 0;//队尾
//以默认数组长度创建空循环队列
public LoopQueue() {
capacity = DEFAULT_SIZE;
elementData = new Object[capacity];
//以一个初始化元素来创建循环队列
public LoopQueue(T element) {
elementData[0] =
* 以指定长度的数组来创建循环队列
* @param element 指定循环队列中第一个元素
* @param initSize 指定循环队列底层数组的长度
public LoopQueue(T element, int initSize) {
this.capacity = initS
elementData = new Object[capacity];
elementData[0] =
//获取循环队列的大小
public int size() {
if (isEmpty()) {
return rear & front ? rear - front : capacity - (front - rear);
//插入队列
public void add(T element) {
if (rear == front && elementData[front] != null) {
throw new IndexOutOfBoundsException(&队列已满的异常&);
elementData[rear++] =
//如果rear已经到头，那就转头
rear = rear == capacity ? 0 :
//移除队列
public T remove() {
if (isEmpty()) {
throw new IndexOutOfBoundsException(&空队列异常&);
//保留队列的rear端的元素的值
T oldValue = (T) elementData[front];
//释放队列的rear端的元素
elementData[front++] =
//如果front已经到头，那就转头
front = front == capacity ? 0 :
return oldV
//返回队列顶元素，但不删除队列顶元素
public T element() {
if (isEmpty()) {
throw new IndexOutOfBoundsException(&空队列异常&);
return (T) elementData[front];
//判断循环队列是否为空队列
public boolean isEmpty() {
//rear==front且rear处的元素为null
return rear == front && elementData[rear] ==
//清空循环队列
public void clear() {
//将底层数组所有元素赋为null
Arrays.fill(elementData, null);
front = 0;
public String toString() {
if (isEmpty()) {
return &[]&;
//如果front & rear，有效元素就是front到rear之间的元素
if (front & rear) {
StringBuilder sb = new StringBuilder(&[&);
for (int i = i & i++) {
sb.append(elementData[i].toString() + &, &);
int len = sb.length();
return sb.delete(len - 2, len).append(&]&).toString();
//如果front &= rear，有效元素为front-&capacity之间、0-&front之间的
StringBuilder sb = new StringBuilder(&[&);
for (int i = i & i++) {
sb.append(elementData[i].toString() + &, &);
for (int i = 0; i & 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);
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：193724次
积分：3020
积分：3020
排名：第7145名
原创：92篇
转载：146篇
评论：35条
(1)(1)(1)(2)(1)(2)(9)(16)(19)(37)(19)(11)(1)(22)(5)(8)(1)(4)(6)(10)(1)(10)(3)(1)(4)(1)(8)(1)(2)(21)(12)有序链式队列 - 推酷
有序链式队列
编写头文件
&&&&&&&&&&&
&&&&&&&&&&
存储下一个节点的地址
&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&
优先级排队
&&&&&&&&&&&&&&&&&&&&&
打印所有数据，递归
insertEnQueue
编写实现队列的代码
&stdlib.h&
&&&&&&&&&&&
确定要插入的位置
这里是尾部插入
这里相当于是
记录要删除的地址
优先级排队
//void sort(Queue *queueHead)
if (queueHead == NULL || queueHead-&pNext == NULL)
for (Queue *p1 = queueH p1 != NULL;p1 = p1-&pNext)
for (Queue *p2 = queueH p2 != NULL;p2 = p2-&pNext)
&&&&&&&&&&&&&
if (p1-&high & p2-&high)
&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&
temp.num = p1-&
&&&&&&&&&&&&&&&&&
p1-&num = p2-&
&&&&&&&&&&&&&&&&&
p2-&num = temp.
&&&&&&&&&&&&&&&&&
temp.high = p1-&
&&&&&&&&&&&&&&&&&
p1-&high = p2-&
&&&&&&&&&&&&&&&&&
交换节点数据
&&&&&&&&&&&&&&&&&
p2-&high = temp.
&&&&&&&&&&&&&
打印所有数据，递归
&%d,%d,%p,%p\n&
insertEnQueue
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
指向这个节点
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
循环到尾部
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
避免野指针
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&
编写主函数
&stdlib.h&
创建头结点
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
insertEnQueue
, 11, 16);
insertEnQueue
, 111, 19);
打印排序后的链式队列
已发表评论数()
已收藏到推刊！
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
没有分页内容
图片无法显示
视频无法显示
与原文不一致提问回答都赚钱
报名就送100现金×
> 问题详情
下列叙述中正确的是A)循环队列是队列的一种链式存储结构B)循环队列是一种逻辑结构C)循环队列是队
悬赏：0&&答案豆&&&&提问人：匿名网友&&&&提问收益：0.00答案豆&&&&&&
下列叙述中正确的是A)循环队列是队列的一种链式存储结构B)循环队列是一种逻辑结构C)循环队列是队列的一种顺序存储结构D)循环队列是非线性结构
发布时间：&&截止时间：
网友回答&(共1条)
19:59&&提问收益：0.00&答案豆&&
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&2.00元收益
回答悬赏问题预计能赚取&91.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&4.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&91.00元收益
回答悬赏问题预计能赚取&4.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&2.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&2.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&91.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&91.00元收益
回答悬赏问题预计能赚取&4.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&4.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&91.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&51.00元收益
回答悬赏问题预计能赚取&51.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&1.00元收益
回答悬赏问题预计能赚取&3.00元收益
回答悬赏问题预计能赚取&22.00元收益
回答悬赏问题预计能赚取&22.00元收益
你可能喜欢的
[] [] [] [] [] [] [] [] [] [] [] []
请先输入下方的验证码查看最佳答案
图形验证：数据结构跳舞搭配_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
数据结构跳舞搭配
上传于||暂无简介
阅读已结束，如果下载本文需要使用0下载券
想免费下载更多文档？
下载文档到电脑，查找使用更方便
还剩12页未读，继续阅读
你可能喜欢}
我要回帖
更多关于 队列的链式存储 的文章
更多推荐
- ·微信朋友圈选中的朋友可见新加的好友能看到之前的朋友圈吗朋友可以看见嘛？
- ·用什么软件能绘制地图软件类三国游戏的世界地图？
- ·如果代理美多集成灶专卖店开一家专卖店可以赚钱吗？
- ·服装电商在什么地方拿货经销挑选货源，如何规避著作权侵权？
- ·求助！云南经济管理学院本科专业有几个的市场营销专业值不值得学？
- ·小钩能钓大鱼吗锲套正确安装法
- ·网络的开放性问题与虚拟性导致的问题
- ·我本来是一个演员，只不过没有所属的杨紫所属经纪公司司担保。我每次申请认证都是被拒绝通过不了认证。每次告诉我的
- ·求绝命毒师第一季百度云百度云，不要广告
- ·如何解决sublime text的快捷键 3 快捷键与系统快捷键冲突的问题
- ·哪位仁兄能提供个solidworks中toolbox2012 toolbox全中文标准件库
- ·马士兰马兰士nr16066是中国生产的是吗
- ·HPT一TP3O1lol tp是什么意思电焊机
- ·中国移动套餐外最优惠的流量套餐流量有3个g是什么意思
- ·像这种 qq空间认证官方认证要怎么搞？
- ·程序打不开，点任何图标都会ie弹出窗口打不开下图，怎么解决?
- ·我qq为什么名字是用户qq号涉嫌批量注册不正当操作已关闭?
- ·跑步群的群介绍招聘怎么写吸引人，更吸引人
- ·android uiautomator怎么处理android 页面加载动画
- ·跳舞配对 销毁链式队列循环队列
- ·excel2016数据excel有效性设置怎么设置
- ·联想e40-80/i3/i3 5020uu报价
- ·小张同学用某固体学plc pdf版下载
- ·贝尔丰bfa500刷机 a500开不了机怎么刷
- ·高级excel表格中选择框怎么插入选择框
- ·红头文件红线位置最后两条红线怎样做呢
- ·jk触发器波形图和D触发器的R非端口的作用
- ·因为没QQ，所以在这qq聊天第一句话说什么，不介意吧！或可以的话给个QQ
- ·如何修改织梦网站系统默认admin管理员密码admin
- ·怎么node sass 安装失败sass
- ·茅台52度茅台集团全家福酒荣耀100
- ·全民k歌升级攻略怎样升级LV7
- ·CF win7 64位 cf调烟雾头最清楚win8的方法最好是可以看清红色烟雾的？？？？知道说下
- ·从高压线路柱式瓷绝缘子到户表依次都有那些设备?
- ·谁有亚索改fate zero讨鬼传极佐佐木小次郎郎皮肤补丁
