『数据结构与算法』—— 队列

定义

有一定的业务需求就会有对应的技术或数据结构产生。我们都知道 CPU 的资源是有限的,任务的处理速度与线程个数并不是线性正相关。相反过多的线程反而会导致 CPU 频繁切换,处理性能下降。所以线程池的大小一般都是综合考虑处理任务的特点和硬件环境,来事先设置的。

队列的特点 先进先出,可以想象成排队买票,先来的先买。最基本的操作就是 入队和出队,所以队列跟栈一样,也是一种 操作受限的线性数据结构

实现

类似栈,可以通过数组和链表试下,数组实现的队列叫做 顺序队列,链表实现的队列叫做 链式队列

顺序队列

核心思想在于,使用两个下标保存头部和尾部的数据,也可以当成标识。因为入队是从屁股进行插入,出队是从头部拿出数据,因此要记住头尾的位置。

先来看一下简单的实现方式:

class ArrayQueue {
    T[] items;
    int head;
    int tail;
    int count;

    ArrayQueue(int capacity) {
        items = (T[]) new Object[capacity];
        count = capacity;
    }

    boolean enqueue(T t) {
        if (tail == count) return false;
        items[tail] = t;
        tail ++;
        print("enqueue");
        return true;
    }

    T dequeue() {
        if (head == tail) return null;
        T t= items[head];
        items[head] = null;
        head ++;
        print("dequeue");
        return t;
    }

    void print(String mode) {
        System.out.println("mode:\t" + mode + " head:\t" + head + " tail:\t" + tail);
        for (int i = head; i < tail; i++) {
            System.out.print(items[i] + "");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(6);
        queue.enqueue("1");
        queue.enqueue("2");
        queue.enqueue("3");
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.enqueue("5");
        queue.enqueue("6");
    }
}

运行结果:

mode:   enqueue head:   0 tail: 1
1
mode:   enqueue head:   0 tail: 2
12
mode:   enqueue head:   0 tail: 3
123
mode:   dequeue head:   1 tail: 3
23
mode:   dequeue head:   2 tail: 3
3
mode:   dequeue head:   3 tail: 3

mode:   enqueue head:   3 tail: 4
5
mode:   enqueue head:   3 tail: 5
56

上述实现的方式有一个弊端,当 tail == n 的时候,就不能继续插入数据,但是此时容器并没有装满,只是不能继续往后插入数据了。那这个时候就需要对容器进行改变:数据搬移。单并不是每次入队都需要迁移,为了优化时间复杂度,可以在每次尾节点到达终点时,再开始数据搬移,即数据往前移动 head 的位置。

来看一下实现方式:

class DynamicArrayQueue {
    T[] items;
    int head;
    int tail;
    int count;

    DynamicArrayQueue(int capacity) {
        items = (T[]) new Object[capacity];
        count = capacity;
    }

    boolean enqueue(T t) {
        if (tail == count) {
            if (head == 0) return false;
            for (int i = head; i < tail; i++) {
                items[i - head] = items[i];
            }
            tail -= head;
            head = 0;
        }
        items[tail] = t;
        tail ++;
        print("enqueue");
        return true;
    }

    T dequeue() {
        if (head == tail) return null;
        T t = items[head];
        items[head] = null;
        head ++;
        print("new dequeue");
        return t;
    }

    void print(String mode) {
        System.out.println("mode:\t" + mode + " head:\t" + head + " tail:\t" + tail);
        for (int i = head; i < tail; i++) {
            System.out.print(items[i] + "");
        }
        System.out.println();
        System.out.println(Arrays.toString(items));
    }

    public static void main(String[] args) {
        DynamicArrayQueue queue = new DynamicArrayQueue(4);
        queue.enqueue("1");
        queue.enqueue("2");
        queue.enqueue("3");
        queue.enqueue("4");
        queue.dequeue();
        queue.dequeue();
        queue.enqueue("5");
        queue.enqueue("6");
    }
}

结果:

mode:   enqueue head:   0 tail: 1
1
[1, null, null, null]
mode:   enqueue head:   0 tail: 2
12
[1, 2, null, null]
mode:   enqueue head:   0 tail: 3
123
[1, 2, 3, null]
mode:   enqueue head:   0 tail: 4
1234
[1, 2, 3, 4]
mode:   new dequeue head:   1 tail: 4
234
[null, 2, 3, 4]
mode:   new dequeue head:   2 tail: 4
34
[null, null, 3, 4]
mode:   enqueue head:   0 tail: 3
345
[3, 4, 5, 4]
mode:   enqueue head:   0 tail: 4
3456
[3, 4, 5, 6]
mode:   new dequeue head:   1 tail: 4
456
[null, 4, 5, 6]
mode:   enqueue head:   0 tail: 4
4567
[4, 5, 6, 7]

想比较之前的实现,出队的逻辑并没有任何的改变,在入队是,需要判断 tail == 0,如果达到这个条件则可能需要进行数据搬移。

链式队列

思路其实类似于顺序队列的实现逻辑。

class LinkedQueue {
    Node head = null;
    Node tail = null;

    void enqueue(T t) {
        if (tail == null) {
            Node node = new Node(t, null);
            head = node;
            tail = node;
        } else {
            tail.next = new Node(t, null);
            tail = tail.next;
        }
        System.out.println(head.toString());
    }

    T dequeue() {
        if (head == null) return null;
        T t = head.value;
        head = head.next;
        if (head == null) {
            tail = null;
        }
        System.out.println(head == null ? "null" : head.toString());
        return t;
    }

    public static void main(String[] args) {
        LinkedQueue queue = new LinkedQueue();
        queue.enqueue("1");
        queue.enqueue("2");
        queue.enqueue("3");
        queue.dequeue();
        queue.dequeue();
        queue.enqueue("6");
    }
}

运行结果:

1 
1 2 
1 2 3 
2 3 
3 
3 6 

需要注意的是:

  1. 入队的时候,需要考虑队列无数据的情况
  2. 出队的时候,需要考虑出队到最后尾节点的处理

循环队列

之前在用数组实现队列时,在 tail == n 时会有数据搬移的操作,这样入队操作性能就会收到影响,我们可以使用循环队列来解决这个问题。

循环队列其实长得像一个环,现在需要将首尾相连变成一个环。

放三张图感受一下,图片来自于极客时间的课程。

image
image
image

从图中可以发现规律,当 (tail + 1) % n = head 时,说明队列已满。

来看一下代码的具体实现方式:

class CircularQueue {
    // 数组:items,数组大小:n
    private String[] items;
    private int n = 0;
    // head表示队头下标,tail表示队尾下标
    private int head = 0;
    private int tail = 0;

    // 申请一个大小为capacity的数组
    public CircularQueue(int capacity) {
        items = new String[capacity + 1];
        n = capacity + 1;
    }

    // 入队
    public boolean enqueue(String item) {
        // 队列满了
        if ((tail + 1) % n == head) return false;
        items[tail] = item;
        tail = (tail + 1) % n;
        return true;
    }

    // 出队
    public String dequeue() {
        // 如果head == tail 表示队列为空
        if (head == tail) return null;
        String ret = items[head];
        head = (head + 1) % n;
        return ret;
    }

    public void printAll() {
        if (0 == n) return;
        for (int i = head; i % n != tail; ++i) {
            System.out.print(items[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        CircularQueue queue = new CircularQueue(5);
        queue.enqueue("1");
        queue.enqueue("2");
        queue.enqueue("3");
        queue.enqueue("4");
        queue.printAll();
        queue.dequeue();
        queue.printAll();
        queue.enqueue("5");
        queue.enqueue("6");
        queue.printAll();
    }
}

运行结果:

1 2 3 4 
2 3 4 
2 3 4 5 6 

参考自极客时间

你可能感兴趣的:(『数据结构与算法』—— 队列)