diff --git a/docs/notes/算法 - 栈和队列.md b/docs/notes/算法 - 栈和队列.md
index f72e8521..9a0f69a4 100644
--- a/docs/notes/算法 - 栈和队列.md
+++ b/docs/notes/算法 - 栈和队列.md
@@ -1,192 +1,318 @@
-* [前言](#前言)
-* [Quick Find](#quick-find)
-* [Quick Union](#quick-union)
-* [加权 Quick Union](#加权-quick-union)
-* [路径压缩的加权 Quick Union](#路径压缩的加权-quick-union)
-* [比较](#比较)
+* [栈](#栈)
+ * [1. 数组实现](#1-数组实现)
+ * [2. 链表实现](#2-链表实现)
+* [队列](#队列)
-# 前言
-
-用于解决动态连通性问题，能动态连接两个点，并且判断两个点是否连通。
-
- 
-
-| 方法 | 描述 |
-| :---: | :---: |
-| UF(int N) | 构造一个大小为 N 的并查集 |
-| void union(int p, int q) | 连接 p 和 q 节点 |
-| int find(int p) | 查找 p 所在的连通分量编号 |
-| boolean connected(int p, int q) | 判断 p 和 q 节点是否连通 |
+# 栈
```java
-public abstract class UF {
+public interface MyStack- extends Iterable
- {
- protected int[] id;
+ MyStack
- push(Item item);
- public UF(int N) {
- id = new int[N];
- for (int i = 0; i < N; i++) {
- id[i] = i;
- }
- }
+ Item pop() throws Exception;
- public boolean connected(int p, int q) {
- return find(p) == find(q);
- }
+ boolean isEmpty();
- public abstract int find(int p);
+ int size();
- public abstract void union(int p, int q);
}
```
-# Quick Find
-
-可以快速进行 find 操作，也就是可以快速判断两个节点是否连通。
-
-需要保证同一连通分量的所有节点的 id 值相等。
-
-但是 union 操作代价却很高，需要将其中一个连通分量中的所有节点 id 值都修改为另一个节点的 id 值。
-
-
+## 1. 数组实现
```java
-public class QuickFindUF extends UF {
+public class ArrayStack- implements MyStack
- {
- public QuickFindUF(int N) {
- super(N);
+ // 栈元素数组，只能通过转型来创建泛型数组
+ private Item[] a = (Item[]) new Object[1];
+
+ // 元素数量
+ private int N = 0;
+
+
+ @Override
+ public MyStack
- push(Item item) {
+ check();
+ a[N++] = item;
+ return this;
}
@Override
- public int find(int p) {
- return id[p];
- }
+ public Item pop() throws Exception {
-
- @Override
- public void union(int p, int q) {
- int pID = find(p);
- int qID = find(q);
-
- if (pID == qID) {
- return;
+ if (isEmpty()) {
+ throw new Exception("stack is empty");
}
- for (int i = 0; i < id.length; i++) {
- if (id[i] == pID) {
- id[i] = qID;
+ Item item = a[--N];
+
+ check();
+
+ // 避免对象游离
+ a[N] = null;
+
+ return item;
+ }
+
+
+ private void check() {
+
+ if (N >= a.length) {
+ resize(2 * a.length);
+
+ } else if (N > 0 && N <= a.length / 4) {
+ resize(a.length / 2);
+ }
+ }
+
+
+ /**
+ * 调整数组大小，使得栈具有伸缩性
+ */
+ private void resize(int size) {
+
+ Item[] tmp = (Item[]) new Object[size];
+
+ for (int i = 0; i < N; i++) {
+ tmp[i] = a[i];
+ }
+
+ a = tmp;
+ }
+
+
+ @Override
+ public boolean isEmpty() {
+ return N == 0;
+ }
+
+
+ @Override
+ public int size() {
+ return N;
+ }
+
+
+ @Override
+ public Iterator
- iterator() {
+
+ // 返回逆序遍历的迭代器
+ return new Iterator
- () {
+
+ private int i = N;
+
+ @Override
+ public boolean hasNext() {
+ return i > 0;
}
- }
+
+ @Override
+ public Item next() {
+ return a[--i];
+ }
+ };
+
}
}
```
-# Quick Union
+## 2. 链表实现
-可以快速进行 union 操作，只需要修改一个节点的 id 值即可。
-
-但是 find 操作开销很大，因为同一个连通分量的节点 id 值不同，id 值只是用来指向另一个节点。因此需要一直向上查找操作，直到找到最上层的节点。
-
-
+需要使用链表的头插法来实现，因为头插法中最后压入栈的元素在链表的开头，它的 next 指针指向前一个压入栈的元素，在弹出元素时就可以通过 next 指针遍历到前一个压入栈的元素从而让这个元素成为新的栈顶元素。
```java
-public class QuickUnionUF extends UF {
+public class ListStack- implements MyStack
- {
- public QuickUnionUF(int N) {
- super(N);
+ private Node top = null;
+ private int N = 0;
+
+
+ private class Node {
+ Item item;
+ Node next;
}
@Override
- public int find(int p) {
- while (p != id[p]) {
- p = id[p];
- }
- return p;
+ public MyStack
- push(Item item) {
+
+ Node newTop = new Node();
+
+ newTop.item = item;
+ newTop.next = top;
+
+ top = newTop;
+
+ N++;
+
+ return this;
}
@Override
- public void union(int p, int q) {
- int pRoot = find(p);
- int qRoot = find(q);
+ public Item pop() throws Exception {
- if (pRoot != qRoot) {
- id[pRoot] = qRoot;
+ if (isEmpty()) {
+ throw new Exception("stack is empty");
}
+
+ Item item = top.item;
+
+ top = top.next;
+ N--;
+
+ return item;
+ }
+
+
+ @Override
+ public boolean isEmpty() {
+ return N == 0;
+ }
+
+
+ @Override
+ public int size() {
+ return N;
+ }
+
+
+ @Override
+ public Iterator
- iterator() {
+
+ return new Iterator
- () {
+
+ private Node cur = top;
+
+
+ @Override
+ public boolean hasNext() {
+ return cur != null;
+ }
+
+
+ @Override
+ public Item next() {
+ Item item = cur.item;
+ cur = cur.next;
+ return item;
+ }
+ };
+
}
}
```
-这种方法可以快速进行 union 操作，但是 find 操作和树高成正比，最坏的情况下树的高度为节点的数目。
+# 队列
-
+下面是队列的链表实现，需要维护 first 和 last 节点指针，分别指向队首和队尾。
-# 加权 Quick Union
-
-为了解决 quick-union 的树通常会很高的问题，加权 quick-union 在 union 操作时会让较小的树连接较大的树上面。
-
-理论研究证明，加权 quick-union 算法构造的树深度最多不超过 logN。
-
- 
+这里需要考虑 first 和 last 指针哪个作为链表的开头。因为出队列操作需要让队首元素的下一个元素成为队首，所以需要容易获取下一个元素，而链表的头部节点的 next 指针指向下一个元素，因此可以让 first 指针链表的开头。
```java
-public class WeightedQuickUnionUF extends UF {
+public interface MyQueue- extends Iterable
- {
- // 保存节点的数量信息
- private int[] sz;
+ int size();
+
+ boolean isEmpty();
+
+ MyQueue
- add(Item item);
+
+ Item remove() throws Exception;
+}
+```
+
+```java
+public class ListQueue
- implements MyQueue
- {
+
+ private Node first;
+ private Node last;
+ int N = 0;
- public WeightedQuickUnionUF(int N) {
- super(N);
- this.sz = new int[N];
- for (int i = 0; i < N; i++) {
- this.sz[i] = 1;
- }
+ private class Node {
+ Item item;
+ Node next;
}
@Override
- public int find(int p) {
- while (p != id[p]) {
- p = id[p];
- }
- return p;
+ public boolean isEmpty() {
+ return N == 0;
}
@Override
- public void union(int p, int q) {
+ public int size() {
+ return N;
+ }
- int i = find(p);
- int j = find(q);
- if (i == j) return;
+ @Override
+ public MyQueue
- add(Item item) {
- if (sz[i] < sz[j]) {
- id[i] = j;
- sz[j] += sz[i];
+ Node newNode = new Node();
+ newNode.item = item;
+ newNode.next = null;
+
+ if (isEmpty()) {
+ last = newNode;
+ first = newNode;
} else {
- id[j] = i;
- sz[i] += sz[j];
+ last.next = newNode;
+ last = newNode;
}
+
+ N++;
+ return this;
+ }
+
+
+ @Override
+ public Item remove() throws Exception {
+
+ if (isEmpty()) {
+ throw new Exception("queue is empty");
+ }
+
+ Node node = first;
+ first = first.next;
+ N--;
+
+ if (isEmpty()) {
+ last = null;
+ }
+
+ return node.item;
+ }
+
+
+ @Override
+ public Iterator
- iterator() {
+
+ return new Iterator
- () {
+
+ Node cur = first;
+
+
+ @Override
+ public boolean hasNext() {
+ return cur != null;
+ }
+
+
+ @Override
+ public Item next() {
+ Item item = cur.item;
+ cur = cur.next;
+ return item;
+ }
+ };
}
}
```
-
-# 路径压缩的加权 Quick Union
-
-在检查节点的同时将它们直接链接到根节点，只需要在 find 中添加一个循环即可。
-
-# 比较
-
-| 算法 | union | find |
-| :---: | :---: | :---: |
-| Quick Find | N | 1 |
-| Quick Union | 树高 | 树高 |
-| 加权 Quick Union | logN | logN |
-| 路径压缩的加权 Quick Union | 非常接近 1 | 非常接近 1 |