数据结构与算法——4、队列的实现_arrayque

一、队列的定义

1、定义

  队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

  • 我们把允许删除的一端称为队首（front），插入的一端称为队尾（rear）
  • 不含任何数据元素的队列称为空队列
  • 队列是一种先进先出（First In Last Out）的线性表，简称FIFO
  • 队列本身是一个线性表，其数据元素具有线性关系，只不过它是一种特殊的 线性表而已
  • 队列的插入操作，叫作入队
    队列的删除操作，叫作出队
1
2
3
4
5
6

2、图文演示

---

二、Queue队列接口的定义

  同样队列可以顺序存储实现也可以链表存储实现，所以将共性抽取定义出Queue接口。

package p1.接口;
/**
 * @Auther: wjw
 * @Date: 2022/1/14-01-14-17:42
 * @Description: p2.线性结构
 * @version: 1.0
 */
public interface Queue<E> extends Iterable<E> {
    public void offer(E element);

    public E poll();

    public boolean isEmpty();

    public void clear();

    public int size();

    public E peek();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

---

三、ArrayQueue类

1.定义

  该类为队列的顺序存储具体实现
  因为队列本身就是一种特殊的线性表
  所以我们可以借用之前完成ArrayList来实现我们的ArrayQueue

2.代码演示

package p3.实例应用;
import p1.接口.Queue;
import p2.线性结构.ArrayList;

import java.util.Iterator;
/**
 * @Auther: wjw
 * @Date: 2022/1/14-01-14-18:40
 * @Description: p3.实例应用
 * @version: 1.0
 */
public class ArrayQueue<E> implements Queue<E> {
    private ArrayList<E> list;

    public ArrayQueue() {
        list = new ArrayList<>();
    }

    @Override
    public void offer(E element) {
        list.add(list.size(), element);
    }

    @Override
    public E poll() {
        return list.remove(0);
    }

    @Override
    public E peek() {
        return list.get(0);
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public void clear() {
        list.clear();
    }

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

    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }

    @Override
    public String toString() {
        return list.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (this == o) {
            return true;
        }
        if (o instanceof ArrayQueue) {
            ArrayQueue other = (ArrayQueue) o;
            return list.equals(other.list);
        }
        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

test

package p2.线性结构;

import p3.实例应用.ArrayQueue;

public class TestArrayQueue {
    public static void main(String[] args) {
        ArrayQueue<Integer> queue = new ArrayQueue<>();
        for (int i = 1; i <= 10; i++) {
            queue.offer(i);
        }
        System.out.println(queue);
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16