feat: btree && link-list

Author: Z1hgq

BinaryTree/banlenced-b-tree.js

@@ -0,0 +1,22 @@
+
+function getDepth(Tree) {
+  if (!Tree) return 0
+  const left = getDepth(Tree.left)
+  const right = getDepth(Tree.right)
+  // 左平衡 && 右平衡 && 左右高度 <= 1
+  if (left === -1 || right === -1 || Math.abs(left - right) > 1) {
+    return -1
+  }
+  if (left > right) {
+    return left + 1
+  }
+  return right + 1
+}
+
+function banlencedBTree(Tree) {
+  return getDepth(Tree) !== -1
+}
+
+const data = require('./generateBTree')
+
+console.log(banlencedBTree(data))

BinaryTree/bfs-tree.js

@@ -0,0 +1,15 @@
+function bfsTree(Tree) {
+  const res = []
+  const stack = [Tree]
+  while (stack.length) {
+    const node = stack.shift()
+    res.push(node.val)
+    node.left && stack.push(node.left)
+    node.right && stack.push(node.right)
+  }
+  return res
+}
+
+const data = require('./generateBTree')
+
+console.log(bfsTree(data))

BinaryTree/generateBTree.js

@@ -0,0 +1,33 @@
+
+
+
+function genTree(Tree, depth) {
+  if (depth === 0) {
+    Tree = null;
+    return;
+  }
+  if (!Tree.val) {
+    Tree.val = Math.ceil(Math.random() * 10);
+    Tree.left = {};
+    Tree.right = {};
+    genTree(Tree.left, depth - 1);
+    genTree(Tree.right, depth - 1);
+  }
+}
+
+const tree = {}
+genTree(tree, 3)
+
+module.exports = {
+  "val": 1,
+  "left": {
+    "val": 2,
+    "left": { "val": 4, "left": null, "right": null },
+    "right": { "val": 5, "left": null, "right": null }
+  },
+  "right": {
+    "val": 3,
+    "left": { "val": 6, "left": null, "right": null },
+    "right": { "val": 7, "left": null, "right": null }
+  }
+}

BinaryTree/in-order-traversal.js

@@ -0,0 +1,30 @@
+
+
+function inOrderTraversal1(Tree, res) {
+  if (!Tree) return
+  inOrderTraversal1(Tree.left, res)
+  res.push(Tree.val)
+  inOrderTraversal1(Tree.right, res)
+}
+
+function inOrderTraversal2(Tree) {
+  const res = []
+  const stack = []
+  while (Tree || stack.length) {
+    while (Tree) {
+      stack.push(Tree)
+      Tree = Tree.left
+    }
+    const node = stack.pop()
+    res.push(node.val)
+    Tree = node.right
+  }
+  return res
+}
+
+const data = require('./generateBTree')
+const r = []
+inOrderTraversal1(data, r)
+const res = inOrderTraversal2(data)
+
+console.log(res)

BinaryTree/max-depth-sum.js

@@ -0,0 +1,14 @@
+// Math.max(左边最大深度 + 父节点, 右边最大深度 + 父节点)
+function maxPathSum(Tree) {
+  if (!Tree) return 0
+  const left = Math.max(maxPathSum(Tree.left), 0)
+  const right = Math.max(maxPathSum(Tree.right), 0)
+  if (left > right) {
+    return left + Tree.val
+  }
+  return right + Tree.val
+}
+
+const data = require('./generateBTree')
+
+console.log(maxPathSum(data))

BinaryTree/max-depth.js

@@ -0,0 +1,9 @@
+function maxDepth(Tree) {
+  if (!Tree) return 0
+  const left = maxDepth(Tree.left)
+  const right = maxDepth(Tree.right)
+  if (left > right) {
+    return left + 1
+  }
+  return right + 1
+}

BinaryTree/post-order-traversal.js

@@ -0,0 +1,37 @@
+
+
+function postOrderTraversal1(Tree, res) {
+  if (!Tree) return
+  postOrderTraversal1(Tree.left, res)
+  postOrderTraversal1(Tree.right, res)
+  res.push(Tree.val)
+}
+
+function postOrderTraversal2(Tree) {
+  const res = []
+  const stack = []
+  let lastVisited = Tree
+  while (Tree || stack.length) {
+    while (Tree) {
+      stack.push(Tree)
+      Tree = Tree.left
+    }
+    const node = stack[stack.length - 1]
+    // 重点：先遍历了右儿子才能遍历自身
+    if (!node.right || node.right === lastVisited) {
+      stack.pop()
+      lastVisited = node
+      res.push(node.val)
+    } else {
+      Tree = node.right
+    }
+  }
+  return res
+}
+
+const data = require('./generateBTree')
+const r = []
+postOrderTraversal1(data, r)
+const res = postOrderTraversal2(data)
+
+console.log(res)

BinaryTree/pre-order-traversal.js

@@ -0,0 +1,29 @@
+
+
+function preOrderTranversal1(Tree, res) {
+  if (!Tree) return
+  res.push(Tree.val)
+  preOrderTranversal1(Tree.left, res)
+  preOrderTranversal1(Tree.right, res)
+}
+
+function preOrderTranversal2(Tree) {
+  const res = []
+  const stack = []
+  while (Tree || stack.length) {
+    while (Tree) {
+      stack.push(Tree)
+      res.push(Tree.val)
+      Tree = Tree.left
+    }
+    const node = stack.pop()
+    Tree = node.right
+  }
+  return res
+}
+
+const data = require('./generateBTree')
+
+const res = preOrderTranversal2(data)
+
+console.log(res)

ByteDance/curry.js

@@ -1,25 +1,13 @@
-function curry(fn) {
-    var argArr = Array.prototype.slice.call(arguments, 1); // curry的第二个参数以及后面的参数，初始值通常情况下是[]
-    var len = fn.length; // 待柯里化函数的参数个数
-    return function () { 
-        // 获得本轮递归执行的函数的参数
-        var innerArgs = Array.prototype.slice.call(arguments); 
-        // 将上一轮递归的参数与本轮递归的参数进行合并
-        // 注意： argArr 里面缓存了上一轮递归执行参数合并后的结果
-        argArr = argArr.concat(innerArgs); 
-        if (argArr.length === len) { 
-            // 如果最终合并后的参数个数，与被柯里化的函数的参数个数相同
-            // 那么将合并后的参数作为被柯里化函数的参数，执行
-            // 相当于提取所有的参数，然后拿到原函数里面去执行
-            var result = fn.apply(null, argArr);
-            // 到这里就执行完成了
-            argArr = [];
-            return result;
+function curry(fn, args) {
+    args = args || []
+    const length = fn.length
+    return function() {
+        const curArgs = Array.prototype.slice.call(arguments, 0)
+        const newArgs = args.concat(curArgs)
+        if (newArgs.length === length) {
+            return fn.apply(this, newArgs)
         } else {
-            // 返回正在执行的函数，也就是函数自身，相当于递归
-            // 但是递归层数是动态的
-            // 这里会把本轮递归的参数通过 argArr 带到下一轮递归中
-            return arguments.callee;
+            return curry(fn, newArgs)
         }
     }
 }

linked-list/delete-duplicates.js

@@ -0,0 +1,16 @@
+
+
+function deleteDuplicates(head) {
+  let cur = head
+  while (cur) {
+    while (cur.next && cur.val === cur.next.val) {
+      cur.next = cur.next.next
+    }
+    cur = cur.next
+  }
+  return head
+}
+
+const { generateLinkList, outputLinkList } = require('./generateLinkList')
+
+console.log(outputLinkList(deleteDuplicates(generateLinkList([1, 1, 2, 3, 3, 3, 4, 4, 5]))))

linked-list/generateLinkList.js

@@ -0,0 +1,25 @@
+function generateLinkList(arr = []) {
+  let head = {}
+  const res = head
+  for (let index = 0; index < arr.length; index++) {
+    const cur = arr[index]
+    head.val = cur
+    head.next = index === arr.length - 1 ? null : {}
+    head = head.next
+  }
+  return res
+}
+
+function outputLinkList(head) {
+  const res = []
+  while (head) {
+    res.push(head.val)
+    head = head.next
+  }
+  return res
+}
+
+module.exports = {
+  outputLinkList,
+  generateLinkList
+}

linked-list/remove-linked-list-elements.js

@@ -0,0 +1,28 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+ function removeElements(head, val) {
+  let cur = { val: null, next: head }
+  let result = cur
+  let pre = cur
+  cur = cur.next
+  while(cur) {
+      if (cur.val === val) {
+          pre.next = cur.next
+          cur = pre.next
+      } else {
+          pre = pre.next
+          cur = cur.next
+      }
+  }
+  return result.next
+};

linked-list/reverse-list.js

@@ -0,0 +1,16 @@
+
+function reverseList(head) {
+  let cur = head
+  let res = null
+  while (cur) {
+    const next = cur.next
+    cur.next = res
+    res = cur
+    cur = next
+  }
+  return res
+}
+
+const { generateLinkList, outputLinkList } = require('./generateLinkList')
+
+console.log(outputLinkList(reverseList(generateLinkList([1,2,3,4,5]))))