Algorithm:

20 有效括号

  1. var isValid = function(s) {
  2.   let r = s.split("");
  3.   let a = [];
  4.   const diction = {
  5.     '[':']',
  6.     '(':')',
  7.     '{':'}'
  8.   };
  9.   for (let i = 0; i < r.length; i++) {
  10.     if(i >= 1 && r[i] === diction[a[a.length-1]]) {
  11.       a.pop()
  12.     }else {
  13.       a.push(r[i]);
  14.     }
  15.   }
  16.   return !a.length
  17. };
  19. // 用一个 map 来维护左括号和右括号的对应关系
  20. const diction = {
  21.   "(": ")",
  22.   "[": "]",
  23.   "{": "}",
  24. };
  26. /**
  27.  * @param {string} s
  28.  * @return {boolean}
  29.  */
  30. const isValid = function (s) {
  31.   // 结合题意，空字符串无条件判断为 true
  32.   if (!s) {
  33.     return true;
  34.   }
  35.   // 初始化 stack 数组
  36.   const stack = [];
  37.   // 缓存字符串长度
  38.   const len = s.length;
  39.   // 遍历字符串
  40.   for (let i = 0; i < len; i++) {
  41.     // 缓存单个字符
  42.     const ch = s[i];
  43.     // 判断是否是左括号，这里我为了实现加速，没有用数组的 includes 方法，直接手写判断逻辑
  44.     if (ch === "(" || ch === "{" || ch === "[") stack.push(diction[ch]);
  45.     // 若不是左括号，则必须是和栈顶的左括号相配对的右括号
  46.     else {
  47.       // 若栈不为空，且栈顶的左括号没有和当前字符匹配上，那么判为无效
  48.       if (!stack.length || stack.pop() !== ch) {
  49.         return false;
  50.       }
  51.     }
  52.   }
  53.   // 若所有的括号都能配对成功，那么最后栈应该是空的
  54.   return !stack.length;
  55. };

71 简化路径

  1. var simplifyPath = function(path) {
  2.     const paths = path.split("/");
  3.     let r = [];
  4.     for (let i = 0; i <= paths.length; i++) {
  5.         if (paths[i]) {
  6.             if(paths[i] == '..') {
  7.                 r.pop();
  8.             }else if(paths[i] !== '.'){
  9.                 r.push(paths[i])
  10.             }
  11.         }
  12.     }
  13.     return "/" + r.join("/")
  14. };
  16. var simplifyPath = function(path) {
  17.     let ad = path.split("/")
  18.     let op=[]
  19.     for(let i=0;i<ad.length;i++){
  20.         if(ad[i]==""||ad[i]=="."){
  21.             continue
  22.         }
  23.         else if(ad[i]==".."){
  24.             op.pop()
  25.         }
  26.         else{
  27.             op.push(ad[i])
  28.         }
  29.     }
  30.     return '/' + op.join('/')
  31. };

有效括号和简化路径都是非常典型的栈数据结构的题目，栈的特点就是先进后出，可以理解为：吃东西然后吐出来。

1 两数之和

  1. function twoSum(nums,r) {
  2.   let map = {};
  3.   for(let i = 0; i < nums.length; i++) {
  4.     const surplus = r - nums[i];
  5.     const find = map[surplus];
  6.     if(find !== undefined) {
  7.       return [find, i];
  8.     }else{
  9.       map[nums[i]] = i;
  10.     }
  11.   }
  12. }

509 斐波那契

  1. function fib(N) {
  2.   if (N < 2) {
  3.     return N
  4.   }
  5.   return fib(N-1) + fib(N-2)
  6. }
  8. // 递推 O(n)
  9. var fib = function(N) {
  10.     let cache = [];
  11.     for(let i = 0; i <= N; i++){
  12.         if(i == 0 || i == 1) {
  13.             cache[i] = i;
  14.         }else{
  15.             cache[i] = cache[i-1] + cache[i-2]
  16.         }
  17.     }
  18.     return cache[N]
  19. };

斐波那契和两数之和的共同点都是可以通过缓存来实现。

Review: 阅读并点评一篇英文技术文章

Tips: 学习一个技术技巧

window.onload与document.ready

共同点:

表面上看都是页面加载时就去执行一个函数或动作。

区别:

  1. 执行时间
    window.onload所有资源加载完毕后才能执行。JavaScript此时才可以访问网页中的任何元素。
    $(document).ready()是DOM结构绘制完毕后就执行。此时，网页的所有元素对jQuery而言都是可以访问的，但是，这并不意味着这些元素关联的文件都已经下载完毕。
  2. 编写个数不同
    window.onload不能同时编写多个，会出现覆盖的问题。
    $(document).ready()可以同时编写多个，并且都可以得到执行。
  3. 简化写法
    window.onload没有简化写法 ；
    $(document).ready(function(){})可以简写成$(function(){});

    求交集

    a.filter(v => b.includes(v));

    非交集

    a.concat(b).filter(v => !a.includes(v) || !b.includes(v))

    JSON.stringify() 的秘密特性

    stringify 函数也可以有第二个参数[] ```javascript var product = { name: “zhangsan”, age: 18 } JSON.stringify(product,[‘name’]) // “{“name”:”zhangsan”}”

JSON.stringify(product,(key ,value)=> { if(typeof value === ‘string’) return undefined; return value }) // “{“age”:18}” ```

stringify 函数也可以有第二个参数func

Share: 分享一篇有观点和思考的技术文章

该网站为中文教程，使用通俗的语言，介绍各种设计模式，图文并茂。此外，还有代码重构方面的英语内容
该网站收集各种思考工具（比如决策树和冰山模型），这些工具可以帮助你解决问题、制定决策和理解系统。