学习 堆和优先队列

Author: cloudyan

src/data-structures/doubly-linked-list/README.zh-CN.md

@@ -10,6 +10,10 @@
 
 在双向链表中进行添加或者删除节点时，需做的链接更改要比单向链表复杂得多。这种操作在单向链表中更简单高效，因为不需要关注一个节点（除第一个和最后一个节点以外的节点）的两个链接，而只需要关注一个链接即可。
 
+## 基本操作
+
+同链表
+
 ## 基础操作的伪代码
 
 ### 插入

src/data-structures/hash-table/HashTable.js

@@ -35,6 +35,7 @@ export default class HashTable {
     //
     // where charCodeAt(i) is the i-th character code of the key, n is the length of the key and
     // PRIME is just any prime number like 31.
+    // 求和取余
     const hash = Array.from(key).reduce(
       (hashAccumulator, keySymbol) => (hashAccumulator + keySymbol.charCodeAt(0)),
       0,

src/data-structures/hash-table/README.zh-CN.md

@@ -5,11 +5,20 @@
 
 哈希表使用 *哈希函数/散列函数* 来计算一个值在数组或桶(buckets)中或槽(slots)中对应的索引，可使用该索引找到所需的值。
 
+## 基本操作
+
+- hash 计算 hash 值
+- set
+- get
+- delete
+- has
+- getKeys
+
 ## 伪代码
 
 ### 计算 hash
 
-为简单起见，我们将只使用密钥中所有字符的字符代码和计算散列值。但也可以使用更复杂的方法，如多项式字符串哈希来减少碰撞次数：
+为简单起见，我们将只使用密钥中所有字符的字符代码**求和取余**计算散列值。但也可以使用更复杂的方法，如多项式字符串哈希来减少碰撞次数：
 
 ```text
 hash = charCodeAt(0) * PRIME^(n-1) + charCodeAt(1) * PRIME^(n-2) + ... + charCodeAt(n-1)
@@ -31,6 +40,8 @@ end Hash
 
 理想情况下，散列函数将为每个键分配给一个唯一的桶(bucket)，但是大多数哈希表设计采用不完美的散列函数，这可能会导致"哈希冲突(hash collisions)"，也就是散列函数为多个键(key)生成了相同的索引，这种碰撞必须以某种方式进行处理。
 
+如果存在冲突则 `append` 处理，否则直接赋值
+
 ![Hash Table](./images/hash-table.jpeg)
 
 *Made with [okso.app](https://okso.app)*

src/data-structures/heap/Heap.js

@@ -2,6 +2,7 @@ import Comparator from '../../utils/comparator/Comparator';
 
 /**
  * Parent class for Min and Max Heaps.
+ * 这里的堆实际上是二叉堆(Binary Heap)，其实也可定义k叉堆。
  */
 export default class Heap {
   /**
@@ -36,7 +37,7 @@ export default class Heap {
 
   /**
    * @param {number} childIndex
-   * @return {number}
+   * @return {number} 向下取整
    */
   getParentIndex(childIndex) {
     return Math.floor((childIndex - 1) / 2);
@@ -67,27 +68,27 @@ export default class Heap {
   }
 
   /**
-   * @param {number} parentIndex
+   * @param {number} childIndex
    * @return {*}
    */
-  leftChild(parentIndex) {
-    return this.heapContainer[this.getLeftChildIndex(parentIndex)];
+  parent(childIndex) {
+    return this.heapContainer[this.getParentIndex(childIndex)];
   }
 
   /**
    * @param {number} parentIndex
    * @return {*}
    */
-  rightChild(parentIndex) {
-    return this.heapContainer[this.getRightChildIndex(parentIndex)];
+  leftChild(parentIndex) {
+    return this.heapContainer[this.getLeftChildIndex(parentIndex)];
   }
 
   /**
-   * @param {number} childIndex
+   * @param {number} parentIndex
    * @return {*}
    */
-  parent(childIndex) {
-    return this.heapContainer[this.getParentIndex(childIndex)];
+  rightChild(parentIndex) {
+    return this.heapContainer[this.getRightChildIndex(parentIndex)];
   }
 
   /**

src/data-structures/heap/README.zh-CN.md

@@ -14,10 +14,54 @@
 
 ![Array Representation](./images/array-representation.jpeg)
 
+在堆“顶部”的没有父级节点的节点, 被称之为根节点。
 
-在堆“顶部”的没有父级节点的节点,被称之为根节点。
+## 基本操作
+
+堆就是用数组实现的一棵完全二叉树（在时间和空间上很高效），堆是完全二叉树，索引值具有以下关系
+
+```text
+        parent(index)
+       /             \
+left(2*index+1)  right(2*index+2)
+
+- 第 h 层第 n 个元素是 `2 ^ h + n`
+- 索引:父计算子
+  leftChildIndex 为 `parentIndex * 2 + 1`
+  rightChildIndex 为 `parentIndex * 2 + 2`
+- 索引:子计算父
+  parentIndex 为 `(childIndex - 1) / 2` 后向下取整
+
+因为上面索引值的关系，这也就是为什么可以直接用数组来存储堆的原因。
+```
+
+- 索引、父子元素等操作
+  - getLeftChildIndex
+  - getRightChildIndex
+  - getParentIndex
+  - hasParent 通过索引值有效性来判断
+  - hasLeftChild
+  - hasRightChild
+  - parent 通过索引值获取
+  - leftChild
+  - rightChild
+- swap 两个值交换位置
+- peek 仅仅读取最小值或最大值
+- poll 从堆中提取最小值或最大值 `O(1)`
+- add 向堆中插入一个新元素 insert(value)
+  - buildHeap(array) 通过反复调用 `insert()` 方法将一个（无序）数组转换成一个堆。如果你足够聪明，你可以在 `O(n)` 时间内完成。
+- remove 删除堆元素 delete removeAtIndex(index)
+- find search(value)
+- isEmpty
+- toString
+- 原始操作，用于保证插入或删除节点以后使其符合堆的性质
+  - heapifyUp 将新元素提升使其符合堆的性质
+  - heapifyDown 使删除堆顶元素的堆再次成为堆
+  - pairIsInCorrectOrder 检查堆元素的顺序是否正确
 
 ## 参考
 
 - [Wikipedia](https://en.wikipedia.org/wiki/Heap_(data_structure))
 - [YouTube](https://www.youtube.com/watch?v=t0Cq6tVNRBA&index=5&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [数据结构之“堆”](http://www.cnblogs.com/Jason-Damon/archive/2012/04/18/2454649.html)
+- [数据结构：堆（Heap）](https://www.jianshu.com/p/6b526aa481b1)

src/data-structures/linked-list/README.zh-CN.md

@@ -12,6 +12,26 @@
 
 *Made with [okso.app](https://okso.app)*
 
+## 基本操作
+
+- 插入
+  - prepend
+  - append
+- 搜索
+  - find
+- 删除
+  - delete
+  - deleteHead
+  - deleteTail
+- 辅助
+  - toArray
+  - fromArray
+  - toString
+  - reverse
+- 其他
+  - 遍历
+  - 反向遍历
+
 ## 基本操作的伪代码
 
 [伪代码格式](https://blog.csdn.net/ssisse/article/details/51501797)

src/data-structures/priority-queue/README.zh-CN.md

@@ -4,12 +4,32 @@
 
 在优先队列中, 低优先级的元素之前前面应该是高优先级的元素。 如果两个元素具有相同的优先级, 则根据它们在队列中的顺序是它们的出现顺序即可。
 
-优先队列虽通常用堆来实现,但它在概念上与堆不同。优先队列是一个抽象概念，就像“列表”或“图”这样的抽象概念一样; 
+优先队列虽通常用堆来实现, 但它在概念上与堆不同。优先队列是一个抽象概念, 就像“列表”或“图”这样的抽象概念一样;
 
-正如列表可以用链表或数组实现一样，优先队列可以用堆或各种其他方法实现,例如无序数组。
+正如列表可以用链表或数组实现一样, 优先队列可以用堆或各种其他方法实现, 例如无序数组。
 
+## 基本操作
+
+此处实现 inherit MinHeap，按优先级排序存储数据
+
+- add
+- remove
+- changePriority
+- findByValue
+- hasValue
+- comparePriority
+- compareValue
+
+优先队列的作用是能保证每次取出的元素都是队列中权值最小的（Java的优先队列每次取最小元素，C++的优先队列每次取最大元素）。这里牵涉到了大小关系，元素大小的评判可以通过元素本身的自然顺序（natural ordering），也可以通过构造时传入的比较器（Comparator，类似于C++的仿函数）。
+
+优先队列的应用比较广泛，比如作业系统中的调度程序，当一个作业完成后，需要在所有等待调度的作业中选择一个优先级最高的作业来执行，并且也可以添加一个新的作业到作业的优先队列中。
+
+问题：
+
+这里执行 poll 时，优先队列里存储的优先级并未删除，可以覆写处理
 
 ## 参考
 
 - [Wikipedia](https://en.wikipedia.org/wiki/Priority_queue)
 - [YouTube](https://www.youtube.com/watch?v=wptevk0bshY&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8&index=6)
+- [深入理解Java PriorityQueue](http://www.cnblogs.com/CarpenterLee/p/5488070.html)

src/data-structures/queue/README.zh-CN.md

@@ -4,13 +4,20 @@
 
 队列基本操作有两种：入队和出队。从队列的后端位置添加实体，称为入队；从队列的前端位置移除实体，称为出队。
 
-
 队列中元素先进先出 FIFO (first in, first out)的示意
 
 ![Queue](./images/queue.jpeg)
 
 *Made with [okso.app](https://okso.app)*
 
+## 基本操作
+
+- peek 读取队首 value
+- enqueue 队尾入队
+- dequeue 队首出队
+- toString
+- isEmpty
+
 ## 参考
 
 - [Wikipedia](https://en.wikipedia.org/wiki/Queue_(abstract_data_type))

src/data-structures/stack/README.zh-CN.md

@@ -2,8 +2,8 @@
 
 在计算机科学中, 一个 **栈(stack)** 是一种抽象数据类型,用作表示元素的集合,具有两种主要操作:
 
-* **push**, 添加元素到栈的顶端(末尾);
-* **pop**, 移除栈最顶端(末尾)的元素.
+- **push**, 添加元素到栈的顶端(末尾);
+- **pop**, 移除栈最顶端(末尾)的元素.
 
 以上两种操作可以简单概括为“后进先出(LIFO = last in, first out)”。
 
@@ -17,6 +17,16 @@
 
 *Made with [okso.app](https://okso.app)*
 
+## 基本操作
+
+- push
+- pop
+- peek
+- 辅助
+  - isEmpty
+  - toArray
+  - toString
+
 ## 参考
 
 - [Wikipedia](https://en.wikipedia.org/wiki/Stack_(abstract_data_type))