docs: add algorithm

Author: Mayandev

算法与数据结构学习/.eslintrc.js

@@ -0,0 +1,19 @@
+module.exports = {
+  env: {
+    browser: true,
+    es6: true,
+  },
+  extends: [
+    'airbnb-base',
+  ],
+  globals: {
+    Atomics: 'readonly',
+    SharedArrayBuffer: 'readonly',
+  },
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: 'module',
+  },
+  rules: {
+  },
+};

算法与数据结构学习/README.md

@@ -2,14 +2,17 @@
 
 ## 数据结构
 
-- [链表](https://github.com/Mayandev/javascript_algorithm/blob/master/%E7%AE%97%E6%B3%95%E4%B8%8E%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%AD%A6%E4%B9%A0/data-structures/linked-list)
-
-- [双向链表](https://github.com/Mayandev/javascript_algorithm/blob/master/%E7%AE%97%E6%B3%95%E4%B8%8E%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%AD%A6%E4%B9%A0/data-structures/doubly-linked-list)
-
-- [队列](https://github.com/Mayandev/javascript_algorithm/blob/master/%E7%AE%97%E6%B3%95%E4%B8%8E%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%AD%A6%E4%B9%A0/data-structures/queue)
+- [链表](data-structures/linked-list)
+- [双向链表](data-structures/doubly-linked-list)
+- [队列](data-structures/queue)
+- [堆栈](data-structures/stack)
+- [哈希表](data-structures/hash-table)
+- [堆](data-structures/heap)
+- [有限队列](data-structures/priority-queue)
 
 ## 算法
 
 ### 排序
 
-- [归并排序](https://github.com/Mayandev/javascript_algorithm/blob/master/%E7%AE%97%E6%B3%95%E4%B8%8E%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%AD%A6%E4%B9%A0/algorithms/sort/merge-sort.js)
+- [归并排序](algorithms/sort/merge-sort)
+- [堆排序](algorithms/sort/heap-sort)

算法与数据结构学习/algorithms/sort/SortTester.js

@@ -0,0 +1,28 @@
+export const sortedArr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+export const reverseArr = [20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+export const notSortedArr = [15, 8, 5, 12, 10, 1, 16, 9, 11, 7, 20, 3, 2, 6, 17, 18, 4, 13, 14, 19];
+export const equalArr = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+export const negativeArr = [-1, 0, 5, -10, 20, 13, -7, 3, 2, -3];
+export const negativeArrSorted = [-10, -7, -3, -1, 0, 2, 3, 5, 13, 20];
+
+export class SortTester {
+  static testSort(SortingClass) {
+    const sorter = new SortingClass();
+
+    expect(sorter.sort([])).toEqual([]);
+    expect(sorter.sort([1])).toEqual([1]);
+    expect(sorter.sort([1, 2])).toEqual([1, 2]);
+    expect(sorter.sort([2, 1])).toEqual([1, 2]);
+    expect(sorter.sort([3, 4, 2, 1, 0, 0, 4, 3, 4, 2])).toEqual([0, 0, 1, 2, 2, 3, 3, 4, 4, 4]);
+    expect(sorter.sort(sortedArr)).toEqual(sortedArr);
+    expect(sorter.sort(reverseArr)).toEqual(sortedArr);
+    expect(sorter.sort(notSortedArr)).toEqual(sortedArr);
+    expect(sorter.sort(equalArr)).toEqual(equalArr);
+  }
+
+  static testNegativeNumbersSort(SortingClass) {
+    const sorter = new SortingClass();
+    expect(sorter.sort(negativeArr)).toEqual(negativeArrSorted);
+  }
+
+}

算法与数据结构学习/algorithms/sort/heap-sort/HeapSort.js

@@ -0,0 +1,20 @@
+import MinHeap from '../../../data-structures/heap/MinHeap'
+
+export default class HeapSort {
+  sort (originalArray) {
+    const sortedArray = [];
+
+    const minHeap = new MinHeap();
+
+    originalArray.forEach(element => {
+      minHeap.add(element)
+    });
+
+    while (!minHeap.isEmpty()) {
+      const nextMinElement = minHeap.poll();
+
+      sortedArray.push(nextMinElement);
+    }
+    return sortedArray;
+  }
+}

算法与数据结构学习/algorithms/sort/heap-sort/README.md

@@ -0,0 +1,17 @@
+# Heap Sort
+
+Heapsort是一种基于比较的排序算法。堆排序可以认为是一种改进的选择排序：类似于该算法，它将输入分为排序和未排序的区域，并反复进行通过提取最大的区域来缩小未分类区域元素并将其移至已排序的区域。改进方法包括使用堆数据结构而不是线性时间搜索来找到最大值。
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/1/1b/Sorting_heapsort_anim.gif)
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/4/4d/Heapsort-example.gif)
+
+## Complexity
+
+| 名称                  | 最优            | 平均             | 最差               | 空间    | 稳定    | Comments  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Heap sort**         | n log(n)   | n log(n)       | n log(n)       | 1         | No        |           |
+
+## References
+
+[Wikipedia](https://en.wikipedia.org/wiki/Heapsort)

算法与数据结构学习/algorithms/sort/heap-sort/__test__/HeapSort.test.js

@@ -0,0 +1,19 @@
+import HeapSort from '../HeapSort';
+import {
+  equalArr,
+  notSortedArr,
+  reverseArr,
+  sortedArr,
+  SortTester,
+} from '../../SortTester';
+
+describe('HeapSort', () => {
+  it('should sort array', () => {
+    SortTester.testSort(HeapSort);
+  });
+
+  it('should sort negative numbers', () => {
+    SortTester.testNegativeNumbersSort(HeapSort);
+  });
+
+});

算法与数据结构学习/algorithms/sort/merge-sort/README.md

@@ -0,0 +1,23 @@
+# Merge Sort
+
+在计算机科学中，合并排序（通常也拼写为mergesort）是一种高效的通用功能，基于比较的排序算法。 大多数实施产生稳定的排序，这意味着执行保留排序后相等元素的输入顺序输出。 Mergesort是一种分而治之的算法，由约翰·冯·诺伊曼（John von Neumann）于1945年发明。
+
+合并排序的示例。 首先将列表分为最小单位（1个元素），然后比较每个元素与相邻列表进行排序和合并两个相邻的列表。 最后将所有元素排序并合并。
+
+![合并排序]（https://upload.wikimedia.org/wikipedia/commons/c/cc/Merge-sort-example-300px.gif）
+
+递归合并排序算法，用于对7个数组进行排序整数值。 这些是人类将要采取的步骤模拟合并排序（自上而下）。
+
+
+![Merge Sort](https://upload.wikimedia.org/wikipedia/commons/e/e6/Merge_sort_algorithm_diagram.svg)
+
+## Complexity
+
+| 名称                  | 最优            | 平均             | 最差               | 空间    | 稳定    | 评论  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **归并排序**        | n log(n)   | n log(n)       | n log(n)       | n         | Yes       |           |
+
+## References
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Merge_sort)
+- [YouTube](https://www.youtube.com/watch?v=KF2j-9iSf4Q&index=27&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

算法与数据结构学习/algorithms/sort/merge-sort.js renamed to 算法与数据结构学习/algorithms/sort/merge-sort/merge-sort.js

@@ -26,6 +26,9 @@ export default class HashTable {
       0,
     );
 
+    console.log(hash);
+    
+
 
     // 减少哈希数，使其适合哈希表的大小。
     return hash % this.buckets.length;
@@ -34,7 +37,6 @@ export default class HashTable {
   // 插入函数
   set(key, value) {
     const keyHash = this.hash(key);
-    console.log(key, value);
     this.keys[key] = keyHash;
     const bucketLinkedList = this.buckets[keyHash];
     const node = bucketLinkedList.find({callback: nodeValue => nodeValue.key === key})

算法与数据结构学习/data-structures/hash-table/HashTable.js

@@ -0,0 +1,21 @@
+# 哈希表
+
+在计算中, 一个  **哈希表(hash table 或hash map)**  是一种实现 *关联数组(associative array)* 
+的抽象数据；类型, 该结构可以将 *键映射到值*。
+
+哈希表使用 *哈希函数/散列函数* 来计算一个值在数组或桶(buckets)中或槽(slots)中对应的索引,可使用该索引找到所需的值。
+
+理想情况下,散列函数将为每个键分配给一个唯一的桶(bucket),但是大多数哈希表设计采用不完美的散列函数,这可能会导致"哈希冲突(hash collisions)",也就是散列函数为多个键(key)生成了相同的索引,这种碰撞必须
+以某种方式进行处理。
+
+
+![Hash Table](https://upload.wikimedia.org/wikipedia/commons/7/7d/Hash_table_3_1_1_0_1_0_0_SP.svg)
+
+通过单独的链接解决哈希冲突
+
+![Hash Collision](https://upload.wikimedia.org/wikipedia/commons/d/d0/Hash_table_5_0_1_1_1_1_1_LL.svg)
+
+## 参考
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Hash_table)
+- [YouTube](https://www.youtube.com/watch?v=shs0KM3wKv8&index=4&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

算法与数据结构学习/data-structures/hash-table/README.md

@@ -2,12 +2,13 @@ import HashTable from './HashTable';
 
 let hashTable = new HashTable();
 
-hashTable.set('a', 'aaaaaa')
-hashTable.set('b', 'bbbbbb')
-hashTable.set('c', 'cccccc')
-hashTable.set('d', 'dddddd')
+hashTable.set('a', 'sky-old');
+hashTable.set('a', 'sky');
+hashTable.set('b', 'sea');
+hashTable.set('c', 'earth');
+hashTable.set('d', 'ocean');
 
-hashTable.get('c')
+hashTable.buckets[1].toString();
 console.log(hashTable.getKeys())
 console.log(hashTable.has);
 

算法与数据结构学习/data-structures/hash-table/Test.js

@@ -0,0 +1,89 @@
+import HashTable from '../HashTable';
+
+describe('HashTable', () => {
+  it('should create hash table of certain size', () => {
+    const defaultHashTable = new HashTable();
+    expect(defaultHashTable.buckets.length).toBe(32);
+
+    const biggerHashTable = new HashTable(64);
+    expect(biggerHashTable.buckets.length).toBe(64);
+  });
+
+  it('should generate proper hash for specified keys', () => {
+    const hashTable = new HashTable();
+
+    expect(hashTable.hash('a')).toBe(1);
+    expect(hashTable.hash('b')).toBe(2);
+    expect(hashTable.hash('abc')).toBe(6);
+  });
+
+  it('should set, read and delete data with collisions', () => {
+    const hashTable = new HashTable(3);
+
+    expect(hashTable.hash('a')).toBe(1);
+    expect(hashTable.hash('b')).toBe(2);
+    expect(hashTable.hash('c')).toBe(0);
+    expect(hashTable.hash('d')).toBe(1);
+
+    hashTable.set('a', 'sky-old');
+    hashTable.set('a', 'sky');
+    hashTable.set('b', 'sea');
+    hashTable.set('c', 'earth');
+    hashTable.set('d', 'ocean');
+
+    expect(hashTable.has('x')).toBe(false);
+    expect(hashTable.has('b')).toBe(true);
+    expect(hashTable.has('c')).toBe(true);
+
+    const stringifier = value => `${value.key}:${value.value}`;
+
+    expect(hashTable.buckets[0].toString(stringifier)).toBe('c:earth');
+    expect(hashTable.buckets[1].toString(stringifier)).toBe('a:sky,d:ocean');
+    expect(hashTable.buckets[2].toString(stringifier)).toBe('b:sea');
+
+    expect(hashTable.get('a')).toBe('sky');
+    expect(hashTable.get('d')).toBe('ocean');
+    expect(hashTable.get('x')).not.toBeDefined();
+
+    hashTable.delete('a');
+
+    expect(hashTable.delete('not-existing')).toBeNull();
+
+    expect(hashTable.get('a')).not.toBeDefined();
+    expect(hashTable.get('d')).toBe('ocean');
+
+    hashTable.set('d', 'ocean-new');
+    expect(hashTable.get('d')).toBe('ocean-new');
+  });
+
+  it('should be possible to add objects to hash table', () => {
+    const hashTable = new HashTable();
+
+    hashTable.set('objectKey', { prop1: 'a', prop2: 'b' });
+
+    const object = hashTable.get('objectKey');
+    expect(object).toBeDefined();
+    expect(object.prop1).toBe('a');
+    expect(object.prop2).toBe('b');
+  });
+
+  it('should track actual keys', () => {
+    const hashTable = new HashTable(3);
+
+    hashTable.set('a', 'sky-old');
+    hashTable.set('a', 'sky');
+    hashTable.set('b', 'sea');
+    hashTable.set('c', 'earth');
+    hashTable.set('d', 'ocean');
+
+    expect(hashTable.getKeys()).toEqual(['a', 'b', 'c', 'd']);
+    expect(hashTable.has('a')).toBe(true);
+    expect(hashTable.has('x')).toBe(false);
+
+    hashTable.delete('a');
+
+    expect(hashTable.has('a')).toBe(false);
+    expect(hashTable.has('b')).toBe(true);
+    expect(hashTable.has('x')).toBe(false);
+  });
+});