读者六轮面试，终与字节无缘（详细面经）

    有这么一个数据结构:

    const data = [
      {
        "id": "1",
        "sub": [
          {
            "id": "2",
            "sub": [
              {
                "id": "3",
                "sub": null
              },
              {
                "id": "4",
                "sub": [
                  {
                    "id": "6",
                    "sub": null
                  }
                ]
              },
              {
                "id": "5",
                "sub": null
              }
            ]
          }
        ]
      },
      {
        "id": "7",
        "sub": [
          {
            "id": "8",
            "sub": [
              {
                "id": "9",
                "sub": null
              }
            ]
          }
        ]
      },
      {
        "id": "10",
        "sub": null
      }
    ]
    现在给定一个id，要求实现一个函数

    findPath(data, id) {

    }
    返回给定id在 data 里的路径
    示例:

    id = "1" => ["1"]
    id = "9" => ["7", "8", "9"]
    id = "100"=> []
    PS: id 全局唯一，无序

     async function async1() {
         console.log('async1 start');
         await async2(); 
         console.log('async1 end');
     }
     async function async2() {
         console.log('async2');
         // 注意：这里如果返回 Promise 的话执行顺序就不一样了
     }
     console.log('script start');
     setTimeout(function() {
         console.log('setTimeout');
     }, 0)
     async1();
     new Promise(function(resolve) {
         console.log('promise1');
         resolve();
     }).then(function() {
         console.log('promise2');
     });
     console.log('script end');

// 当时用的 js，用 ts 只是为了表达的更清晰一点
interface Barrage {
  time: Number;
  barrage: String;
}
const binarySearch = (arr: Barrage[], time: number) => {
  let l = 0;
  let r = arr.length - 1;
  while (l <= r) {
    const mid = (l + r) / 2;
    if (arr[mid].time === time) {
      return arr[mid].barrage;
    } else if (arr[mid].time < time) {
      l = mid + 1;
    } else {
      r = mid - 1;
    }
  }
  return null;
}

// 这除出来可有可能是个分数啊
const mid = (l + r) / 2; // Math.floor((l + r) / 2);
// l + r 也可能超出数字范围
const mid = l + Math.floor((r - l) / 2);

let str = "ABCDABA"
let l = 0;
let r = str.length - 1;

const reverse = (str) => {
    let temp = '';
    for(let i = 0; i < str.length; i++) {
        temp += str[i];
    }
    return temp === str;
} 
const isSymmetry = (str) => {
    let l = 0;
    let r = str.legnth - 1;
    while(l <= r) {
        if(str[l] === str[r]) {
            l++;
            r--;
        } else {
            if(!reverse(str.substring(l, r)) && !reverse(str.substring(l + 1, r + 1))) {
                return false;
            }
        
        }
    }
    return true;
}

const isSymmetry = (str, flag = false) => {
    let l = 0;
    let r = str.length - 1;
    while (l <= r) {
        if (str[l] === str[r]) {
            l++;
            r--;
        } else {
            if (flag) {
                return false;
            }
            if (
                !isSymmetry(str.substring(l, r), true) &&
                !isSymmetry(str.substring(l + 1, r + 1), true)
            ) {
                return false;
            }
            return true;
        }
    }
    return true;
};

let str = "https://juejin.cn?name=zhangsan&age=18&id=123";
function getUrlParams = ()=> {
let obj = {};
for (let i = 0; i < splitStr.length; i++) {
  let temp = splitStr[i].split("=");
  obj[temp[0]] = temp[1];
}
return obj;
}
console.log(obj);

const levelOrder = (root) => {
  while (root.length) {
    const temp = root.shift();
    console.log(temp.val);
    for (let i = 0; i < temp.children.length; i++) {
      root.push(temp.children[i]);
    }
  }
};

 const root = [
  {
    val: 1,
    children: [
      {
        val: 3,
        children: [],
      },
    ],
  },
  {
    val: 2,
    children: [
      {
        val: 4,
        children: [],
      },
    ],
  },
];

const twoSum = (arr, target) => {
    const obj = {};
    for(let i = 0; i < arr.length; i++) {
        if (obj[arr[i]] != null) {
            return [obj[arr[i]], i];
        } else {
            obj[target - arr[i]] = i;
        }
    }
    return [];
};

const twoSum = (arr, target) => {
    const res = [];
    for(let i = 0; i < arr.length - 1; i++) {
        for(let j = i + 1; j < arr.length; j++) {
            if(arr[i] + arr[j] === target) {
                res.push([i, j]);
            }
        }
    }
    return res;
}

twoSum([2,7,11, 7], 9);

// 打印个这个 0, 1, 0, 3

const twoSum = (arr, target) => {
    let obj = {};
    let res = [];
    for(let i = 0; i < arr.length; i++) {
        if(obj[arr[i]] != null) {
            let temp = obj[arr[i]];
             for(let j = 0; j < temp.length; j++) {
                 res.push([temp[j], i]); // res.push([temp[j], i); 当时这里少打一个 ]
             }
        } else {
            let temp = target - arr[i];
            obj[temp] = obj[temp] ? [...obj[temp], i] : [i];
        }
    }
    return res;
}

// 我当时觉得最差的情况是这个 
twoSum([2, 2, 2, 7], 9);
// n + n - 1
// 但一半一半才最差, 
twoSum([2, 2, 7, 7], 9);
// (n / 2) + (n/2) * (n/2)
// 而且我还忽略了一种情况, 这个 else 不应该加
twoSum([2, 7, 2, 7], 9);

const twoSum = (arr, target) => {
    let obj = {};
    let res = [];
    for(let i = 0; i < arr.length; i++) {
        if(obj[arr[i]] != null) {
            let temp = obj[arr[i]];
             for(let j = 0; j < temp.length; j++) {
                 res.push([temp[j], i]);
             }
        }
        let temp = target - arr[i];
        // obj[temp] = obj[temp] ? [...obj[temp], i] : [i];
        // 用 push 更好一点
        obj[temp] ? obj[temp].push(i) : obj[temp] = [i];
    }
    return res;
}