循环链表与循环队列

最新推荐文章于 2025-06-20 11:13:08 发布

Anstrue

最新推荐文章于 2025-06-20 11:13:08 发布

阅读量1.6w

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构与算法

本文链接：https://blog.youkuaiyun.com/beautiful_face/article/details/60762947

数据结构与算法专栏收录该内容

12 篇文章

订阅专栏

本文介绍了单向和双向循环链表的概念，强调了它们在遍历上的优势和插入删除操作的区别。接着讨论了队列的‘假溢出’现象，并提出了循环队列作为解决方案，以避免存储空间浪费。此外，还提及了优先级队列在任务调度中的应用。最后，提供了循环队列的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

单向循环链表

和普通的链表结构不同，单向循环链表的最后一个节点的指针指向了头结点，也就是和Head指针有相同的引用

和普通链表相比，循环链表不需要头指针，能够从任意位置实现链表遍历

双向循环链表

和单向链表相比，双向链表多了一个指向上一个节点的前向指针

相比于单向链表，双向循环链表的遍历更加灵活，但缺点是，进行插入和删除操作需要修改更多的指针

队列的“假溢出”

如上图所示，front和rear分别是队列的头、尾指针，在出入队列的过程中会出现一种现象：尾指针指向了对垒的尾部，也就是达到了maxSize，但这是，头指针并没有指向对头，这样就造成的存储空间的浪费，也会导致队列无法继续实现入队、出队操作。因此，提出了循环队列。

优先级队列

和普通的队列相比，优先级队列在出栈是是按照优先级进行的，也就是每次选取优先级最高的元素出列，这在计算机的任务调度中有很大的用处

    private Object element;   //数据域
    private int priority;     //用整型数字表示对雷元素的优先级

    public Element(Object element, int priority) {
        this.element = element;
        this.priority = priority;
    }

public Object delete() {
        if(isEmpty()){                //判断队列是否为空
            System.out.println("队列为空");
        }

                                     //找优先级最低的元素，默认为队头元素
        Element MIN = queue[0];
        int index = 0;
        for (int i = 0; i < count; i++) {
            if(queue[i].getPriority() < MIN.getPriority()){
                MIN = queue[i];
                index = i;
            }
        }

                                       //出队，后面的元素向前移
        for (int i = index + 1; i < count; i++) {
            queue[i -1] = queue[i];
            }
        rear--;
        count--;
        return MIN;
    }

循环队列

附上循环对垒的代码：

public class ImplQueue implements CircularQueue{

    static final  int defauleSize = 10;
    int front,rear,count,maxSize;
    Object[] queue;


    public static void main(String[] args) {
        ImplQueue circleQueue = new ImplQueue();
        circleQueue.append(10);
        circleQueue.append("d");
        circleQueue.append("sss");
        circleQueue.append(1);
        System.out.println(circleQueue.isEmpty());
        System.out.println(circleQueue.getFront());
        while (!circleQueue.isEmpty()){
            System.out.println(circleQueue.delete());
        }
    }

    //默认队列长度
    public ImplQueue() {
        rear = 0;
        front = 0;
        count = 0;
        maxSize = defauleSize;
        queue = new Object[defauleSize];
    }

    //自定义队列那长度
    public ImplQueue(int maxSize) {
        this.maxSize = maxSize;
        rear = 0;
        front = 0;
        count = 0;
        queue = new Object[maxSize];
    }

    @Override
    public void append(Object obj) {
        //判断队列是否为满
        if(front == rear && count > 0) {
            System.out.println("队列已满，无法插入");
        }else {
            queue[rear] = obj;
            rear = (rear + 1) % maxSize;
            count++;
        }
    }

    @Override
    public Object delete() {
        Object obj = null;
        //判断队列是否为空
        if(isEmpty()){
            System.out.println("队列为空，无法删除");
        }else {
            obj = queue[front];
            front = (front +1) % maxSize;
            count--;
        }
        return obj;
    }

    @Override
    public Object getFront() {
        Object obj = null;
        if(isEmpty()){
            System.out.println("队列为空");
        }else {
            obj = queue[front];
        }
        return obj;
    }

    @Override
    public boolean isEmpty() {
        return count == 0;
    }
}