五种编程语言解释数据结构与算法—队列

五种编程语言解释数据结构与算法—队列

1、队列的基本概念

1.1、队列的逻辑结构和特点

1.2、队列的基本操作

2、队列的顺序存储结构

2.1、逻辑结构示意图

2.2、队列的判空条件

2.3、队列的求队长的操作

3、循环队列介绍

3.1、逻辑结构示意图

3.2、如何解决循环队列队空队满条件的判断冲突

3.2.1、方案一：牺牲一个存储单元

3.2.2、方案二：增加一个变量代表元素的个数

3.2.3、方案三：增加一个tag标识

3.3、循环队列的基本操作

3.3.1、初始化操作

3.3.2、判空操作

3.3.3、入队操作

3.3.4、出队操作

4、队列的链式存储结构

4.1、逻辑结构示意图

4.2、初始化操作

4.3、判空操作

4.4、入队操作

4.5、出队操作

5、双端队列

5.1、逻辑示意图

5.2、输出受限的双端队列

5.3、输入受限的双端队列

接下来，使用编程语言来实现顺序存储的队列结构

6、C语言实现

6.1、SeqQueue.h文件中的内容

#ifndef XGP_STUDY_DEMO53_SEQQUEUE_H
#define XGP_STUDY_DEMO53_SEQQUEUE_H

#include 
#include 

#define MAX_SIZE 1024

//顺序队列结构体
typedef struct SEQQUEUE {
    void* data[MAX_SIZE];
    int size;
}SeqQueue;

//初始化
SeqQueue* Init_SeqQueue();
//入队
void Push_SeqQueue(SeqQueue* queue,void* data);
//放回队头元素
void* Front_SeqQueue(SeqQueue* queue);
//出队
void* Pop_SeqQueue(SeqQueue* queue);
//放回队尾的元素
void* Back_SeqQueue(SeqQueue* queue);
//放回大小
int Size_SeqQueue(SeqQueue* queue);
//清空队列
void Clear_SeqQueue(SeqQueue* queue);
//销毁
void FreeSpace_SeqQueue(SeqQueue* queue);

#endif //XGP_STUDY_DEMO53_SEQQUEUE_H

6.2、SeqQueue.c文件中的内容

#include "SeqQueue.h"

//初始化
SeqQueue* Init_SeqQueue() {

    SeqQueue* queue = (SeqQueue*)malloc(sizeof(SeqQueue));

    for(int i = 0;i < MAX_SIZE;i++) {
        queue->data[i] = NULL;
    }
    queue->size = 0;
    return queue;
}
//入队
void Push_SeqQueue(SeqQueue* queue,void* data) {
    //数组的左边当作队头
    if(queue == NULL || data == NULL || queue->size == MAX_SIZE) return;

    queue->data[queue->size] = data;
    queue->size++;
}
//放回队头元素
void* Front_SeqQueue(SeqQueue* queue) {
    if(queue == NULL || queue->size == 0) return NULL;
    return queue->data[0];
}
//出队
void* Pop_SeqQueue(SeqQueue* queue) {
    if(queue == NULL || queue->size == 0) return NULL;
    //需要移动元素
    void* save = queue->data[0];
    for(int i = 0;i < queue->size - 1;i++) {
        queue->data[i] = queue->data[i+1];
    }
    queue->size--;
    return save;
}
//放回队尾的元素
void* Back_SeqQueue(SeqQueue* queue) {
    if(queue == NULL || queue->size == 0) return NULL;
    return queue->data[queue->size - 1];
}
//放回大小
int Size_SeqQueue(SeqQueue* queue) {
    if(queue == NULL) return -1;
    return queue->size;
}
//清空队列
void Clear_SeqQueue(SeqQueue* queue) {
    if(queue == NULL) return;
    queue->size = 0;
}
//销毁
void FreeSpace_SeqQueue(SeqQueue* queue) {
    if(queue == NULL) return;
    free(queue);
}

6.3、main.c文件中的内容

#include "SeqQueue.h"
#include 

typedef struct PERSON {
    char name[64];
    int age;
}Person;

int main() {
    //创建队列
    SeqQueue* queue = Init_SeqQueue();
    //创建数据
    Person p1,p2,p3,p4,p5;
    strcpy(p1.name,"aaa");
    strcpy(p2.name,"bbb");
    strcpy(p3.name,"ccc");
    strcpy(p4.name,"ddd");
    strcpy(p5.name,"eee");

    p1.age = 18;
    p2.age = 19;
    p3.age = 20;
    p4.age = 21;
    p5.age = 22;

    Push_SeqQueue(queue,&p1);
    Push_SeqQueue(queue,&p2);
    Push_SeqQueue(queue,&p3);
    Push_SeqQueue(queue,&p4);
    Push_SeqQueue(queue,&p5);

    //输出队尾元素
    Person* backP = (Person*)Back_SeqQueue(queue);
    printf("Name:%s\tAge:%d\n",backP->name,backP->age);
    printf("============================================\n");

    while (Size_SeqQueue(queue) > 0) {
        //取出队头元素
        Person* p = (Person*)Pop_SeqQueue(queue);;
        printf("Name:%s\tAge:%d\n",p->name,p->age);
    }

    //销毁
    FreeSpace_SeqQueue(queue);

    return 0;
}

6.4、输出结果

Name:eee        Age:22
============================================
Name:aaa        Age:18
Name:bbb        Age:19
Name:ccc        Age:20
Name:ddd        Age:21
Name:eee        Age:22

Process finished with exit code 0

7、C++语言实现

7.1、SeqQueue.h文件中的内容

#ifndef XGP_STUDY_DEMO54_SEQQUEUE_H
#define XGP_STUDY_DEMO54_SEQQUEUE_H

#include 
using namespace std;

#define MAX_SIZE 1024

template 
class SeqQueue {
private:
    T* data[MAX_SIZE];
    int size;

public:
    SeqQueue();
    //入队
    void Push_SeqQueue(T* data);
//放回队头元素
    T* Front_SeqQueue();
//出队
    T* Pop_SeqQueue();
//放回队尾的元素
    T* Back_SeqQueue();
//放回大小
    int Size_SeqQueue();
//清空队列
    void Clear_SeqQueue();
    ~SeqQueue();
};


#endif //XGP_STUDY_DEMO54_SEQQUEUE_H

7.2、SeqQueue.cpp文件中的内容

#include "SeqQueue.h"

template
SeqQueue::SeqQueue() {
    for(int i = 0;i < MAX_SIZE;i++) {
        this->data[i] = NULL;
    }
    this->size = 0;
}

template
void SeqQueue::Push_SeqQueue(T *data) {
    //数组的左边当作队头
    if(data == NULL || this->size == MAX_SIZE) return;

    this->data[this->size] = data;
    this->size++;
}

template
T *SeqQueue::Front_SeqQueue() {
    if(this->size == 0) return NULL;
    return this->data[0];
}

template
T *SeqQueue::Pop_SeqQueue() {
    if(this->size == 0) return NULL;
    //需要移动元素
    T* save = this->data[0];
    for(int i = 0;i < this->size - 1;i++) {
        this->data[i] = this->data[i+1];
    }
    this->size--;
    return save;
}

template
T *SeqQueue::Back_SeqQueue() {
    if(this->size == 0) return NULL;
    return this->data[this->size - 1];
}

template
int SeqQueue::Size_SeqQueue() {
    return this->size;
}

template
void SeqQueue::Clear_SeqQueue() {
    this->size = 0;
}

template
SeqQueue::~SeqQueue() {
    cout<<"销毁方法已启动"<

7.3、main.cpp文件中的内容

#include "SeqQueue.cpp"

class Person {
public:
    string name;
    int age;

    Person(const string &name, int age) : name(name), age(age) {}

    friend ostream &operator<<(ostream &os, const Person &person) {
        os << "name: " << person.name << " age: " << person.age;
        return os;
    }
};

int main() {
    //创建队列
    SeqQueue* queue = new SeqQueue();
    //创建数据
    Person p1("aaa",18);
    Person p2("bbb",19);
    Person p3("ccc",20);
    Person p4("ddd",21);
    Person p5("eee",22);

    queue->Push_SeqQueue(&p1);
    queue->Push_SeqQueue(&p2);
    queue->Push_SeqQueue(&p3);
    queue->Push_SeqQueue(&p4);
    queue->Push_SeqQueue(&p5);


    //输出队尾元素
    Person* backP = queue->Back_SeqQueue();
    cout<<*backP<Size_SeqQueue() > 0) {
        //取出队头元素
        Person* p = queue->Pop_SeqQueue();;
        cout<<*p<

7.4、输出结果

name: eee age: 22
========================
name: aaa age: 18
name: bbb age: 19
name: ccc age: 20
name: ddd age: 21
name: eee age: 22
销毁方法已启动

Process finished with exit code 0

8、Java语言实现

8.1、SeqQueue.java文件中的内容

package com.xgp.队列;

public interface SeqQueue {
    //入队
    void Push_SeqQueue(T data);
    //放回队头元素
    T Front_SeqQueue();
    //出队
    T Pop_SeqQueue();
    //放回队尾的元素
    T Back_SeqQueue();
    //放回大小
    int Size_SeqQueue();
    //清空队列
    void Clear_SeqQueue();
    //销毁
    void FreeSpace_SeqQueue();
}

8.2、SeqQueueImpl.java文件中的内容

package com.xgp.队列;

public class SeqQueueImpl implements SeqQueue {

    private int MAX_SIZE = 1024;

    private Object[] data = new Object[MAX_SIZE];
    private int size;

    public SeqQueueImpl() {
        for(int i = 0;i < MAX_SIZE;i++) {
            this.data[i] = null;
        }
        this.size = 0;
    }

    public SeqQueueImpl(int MAX_SIZE) {
        this.MAX_SIZE = MAX_SIZE;
        for(int i = 0;i < MAX_SIZE;i++) {
            this.data[i] = null;
        }
        this.size = 0;
    }

    @Override
    public void Push_SeqQueue(T data) {
        //数组的左边当作队头
        if(data == null || this.size == MAX_SIZE) return;

        this.data[this.size] = data;
        this.size++;
    }

    @Override
    public T Front_SeqQueue() {
        if(this.size == 0) return null;
        return (T)this.data[0];
    }

    @Override
    public T Pop_SeqQueue() {
        if(this.size == 0) return null;
        //需要移动元素
        T save = (T)this.data[0];
        for(int i = 0;i < this.size - 1;i++) {
            this.data[i] = this.data[i+1];
        }
        this.size--;
        return save;
    }

    @Override
    public T Back_SeqQueue() {
        if(this.size == 0) return null;
        return (T)this.data[this.size - 1];
    }

    @Override
    public int Size_SeqQueue() {
        return this.size;
    }

    @Override
    public void Clear_SeqQueue() {
        this.size = 0;
    }

    @Override
    public void FreeSpace_SeqQueue() {
        Clear_SeqQueue();
        System.gc();
        System.out.println("对象已被销毁");
    }
}

8.3、Main.java文件中的内容

package com.xgp.队列;

public class Main {
    public static void main(String[] args) {
        //创建队列
        SeqQueue queue = new SeqQueueImpl<>();
        //创建数据
        Person p1 = new Person("aaa",18);
        Person p2 = new Person("bbb",19);
        Person p3 = new Person("ccc",20);
        Person p4 = new Person("ddd",21);
        Person p5 = new Person("eee",22);

        queue.Push_SeqQueue(p1);
        queue.Push_SeqQueue(p2);
        queue.Push_SeqQueue(p3);
        queue.Push_SeqQueue(p4);
        queue.Push_SeqQueue(p5);


        //输出队尾元素
        Person backP = queue.Back_SeqQueue();
        System.out.println(backP);
        System.out.println("===================================");

        while (queue.Size_SeqQueue() > 0) {
            //取出队头元素
            Person p = queue.Pop_SeqQueue();;
            System.out.println(p);
        }

        queue.FreeSpace_SeqQueue();
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

8.4、输出结果

Person{name='eee', age=22}
===================================
Person{name='aaa', age=18}
Person{name='bbb', age=19}
Person{name='ccc', age=20}
Person{name='ddd', age=21}
Person{name='eee', age=22}
对象已被销毁

进程完成，退出码 0

9、JavaScript语言实现

9.1、SeqQueue.js文件中的内容

class SeqQueue {
    constructor() {
        this.MAX_SIZE = 1024;
        this.data = [];
        for(var i = 0;i < this.MAX_SIZE;i++) {
            this.data[i] = null;
        }
        this.size = 0;
    }
    
    Push_SeqQueue(data) {
        //数组的左边当作队头
        if(data == null || this.size == this.MAX_SIZE) return;

        this.data[this.size] = data;
        this.size++;
    }

    Front_SeqQueue() {
        if(this.size == 0) return null;
        return this.data[0];
    }

    Pop_SeqQueue() {
        if(this.size == 0) return null;
        //需要移动元素
        var save = this.data[0];
        for(var i = 0;i < this.size - 1;i++) {
            this.data[i] = this.data[i+1];
        }
        this.size--;
        return save;
    }

    Back_SeqQueue() {
        if(this.size == 0) return null;
        return this.data[this.size - 1];
    }

    Size_SeqQueue() {
        return this.size;
    }

     Clear_SeqQueue() {
        this.size = 0;
    }

    FreeSpace_SeqQueue() {
        this.Clear_SeqQueue();
        console.log("对象已被销毁");
    }
}

9.2、SeqQueue.html文件中的内容

9.3、输出结果

Name:eee	Age:22 SeqQueue.html:18:25
=================================== SeqQueue.html:41:17
Name:aaa	Age:18 SeqQueue.html:18:25
Name:bbb	Age:19 SeqQueue.html:18:25
Name:ccc	Age:20 SeqQueue.html:18:25
Name:ddd	Age:21 SeqQueue.html:18:25
Name:eee	Age:22 SeqQueue.html:18:25
对象已被销毁 SeqQueue.js:50:17

10、Python语言实现

10.1、SeqQueue.py文件中的内容

class SeqQueue:
    def __init__(self) -> None:
        self.MAX_SIZE = 1024
        self.data = [None]*self.MAX_SIZE
        for i in range(0,self.MAX_SIZE):
            self.data[i] = None
        self.size = 0

    def Push_SeqQueue(self,data):
        if(data == None or self.size == self.MAX_SIZE):
            return
        self.data[self.size] = data
        self.size += 1

    def Front_SeqQueue(self):
        if(self.size == 0):
            return None
        return self.data[0]

    def Pop_SeqQueue(self):
        if(self.size == 0):
            return None
        save = self.data[0]
        for i in range(0,self.size):
            self.data[i] = self.data[i+1]
        self.size -= 1
        return save

    def Back_SeqQueue(self):
        if(self.size == 0):
            return None
        return self.data[self.size - 1]

    def Size_SeqQueue(self):
        return self.size

    def Clear_SeqQueue(self):
        self.size = 0

    def FreeSpace_SeqQueue(self):
        self.Clear_SeqQueue()
        print("对象已被销毁")

10.2、main.py文件中的内容

from SeqQueue import *

class Person:

    def __init__(self,name,age) -> None:
        self.name = name
        self.age = age

    def __str__(self) -> str:
        return "Name:" + self.name + "\t" + "Age:" + str(self.age)

queue = SeqQueue()

p1 = Person("aaa", 18)
p2 = Person("bbb", 19)
p3 = Person("ccc", 20)
p4 = Person("ddd", 21)
p5 = Person("eee", 22)

queue.Push_SeqQueue(p1)
queue.Push_SeqQueue(p2)
queue.Push_SeqQueue(p3)
queue.Push_SeqQueue(p4)
queue.Push_SeqQueue(p5)

backP = queue.Back_SeqQueue()
print(backP)
print("======================")

while(queue.Size_SeqQueue() > 0):
    print(queue.Pop_SeqQueue())

queue.FreeSpace_SeqQueue()

10.3、输出结果

Name:eee	Age:22
======================
Name:aaa	Age:18
Name:bbb	Age:19
Name:ccc	Age:20
Name:ddd	Age:21
Name:eee	Age:22
对象已被销毁

Process finished with exit code 0