数据结构&算法模块总结
- (1)复杂度分析原理与方法
- (2)数组与链表原理和使用场景讲解
- (3)栈原理与应用场景讲解
- (4)队列原理与应用场景讲解
- (5)递归原理与虚拟机栈场景应用
- (6)二分查找及其应用场景
- (7) Redis有序集合跳表实现原理
- (8) 散列表(Hash Table)原理和业界应用场景
1.链式队列和数组队列
(1)数组队列
队列与栈的最大特点就是:队列有队头和队尾指针(下标),而栈只有顶端指针(下标)。
一句话总结两者特点:“队列吃多了会拉(头进尾出),而栈吃多了会吐 (头进头出)”
public class ArrayQueue {
private String[] items; // 数组
private int n = 0; // 数组大小
// ★★head表示队头下标,tail表示队尾下标。栈只有一个顶部下标!
private int head = 0;
private int tail = 0;
// 申请一个大小为capacity的数组
public ArrayQueue(int capacity) {
items = new String[capacity];
n = capacity;
}
// 入队
public boolean enqueue(String item) {
// 如果tail == n 表示队列已经满了
// ★如果一直入队再一直出队,会造成“假满队”现象!
if (tail == n) return false;
items[tail] = item;
++tail; //★入队尾部后移
return true;
}
// 出队
public String dequeue() {
// 如果head == tail 表示队列为空
// ★这里也会有假满队问题
if (head == tail) return null;
String ret = items[head];
++head; //★出队头部后移
return ret;
}
}
【入队和出队优化】
"假满队"问题:入队与出队操作,head和tail都会持续往后移动。当tail移动到最右边,即使数组中还有空闲空间,也无法继续往队列中添加数据。
解决办法:
-
出队:不搬移数据
-
入队:集中触发一次数据搬移操作
// 入队操作,将item放入队尾
public boolean enqueue(String item) {
// tail == n表示队列末尾没有空间了
if (tail == n) {
// tail ==n && head==0,表示整个队列都占满了
if (head == 0) return false;
// ★数据搬移
for (int i = head; i < tail; ++i) {
items[i-head] = items[i];
}
// 搬移完之后重新更新head和tail
tail -= head;
head = 0;
}
items[tail] = item;
++tail;
return true;
}
(2)链表队列
实现原理和栈类似,只不过头尾指针需要控制
public class LinkedQueue {
//定义一个节点类
private class Node{
String value;
Node next;
}
//记录队列元素个数
private int size = 0;
//head指向队头结点,tail指向队尾节点
private Node head;
private Node tail;
//申请一个队列
public LinkedQueue(){}
//入队
public boolean enqueue(String item){
Node newNode = new Node();
newNode.value = item;
if (size == 0) head = newNode;
else tail.next = newNode;
tail = newNode;
size++;
return true;
}
//出队
public String dequeue(){
String res = null;
if(size == 0) return res;
if(size == 1) tail = null;
res = head.value;
head = head.next;
size--;
return res;
}
}
2.循环队列
循环队列,顾名思义,它⻓得像⼀个环。原本数组是有头有尾的,是⼀条直线。现在我们把⾸尾相连,扳成了⼀个环。
我们可以看到,图中这个队列的⼤⼩为8,当前head=4,tail=7。当有⼀个新的元素a⼊队时,我们放⼊下标为7的位置。但这个时候,我们并不把tail更新为8,⽽是将其在环中后移⼀位,到下标为0的位置。当再有⼀个元素b⼊队时,我们将b放⼊下标为0的位置,然后tail加1更新为1。所以,在a,b依次⼊队之后,循环队列中的元素就变成了下⾯的样⼦:
通过这样的⽅法,我们成功避免了数据搬移操作。看起来不难理解,但是循环队列的代码实现难度要⽐前⾯讲的⾮循环队列难多了。要想写出没有bug的循环队列的实现代码,我个⼈觉得,最关键的是,确定好队空和队满的判定条件。
在⽤数组实现的⾮循环队列中,队满的判断条件是tail == n,队空条件是head == tail。那针对循环队列,如何判断队空和队满呢?
队列为空的判断条件仍然是head == tail。但队列满的判断条件就稍微有点复杂了。我画了⼀张队列满的图,你可以看⼀下,试着总结⼀下规律。
就像我图中画的队满的情况,tail=3,head=4,n=8,所以总结⼀下规律就是:(3+1)%8=4。多画⼏张队满的图,你就会发现,当队满时,(tail+1)%n=head。
你有没有发现,当队列满时,图中的tail指向的位置实际上是没有存储数据的。所以,循环队列会浪费⼀个数组的存储空间。
Talk is cheap,如果还是没怎么理解,那就show you code吧。
public 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];
n = capacity;
}
// 入队
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;
}
}
3.队列应用介绍
(1) 阻塞队列 (入队、出队阻塞)
-
队列空时: 从队头取数据会被阻塞,直到队列中有了数据才能返回;
-
队列满时: 在队尾 插入数据会被阻塞,直到队列中有空闲位置后再插入数据,然后再返回。
②阻塞原型本质是生产者与消费者
在多线程情况下,会有多个线程同时操作队列,但这个时候就会存在线程安全问题。见并发队列解决方案。
(2) 并发队列队列 (多线程操作)
①并发原理(关注锁粒度即可)
-
最简单直接的实现方式是直接在enqueue()、dequeue()方法上加锁,但是锁粒度大并发度会比较低,同一时刻仅允许一个生产者存或者消费者取操作。
-
实际上,基于数组的循环队列,利用CAS原子操作,可以实现非常高效的并发队列。这也是循环队列比链式队列应用更加广泛的原因。
②并发请求处理策略
-
非阻塞方式: 请求满时,直接拒绝任务请求
-
阻塞方式:请求满时,排队等候直到有空闲线程处理
③采用不同数据结构实现特点
-
链表实现: 无限排队的无界队列,但是可能会导致过多的请求排队等待,请求处理的响应时间过长。不适合快速响应系统
-
数组实现: 队列的大小有限,所以线程池中排队的请求超过队列大小时,接下来的请求就会被拒绝。适合快速响应系统。队列太大导致等待的请求太多,队列太小会导致无法充分利用系统资源、发挥最大性能(太大请求超时,太小降低并发量浪费资源)。
④CAS实现无锁并发队列原理
-
入队前:获取队列tail位置,入队时比较tail位置是否发生变化,如果未变化,则允许入队。否则拒绝本次请求。
-
出队前:获取队列head位置,同上比较是否发生变化,若未变化则允许出队。