数据结构（二）--队列
数据结构（二）–队列
介绍
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
**特点：**先进先出
代码实现
数组方式实现
普通队列
front代表队列队头元素的前一个位置，rear为队尾元素当前位置
初始化：front=-1，rear=-1
当队列空：front==rear
对满了：rear ==maxsize-1
queue类
public class queue {
private int maxSize;
private int front;
private int rear;
private int[] arr;
public queue(int maxSize){
this.maxSize = maxSize;
arr = new int[maxSize];
//初始化队列为空，所以为-1
//front指向队列第一个元素的前一个位置
front = -1;
//rear指向队列最后一个元素位置
rear = -1;
}
public boolean isFull(){
return rear==maxSize-1;
}
public boolean isEmpty(){
return front==rear;
}
public void addQueue(int n){
if(isFull()) System.out.println("队列满了");
else arr[++rear] = n;
}
public int outQueue(){
if (isEmpty()) throw new RuntimeException("队列为空");
else return arr[++front];
}
public void showQueue(){
if (isEmpty()) {
System.out.println("队列为空");
return;
}
for(int i = front+1;i<=rear;i++){
System.out.printf("arr[%d]=%d\t",i,arr[i]);
}
System.out.println();
}
}
主函数
public static void main(String[] args) {
queue q = new queue(6);
q.addQueue(5);
q.addQueue(8);
q.addQueue(10);
q.addQueue(7);
q.showQueue();
System.out.println("出队元素:"+q.outQueue());
System.out.println("出队元素:"+q.outQueue());
q.showQueue();
}
结果
arr[0]=5 arr[1]=8 arr[2]=10 arr[3]=7
出队元素:5
出队元素:8
arr[2]=10 arr[3]=7
环形队列
front代表队列队头元素的前一个位置，rear为队尾元素当前位置，并且约定留一个空位区分队列空和队列满的情况。
初始化：front=0，rear=0
当队列空：front==rear
对满了：(rear+1)%maxSize==front
出队和入队时，front和rear变化：rear=(++rear)%maxSize，front=(++front)%maxSize
public class Cirqueue {
private int maxSize;
private int front;
private int rear;
private int[] arr;
public Cirqueue(int maxSize){
this.maxSize = maxSize;
arr = new int[maxSize];
//初始化队列为空，所以为-1
//front指向队列第一个元素的前一个位置
front = 0;
//rear指向队列最后一个元素位置
rear = 0;
}
public boolean isFull(){
return (rear+1)%maxSize==front;
}
public boolean isEmpty(){
return front==rear;
}
public void addQueue(int n){
if(isFull()) {
System.out.println("队列满了");
return;
}
rear = (++rear)%maxSize;
arr[rear] = n;
}
public int outQueue(){
if (isEmpty()) throw new RuntimeException("队列为空");
front = (++front)%maxSize;
return arr[front];
}
public void showQueue(){
if (isEmpty()) {
System.out.println("队列为空");
return;
}
int i ;
for(i = front+1;i!=rear;i=(i+1)%maxSize){
System.out.printf("arr[%d]=%d\t",i,arr[i]);
}
System.out.printf("arr[%d]=%d\t",i,arr[i]);
System.out.println();
}
}
mian函数
public static void main(String[] args) {
Cirqueue q = new Cirqueue(6);
q.addQueue(5);
q.addQueue(8);
q.addQueue(10);
q.addQueue(7);
q.addQueue(8);
q.showQueue();
System.out.println("出队元素:"+q.outQueue());
System.out.println("出队元素:"+q.outQueue());
System.out.println("出队元素:"+q.outQueue());
q.addQueue(4);
q.addQueue(1);
q.showQueue();
}
结果
arr[1]=5 arr[2]=8 arr[3]=10 arr[4]=7 arr[5]=8
出队元素:5
出队元素:8
出队元素:10
arr[4]=7 arr[5]=8 arr[0]=4 arr[1]=1
链式实现
单向队列
先实现节点
根据需要可以将数据域data的类型改为泛型**< T >**
public class Node {
private String data;
private Node next;
public Node(){}
public Node(String data,Node next){
this.data = data;
this.next = next;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
@Override
public String toString() {
return "Node{" +
"data='" + data + '\''+"}";
}
}
单链表
头节点不存储数据，所有操作临时引用指向head；
删除/插入节点：先判断当前节点是否满足删除或插入条件，然后判断是否可以移动，最后移动（反复）
遍历节点：判断是否可以移动，移动，打印
打印某一节点：判断是否可以移动，移动，判断当前节点是否可以打印（反复）
public class Linelist {
private Node head ;
public Linelist(){
head = new Node(null,null);
}
//打印所有节点
public void printNodes(){
Node tepm = head;
while (true){
if (tepm.getNext()==null) break;
tepm = tepm.getNext();
System.out.println(tepm);
}
}
//尾部添加数据
public void addNode(String data){
Node node = new Node(data,null);
Node temp = head;
while (true){
if (temp.getNext()==null){
temp.setNext(node);
break;
}
temp = temp.getNext();
}
}
//插入数据
public void insertNode(int index,String data){
//判断越界
if (index<=0) throw new RuntimeException("越界");
Node node = new Node(data,null);
Node temp = head;
int i=0;
while (true){
//添加节点
if (i==index-1){
node.setNext(temp.getNext());
temp.setNext(node);
break;
}
//判断越界
if (temp.getNext()==null) throw new RuntimeException("越界！！！");
//移动
temp = temp.getNext();
i++;
}
}
//删除节点
public Node deleteNode(int index) {
//判断越界
if (index <=0 )
new RuntimeException("越界!!!");
Node temp = head;
int i = 0;
while (true) {
//删除节点
if (i == index - 1 && temp.getNext() != null) {
Node temp2 = temp.getNext();
temp.setNext(temp2.getNext());
temp2.setNext(null);
return temp2;
}
//判断越界
if (temp.getNext()==null)
throw new RuntimeException("越界!!!");
//移动
temp = temp.getNext();
i++;
}
}
//打印某一节点
public void printNode(int index){
//判断越界
if (index<=0) new RuntimeException("越界!!!");
Node temp = head;
int i=0;
while (true){
//判断越界
if (temp.getNext()==null) {
new RuntimeException("越界!!!");
}
//移动
i++;
temp = temp.getNext();
//打印
if (i==index){
System.out.println(temp);
break;
}
}
}
}
单链队列
public class Linequeue {
private Linelist linelist ;
public Linequeue(){
linelist =new Linelist();
}
public void addQueue(String data){
linelist.addNode(data);
}
public String outQueue(){
Node node = linelist.deleteNode(1);
return node.getData();
}
public void printQueue(){
linelist.printNodes();
}
public static void main(String[] args) {
Linequeue q = new Linequeue();
q.addQueue("第一人");
q.addQueue("第二人");
q.addQueue("第三人");
q.printQueue();
System.out.println("--------------------");
q.outQueue();
q.addQueue("第四人");
q.addQueue("第五人");
q.printQueue();
}
}
结果
Node{data='第一人'}
Node{data='第二人'}
Node{data='第三人'}
--------------------
Node{data='第二人'}
Node{data='第三人'}
Node{data='第四人'}
Node{data='第五人'}
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）