conardli / awesome-coding-js Goto Github PK

这个方法不能区分1和’1‘，建议换成Map，或者key上面拼一个类型上去。

https://www.conardli.top/docs/JavaScript/%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F.html

开头的 ”在合适的时候才创建对像“ 应该是 对象 而不是对像

call的代码实现写的有漏洞,应该改为如下代码
function fn1() {
console.log(this, 1);
}
Function.prototype.myCall = function (context = window, ...args) {
if (this === Function.prototype) {
return undefined; // 用于防止 Function.prototype.myCall() 直接调用
}
context = Object(context);
const fn = Symbol();
context[fn] = this;
const result = contextfn;
delete context[fn];
return result;
}
fn1.myCall('hello')

快速排序里面的第二种写法代码里面有一处有错误。
第二行这里的
if (end - start < 2) { return; }
if里面应该是“end - start < 1”，不然的话当刚好有两个元素的话就无法去判断排序了。
比如这个数组“[23, 11, 5, 65, 7, 33, 2, 26]”，如果按照你的写法的话会输出“[ 2, 7, 5, 11, 23, 26, 33, 65 ]”，如果改成我那样的话就会正确输出“[ 2, 5, 7, 11, 23, 26, 33, 65 ]”

http://www.conardli.top/docs/dataStructure/%E6%A0%88%E5%92%8C%E9%98%9F%E5%88%97/%E6%A0%88%E5%92%8C%E9%98%9F%E5%88%97.html

当前方法实现输出不符合预期，可以用substring拼接改一下

第一层循环长度应该是length-1吧

堆的基本操作

上面链接的文档里面，关于堆的插入示例代码中。代码好像不符合语言规范。看不明白呢？

• 浅拷贝： 拷贝的是对象的指针，修改内容互相影响
• 深拷贝： 整个对象拷贝到另一个内存中，修改内容互不影响

arr.slice();
arr.concat();

文中提到这两个方法是浅拷贝，应该是深拷贝的

let arr1 = [1,2,3,4];
let arr2 = arr1.slice(0);
let arr3 = arr1.concat();
arr2[1] =6;
arr3[1] = 6;
console.log(arr1);   //  [1,2,3,4]
console.log(arr2);  //  [1,6,3,4]
console.log(arr3);  // [1,6,3,4]

我感觉js并不是一个有序的数据结构，而且你用for in循环并不能保证‘第一次出现’这个条件

var inorderTraversal = function (root, array = []) {
if (root) {
inorderTraversal(root.left, array);
array.push(root.val);
inorderTraversal(root.right, array);
}
return array;
};
console.log(inorderTraversal([1,null,2,3]))
打印[undefined]

https://github.com/ConardLi/awesome-coding-js/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%88%86%E7%B1%BB/%E4%BA%8C%E5%8F%89%E6%A0%91/%E9%87%8D%E5%BB%BA%E4%BA%8C%E5%8F%89%E6%A0%91.md/#%E6%B1%82%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E9%81%8D%E5%8E%86

您好，感觉字符串-正则表达式那道题的题目里第二个符号应该是'*'，而不应该是''吧？

递归算法：好像写错了，解法思路是对的，但是运行就报错，
运行环境：vscode集成leetcode插件

/*
 * @lc app=leetcode.cn id=230 lang=javascript
 *
 * [230] 二叉搜索树中第K小的元素
 */
/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} k
 * @return {number}
 */
function kthSmallest(root, k) {
    const arr = [];
    loopThrough(root, arr);
    if (k > 0 && k <= arr.length) {
      return arr[k - 1];
    }
    return null;
  }

  function loopThrough(node, arr) {
    if (node) {
      loopThrough(node.left, arr);
      arr.push(node);
      loopThrough(node.right, arr);
    }
  }

✘ Wrong Answer
  ✘ 0/91 cases passed (N/A)
  ✘ testcase: '[3,1,4,null,2]\n1'
  ✘ answer: NaN
  ✘ expected_answer: 1
  ✘ stdout:

pre = array[i]; 应该是 pre = i

function FindPathCore(node, expectNumber, stack, sum, result) {
stack.push(node.val);
sum += node.val;
if (!node.left && !node.right && sum === expectNumber) {
result.push(stack.slice(0));
}
if (node.left) {
FindPathCore(node.left, expectNumber, stack, sum, result);
}
if (node.right) {
FindPathCore(node.right, expectNumber, stack, sum, result);
}
stack.pop();
}

当stack[stack.length-1]存在并且没访问过时，stack.pop()会将右子树切断，造成结果项缺失。

选择排序的稳定性应该是 不稳定 的哈

function FirstAppearingOnce() {
let minIndex = 256;
let strIndex = 0;
for (let i = 0; i < 256; i++) {
if (container[i] >= 0 && container[i] < minIndex) {
minIndex = container[i];
strIndex = i;
}
}
return minIndex === 256 ? '#' : String.fromCharCode(strIndex);
}

container[i] >= 0时，container[i]对应字符在字符串中的下标，所以实际使用时 minIndex = [传入的字符串长度或者无穷大]。
哈哈哈，当然这里不涉及具体问题，思路正确。