算法训练（一）

1. 两数之和（最优解理由哈希表遍历）

**题目**：在数组中找到两数之和等于目标值。  
**输入**：`nums = [2,7,11,15], target = 9`  
**输出**：`[0,1]`

function twoSum(nums, target) {
  const sumArr = new Map()
  for (let i = 0; i <= nums.length; i++) {
    const complment = target - nums[i]
    if(sumArr.has(complment)) {
      retun [sumArr.get(complment), i]
    }
    sumArr.set(nums[i], i)
  }
  return []
}

2. 反转字符串（采用reverse解法，也可用for循环）

**题目**：反转字符串。  
**输入**：`"Hello, World!"`  
**输出**：`"!dlroW ,olleH"`

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

3. 判断回文字符串

自己第一反应的解法

**题目**：判断字符串正反读是否一致。  
**输入**：`"level"`  
**输出**：`true`
function isPalindrome(str) {
    const lowerCaseStr = str.toLowerCase();
    return lowerCaseStr === lowerCaseStr.split('').reverse().join('');
}

最优解是利用双指针法

function isPalindrome(str) {
  const lowerCaseStr = str.toLowerCase();
  let left = 0;
  let right = lowerCaseStr.length - 1;
  while(left < right) {
    if (lowerCaseStr[left] !== lowerCaseStr[right]) {
        return false
       }
   left++
   right--
 }
 return true
}

4.数组去重

new Set方法 ES6方法 缺点：旧版浏览器可能会不兼容

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

for 循环 配合 indexOf 方法

优点：兼容性好，在旧版浏览器中也能正常使用。
缺点：时间复杂度较高，为 ，因为 indexOf 方法在查找元素时需要遍历数组。

function forUnique(arr) {
  const uniqueArr = []
  for (let i = 0; i < arr.length; i++) {
    if(uniqueArr.indexOf(arr[i]) === -1) {
      uniqueArr.push(arr[i])
    }
  }
  return uniqueArr
}

5.返回字符串中出现最多次的字符

function maxChar(str) {
  const charMap = {} // map数组
  let maxChar = "" // 出现次数最多的字符
  let maxCount = 0 // 出现次数最多的字符的次数
  for (let char of str) {
    charMap[char] = (charMap[char] || 0) + 1;
    if (charMap[char] > maxCount) {
      maxChar = char
      maxCount =charMap[char]
    }
  }
  return maxChar
}

6.快速排序

// 快速排序
function quickSort(arr) {
  // 终止条件：如果数组个数小于等于1，则直接返回
  if (arr.length <= 1) return arr
  // 选择基准点
  const pivot = arr[0]
  // 定义数组
  const left = []
  const right = []
  // 遍历数组
  for (let i = 1; i < arr.length; i++) {
    pivot > arr[i] ? left.push(arr[i]) : right.push(arr[i])
  }
  // 递归调用
  return [...quickSort(left), pivot, ...quickSort(right)]
}