code: 新增结构

Author: Mayandev

leetcode刷题/note/No110_is-balanced.md

@@ -0,0 +1,81 @@
+# No.110 平衡二叉树
+
+给定一个二叉树，判断它是否是高度平衡的二叉树。
+
+本题中，一棵高度平衡二叉树定义为：
+
+一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。
+
+## 示例
+
+示例 1:
+
+给定二叉树 [3,9,20,null,null,15,7]
+
+    3
+   / \
+  9  20
+    /  \
+   15   7
+返回 true 。
+
+示例 2:
+
+给定二叉树 [1,2,2,3,3,null,null,4,4]
+
+       1
+      / \
+     2   2
+    / \
+   3   3
+  / \
+ 4   4
+返回 false 。
+
+## 解题思路
+
+### 1、自顶向下发
+
+遍历每一个节点，计算节点的左右子树高度。
+
+```javascript
+var isBalanced = function(root) {
+  if (root == null) return true;
+  return (Math.abs(leftHeight(root) - rightHeight(root)) <= 1) && isBalanced(root.left) && isBalanced(root.right)
+};
+
+var leftHeight = function(node) {
+  if (!node) return 0;
+  return height(node.left) + 1;
+}
+
+var rightHeight = function(node) {
+  if (!node) return 0;
+  return height(node.right) + 1;
+}
+
+var height = function(node) {
+  return Math.max(leftHeight(node), rightHeight(node));
+}
+```
+
+### 2、自底向上
+
+对二叉树做深度优先遍历DFS，递归过程中，当我们发现有一例 左/右子树高度差 ＞ 1 的情况时，代表此树不是平衡树，返回-1；
+当发现不是平衡树时，后面的高度计算都没有意义了，因此一路返回-1，避免后续多余计算。
+最差情况是对树做一遍完整DFS，时间复杂度为 O(N)。
+
+```javascript
+var isBalanced = function(root) {
+  return depth(root) != -1;
+};
+
+var depth = function(root) {
+  if (!root) return 0;
+  let left = depth(root.left);
+  if (left == -1) return -1;
+  let right = depth(root.right);
+  if (right == -1) return -1;
+  return Math.abs(left - right) < 2 ? Math.max(left, right) + 1 : -1;
+}
+```

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

@@ -1,19 +1,15 @@
-module.exports = {
-  env: {
-    browser: true,
-    es6: true,
-  },
-  extends: [
-    'airbnb-base',
-  ],
-  globals: {
-    Atomics: 'readonly',
-    SharedArrayBuffer: 'readonly',
-  },
-  parserOptions: {
-    ecmaVersion: 2018,
-    sourceType: 'module',
-  },
-  rules: {
-  },
-};
+{
+  "root": true,
+  "extends": "airbnb",
+  "plugins": ["jest"],
+  "env": {
+    "jest/globals": true
+  },
+  "rules": {
+    "no-bitwise": "off",
+    "no-lonely-if": "off",
+    "class-methods-use-this": "off",
+    "arrow-body-style": "off",
+    "no-loop-func": "off"
+  }
+}

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

@@ -8,7 +8,8 @@
 - [堆栈](data-structures/stack)
 - [哈希表](data-structures/hash-table)
 - [堆](data-structures/heap)
-- [有限队列](data-structures/priority-queue)
+- [优先队列](data-structures/priority-queue)
+- [字典树](data-structures/trie)
 
 ## 算法
 

算法与数据结构学习/algorithms/shell-sort/ShellSort.js

@@ -0,0 +1,18 @@
+function shellSort(arr) {
+  var len = arr.length,
+      temp,
+      gap = Math.floor(len / 2);
+  while (gap > 0) {
+      for (var i = gap; i < len; i++) {
+          temp = arr[i];
+          for (var j = i-gap; j >= 0 && arr[j] > temp; j -= gap) {
+              arr[j+gap] = arr[j];
+          }
+          arr[j+gap] = temp;
+      }
+      gap = Math.floor(gap / 2);
+  }
+  return arr;
+}
+
+console.log(shellSort([5,2,4,1,3]))

算法与数据结构学习/algorithms/sort/insertion-sort/InsertionSort.js

@@ -0,0 +1,18 @@
+export default class InsertionSort {
+  sort(originalArray) {
+    const array = [...originalArray];
+
+    for (let i = 1; i < array.length; i++) {
+      
+      let currentIdx = i;
+
+      while ((array[currentIdx] < array[currentIdx - 1]) && currentIdx > 0) {
+        const tmp = array[currentIdx - 1];
+        array[currentIdx - 1] = array[currentIdx];
+        array[currentIdx] = tmp;
+        currentIdx--;
+      }
+    }
+    return array;
+  }
+}

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

@@ -0,0 +1,19 @@
+# 插入排序
+
+插入排序是一种构建简单的排序算法，最终排序的数组（或列表）一次一个。在大型列表上，效率要比在大型列表上低得多
+高级算法，例如快速排序，堆排序或合并排序。
+
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/4/42/Insertion_sort.gif)
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif)
+
+## 复杂度
+
+| 名称                  | 最优            | 平均             | 最差               | Memory    | Stable    | Comments  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Insertion sort**    | n               | n<sup>2</sup>       | n<sup>2</sup>       | 1         | Yes       |           |
+
+## References
+
+[Wikipedia](https://en.wikipedia.org/wiki/Insertion_sort)

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

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

算法与数据结构学习/algorithms/sort/quick-sort/QuickSortInPlace.js

@@ -0,0 +1,21 @@
+export default class QuickSortInPlace extends Sort {
+  sort(
+    originalArray,
+    inputLowIndex = 0,
+    inputHighIndex = originalArray.length - 1,
+    recursiveCall = false,
+  ) {
+    // 复制一份数组，然后对array进行原地排序
+    const array = recursiveCall ? originalArray : [...originalArray];
+
+    const partitionArray = (lowIndex, highIndex) => {
+      const swap = (leftIndex, rightIndex) => {
+        const temp = array[leftIndex];
+        array[leftIndex] = array[rightIndex];
+        array[rightIndex] = temp;
+      }
+
+      const pivot = array[highIndex];
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+function quickSort(arr, low, high) {
+  // 调整数组
+  let i = adjustArr(arr, low, high);
+  // 分治
+  quickSort(arr, low, i-1);
+  quickSort(arr, i+1, high);
+}
+
+function adjustArr(arr, low, high) {
+  let pivot = arr[low];
+
+  while (low < high) {
+    while (arr[high] > pivot)
+      high--;
+    arr[low++] = arr[high];
+    while (arr[low] < pivot)
+      low++;
+    arr[high--] = arr[low];
+  }
+
+  arr[low] = pivot;
+  return low;
+}
+
+let arr = [72,6,57,88,60,42,83,73,48,85];
+quickSort(arr, 0, arr.length-1);
+console.log(arr);

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

@@ -0,0 +1,29 @@
+function quickSort(arr, low, high) {
+  if (low < high) {
+    // 调整数组
+    let i = adjustArr(arr, low, high);
+    // 分治
+    quickSort(arr, low, i-1);
+    quickSort(arr, i+1, high);
+  } 
+}
+
+function adjustArr(arr, low, high) {
+  let pivot = arr[low];
+
+  while (low < high) {
+    while (low < high && arr[high] > pivot)
+      high--;
+      arr[low] = arr[high];
+    while (low < high && arr[low] < pivot)
+      low++;
+      arr[high] = arr[low];
+  }
+
+  arr[low] = pivot;
+  return low;
+}
+
+let arr = [72,6,57,88,60,42,83,73,48,85];
+quickSort(arr, 0, arr.length-1);
+console.log(arr);

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

@@ -26,7 +26,6 @@ export default class HashTable {
       0,
     );
 
-    console.log(hash);