前端算法题，字节美团算法题(持续更新中)

1、二维数组扁平化处理：[[1,3],[5,6]]

function flattenArray(arr) {
  return [].concat(...arr);
}

2、多维数组扁平化处理：[[1, 3], 2, [5, 6], [7, [8, 9, 10, [11, 12]]]]

//方法一
function flattenArray1(arr = []) {
  while (
    arr.some((item) => Object.prototype.toString.call(item) == "[object Array]")
  ) {
    arr = [].concat(...arr);
  }
  return arr;
}
//方法二
function flattenArray2(arr) {
  return arr
    .toString()
    .split(",")
    .map((item) => Number(item));
}
//方法三
function flatten(arr) {
  return [].concat(
    ...arr.map((item) =>
      Object.prototype.toString.call(item) == "[object Array]"
        ? flatten(item)
        : item
    )
  );
}

3、算法排序：[1, 3, 2, 7, 5, 10, 6, 8, 16];

//冒泡排序
function sort(arr) {
  let len = arr.length;
  for (let i = 0; i < len - 1; i++) {
    for (let j = 0; j < len - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        let temp = arr[j + 1];
        arr[j + 1] = arr[j];
        arr[j] = temp;
      }
    }
  }

  return arr;
}
//希尔排序
function shellSort(arr) {
  var len = arr.length,
    temp,
    gap = 1;
  while (gap < len / 3) {
    // 动态定义间隔序列
    gap = gap * 3 + 1;
  }
  for (gap; gap > 0; gap = Math.floor(gap / 3)) {
    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;
    }
  }

  return arr;
}
//快速排序1
function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  var pivotIndex = Math.floor(arr.length / 2); //基准位置（理论上可任意选取）
  var pivot = arr[pivotIndex]; //基准数
  var left = [];
  var right = [];
  for (var i = 0; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else if (arr[i] > pivot) {
      right.push(arr[i]);
    }
  }
  return quickSort(left).concat([pivot],quickSort(right)); //链接左数组、基准数构成的数组、右数组
}
//快速排序2
function quickSort2(arr) {
  let middleIndex = Math.floor(arr.length / 2);
  let middleItem = arr[middleIndex];
  let left = arr.filter((item) => item < middleItem);
  let right = arr.filter((item) => item > middleItem);
  return [...quickSort(left), middleItem, ...quickSort(right)];
}
//插入排序
const insertSort = (arr) => {
  for (let i in arr) {
    while (i > 0 && arr[i] < arr[i - 1]) {
      [arr[i], arr[i - 1]] = [arr[i - 1], arr[i]];
      i--;
    }
  }
  return arr;
};

4、柯里化实现fn(1)(2)(3)(4)(n)求和

/**方法一*/
function curry() {
  let arr = [...arguments];
  let fn = function () {
    if (arguments.length == 0) {
      return arr.reduce((a, b) => a + b);
    } else {
      arr = arr.concat(...arguments);
      return fn;
    }
  };
  return fn;
}
console.log(curry(1)(2)(3)(4)(5)(9)()); //24

/**方法二*/
function curry1(a) {
  function sum(b) {
    a = b ? b + a : a;
    return sum;
  }
  sum.toString = function () {
    return a;
  };
  return sum;
}
console.log(curry1(1)(2)(3)(4).toString());//10

5、计算字符串中出现的第一个不重复的字符，有则返回索引，无则返回-1

例如：‘google’ 返回4，'aaa’返回-1，'aaaaeec’返回6

const str = "google";

function fn(str) {
  str = str.split("");
  let map = [];
  for (i in str) {
    if (map.filter((item) => item.key == str[i])[0]) {
      map = map.map((it) => {
        if (it.key == str[i]) {
          it.val++;
        }
        return it;
      });
    } else {
      map.push({
        key: str[i],
        val: 1,
      });
    }
  }
    const first =
    map.filter((item) => {
      return item.val == 1;
    })?.[0]?.key || "";
  return first ? str.indexOf(first) : -1;
}
console.log(fn(str));//4

原理： 先将字符串转成数组，利用对象统计每个字符的key值跟在字符串中出现的次数，过滤获得只出现一次的并取第一个字符，通过indexof返回索引

6、数组去重

let a = [1, 2, 1, 3, 4, 6, 4, 5, 6];

let arr = [];
function fn(a) {
  for (i in a) {
    let item = a[i];
    if (arr.indexOf(item) == -1) {
      arr = arr.concat(item);
    }
  }
  return arr;
}
console.log(fn(a));//[1,2,3,4,6,5]

7、无规则对象展开为一层

let a = {
  a: "1",
  b: {
    c: "2",
    d: "3",
    e: {
      f: "4",
      g: {
        h: "5",
      },
    },
  },
  i: "6",
};
const Tools = {
  name: "格式化工具",
  excludeList: ["a"], //要排除的属性
  o: {},
  //展开对象
  openKeys() {
    const $Tool = this;
    let keys = arguments[0];
    return (function () {
      let keysMap = Object.keys(keys);
      for (let i in keysMap) {
        let key = keysMap[i];
        let value = keys[keysMap[i]];
        if (value instanceof Object) {
          $Tool.openKeys(value);
        } else {
          let obj = {
            [key]: value,
          };
          $Tool.o = Object.assign($Tool.o, obj);
        }
      }
      const exclude = (keyList) => {
        for (let i in keyList) {
          delete $Tool.o[keyList[i]];
        }
      };
      exclude($Tool.excludeList);
      return $Tool.o;
    })();
  },
};

console.log(Tools.openKeys(a));//{ c: '2', d: '3', f: '4', h: '5', i: '6' }