数据结构和算法--队列

最新推荐文章于 2024-11-14 13:49:39 发布

zwz0451

最新推荐文章于 2024-11-14 13:49:39 发布

阅读量38

点赞数

文章标签：链表数据结构

本文链接：https://blog.csdn.net/zwz0451/article/details/130314533

版权

文章介绍了两种常见的队列实现方式：链表式队列和数组式（环形）队列。链表队列通过双向链表实现先进先出（FIFO）原则，而数组式队列利用环形数组来高效地进行添加和删除操作。文章提供了详细的Java代码示例，包括插入、删除、遍历等基本操作，并讨论了数组队列在容量为2^n时的优化处理。

摘要由CSDN通过智能技术生成

1.链表式队列

先进先出，后进后出

只能操作收尾项

    E value;
    ListQueue<E> next;

    public ListQueue(E value,ListQueue<E> next){
        this.value = value;
        this.next = next;
    }

    /**
    * 增加一个哨兵
    **/
    ListQueue<E> head = new ListQueue(null,null);
    ListQueue<E> tail  = head;

    /**
    * 新增一个链表
    **/
    ListQueue<E> add = new ListQueue<>(value,null);
        tail.next = add;
        tail = add;
    
    /**
    * 获取一个链表，返回并删除
    **/
    E value = head.next.value;
    head.next = head.next.next;
    return value

2.数组式队列（环形数组队列）

根据下标寻找，时间复杂度低（不受数据量大小影响）

/**
* 初始化
**/    
    E[] array = (E[]) new Object[5];
    int head = 0;//头
    int tail = 0;//尾

/**
* 添加一个队列
**/
array[tail] = value;
        tail++;

/**
* 返回一个队列，并删除
**/
 E e = array[head];
        head++;

/**
* 轮询
**/
for(int i = head;i<tail;i++){
            System.out.print(array[i]);
        }

// 满判断
(tail + 1)%array.length == head
//空判断
tail == head

完整代码


import java.util.Iterator;

public class ListRoundQueueImpl02<E> implements ListNodeQueue<E>{

    /**
     * 初始化数组，也可以使用构造方法初始化
     */
    @SuppressWarnings("all")
    E[] array = (E[]) new Object[5];
    int head = 0;//头
    int tail = 0;//尾
    //当前指针位置计算
    //head % array.length
    //tail % array.length
     /**
     * 如果数组长度为2^n
     * 当前指针位置也可以写为 tail & array.length - 1 
     * 计算逻辑为2进制数位移动
     */

        //判断是否是2^n
        int capacity = 16;
        if((capacity & capacity-1) != 0){
            return false;
        }

    /**
     * 插入新队列
     * @param value
     * @return
     */
    @Override
    public Boolean offer(E value) {
        if (isFull()){
            return false;
        }
        int index = tail % array.length;
        array[index] = value;
        tail++;
        return true;
    }

    /**
     * 获取第一个队列，并移除
     * @return
     */
    @Override
    public E pull() {
        if(isEmpty()){
            return null;
        }
        int index = head % array.length;
        E e = array[index];
        head++;
        return e;
    }

    /**
     * 获取第一个队列，不移除
     * @return
     */
    @Override
    public E peek() {
        int index = head % array.length;
        E e = array[index];
        return e;
    }

    /**
     * 判单是否空
     * @return
     */
    @Override
    public Boolean isEmpty() {
        return head == tail;
    }


    /**
     * 判单是否满
     * @return
     */
    @Override
    public Boolean isFull() {
        return tail - head == array.length;
    }

    /**
     * for轮询
     */
    @Override
    public void getTails() {
        for(int i = head;i<tail;i++){
            System.out.print(array[i]);
        }
    }


    /**
     * 迭代器轮询
     * @return
     */
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            @Override
            public boolean hasNext() {
                return p != tail;
            }

            @Override
            public E next() {
                int index = p % array.length;
                E e = array[index];
                p++;
                return e;
            }
        };
    }
}