From 02fde522e65e864d78e734fe387d26429b76e74f Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Sat, 9 Mar 2019 23:42:50 +0800 Subject: [PATCH] auto commit --- docs/notes/算法 - 栈和队列.md | 370 +++++++++++++++++++++++----------- 1 file changed, 248 insertions(+), 122 deletions(-) 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 |