反转字符串：编写一个函数，接收一个字符串作为参数，返回反转后的字符串。

function reverseString(str) {
  return str.split('').reverse().join('');
}

查找数组中的最大/最小值：编写一个函数，接收一个数字数组作为参数，返回其中的最大值和最小值。

function findMinMax(arr) {
  return {
    max: Math.max(...arr),
    min: Math.min(...arr),
  };
}

两数之和：给定一个整数数组和一个目标值，查找数组中是否存在两个数之和等于目标值，返回这两个数的索引。

function twoSum(arr, target) {
  const hashMap = {};
  for (let i = 0; i < arr.length; i++) {
    const complement = target - arr[i];
    if (hashMap.hasOwnProperty(complement)) {
      return [hashMap[complement], i];
    }
    hashMap[arr[i]] = i;
  }
  return [];
}

合并两个有序数组：编写一个函数，接收两个有序数组作为参数，将它们合并为一个新的有序数组并返回。

function mergeSortedArrays(arr1, arr2) {
  const result = [];
  while (arr1.length && arr2.length) {
    if (arr1[0] <= arr2[0]) {
      result.push(arr1.shift());
    } else {
      result.push(arr2.shift());
    }
  }
  return result.concat(arr1, arr2);
}

斐波那契数列：编写一个函数，接收一个整数 n 作为参数，返回斐波那契数列中第 n 个数。

function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

删除数组中的重复项：编写一个函数，接收一个数组作为参数，删除其中的重复元素并返回新的数组。

function removeDuplicates(arr) {
  return [...new Set(arr)];
}

二分查找：编写一个函数，接收一个有序数组和一个目标值作为参数，使用二分查找法在数组中查找目标值并返回其索引。

function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;
  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) {
      return mid;
    } else if (arr[mid] < target) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }
  return -1;
}

回文字符串检测：编写一个函数，接收一个字符串作为参数，判断该字符串是否为回文字符串（正序和逆序相同）。

function isPalindrome(str) {
  const len = str.length;
  for (let i = 0; i < len / 2; i++) {
    if (str[i] !== str[len - 1 - i]) {
      return false;
    }
  }
  return true;
}

最长公共前缀：编写一个函数，接收一个字符串数组作为参数，返回数组中字符串的最长公共前缀。

function longestCommonPrefix(strs) {
  if (!strs.length) return '';
  let prefix = strs[0];
  for (let i = 1; i < strs.length; i++) {
    while (strs[i].indexOf(prefix) !== 0) {
      prefix = prefix.substring(0, prefix.length - 1);
      if (!prefix) return '';
    }
  }
  return prefix;
}

求两个数组的交集：编写一个函数，接收两个数组作为参数，返回这两个数组的交集。

function intersection(arr1, arr2) {
  const set1 = new Set(arr1);
  const set2 = new Set(arr2);
  return [...set1].filter((item) => set2.has(item));
}

转换树形结构数据的格式

function convertJson (json, parentValue = 'CN') {
  return json.map(item => {
    const value = `${parentValue}:${item.name}`
    return {
      label: item.name,
      value,
      children: item.children ? convertJson(item.children, value) : []
    }
  })
}

const a = [{
  'code': '11',
  'name': '北京市',
  'children': [{
    'code': '1101',
    'name': '市辖区',
    'children': [{
      'code': '110101',
      'name': '东城区',
      'children': [{
        'code': '110101001',
        'name': '东华门街道'
      }]
    }]
  }]
}]

const b = convertJson(a)
console.log(JSON.stringify(b))
// [{
//   "label": "北京市",
//   "value": "CN:北京市",
//   "children": [{
//     "label": "市辖区",
//     "value": "CN:北京市:市辖区",
//     "children": [{
//       "label": "东城区",
//       "value": "CN:北京市:市辖区:东城区",
//       "children": [{
//         "label": "东华门街道",
//         "value": "CN:北京市:市辖区:东城区:东华门街道",
//         "children": []
//       }]
//     }]
//   }]
// }]