js的数组排序算法及查找字符串中出现次数最多的字符算法

数组排序

• 冒泡排序（Bubble Sort）

要点：双层循环，依次比较相邻的两个值，如果后面的比前面的小，则将小的元素排到前面。内层循环次数为：最大值 – 1 – 当前的外层循环，因为前面值已经是最小值，无须重复比较。

function bubbleSort(arr) {
  const len = arr.length;

  for (let i = 0; i < len; i++) {
    for (let j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) { // 相邻两个元素对比
        const temp = arr[j + 1]; // 元素交换

        arr[j + 1] = arr[j];
        arr[j] = temp;
      }
    }
  }

  return arr;
}

console.log(bubbleSort([1, 5, 2, 5, 6, 8, 2, 9, 1, 2, 3]));

• 选择排序（Selection Sort）

要点：双层循环，内循环找到最小值的索引，在外层循环交换值

function selectionSort(arr) {
  const len = arr.length;
  let minIndex, temp;

  for (let i = 0; i < len - 1; i++) {
    minIndex = i;

    for (let j = i + 1; j < len; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }

    temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }

  return arr;
}

console.log(selectionSort([1, 5, 2, 5, 6, 8, 2, 9, 1, 2, 3]));

• 插入排序（Insertion Sort）

function insertionSort(arr) {
  const len = arr.length;
  let preIndex, current;

  for (let i = 1; i < len; i++) {
    preIndex = i - 1;
    current = arr[i];

    while (preIndex >= 0 && arr[preIndex] > current) {
      arr[preIndex + 1] = arr[preIndex];
      preIndex--;
    }

    arr[preIndex + 1] = current;
  }

  return arr;
}

console.log(insertionSort([1, 5, 2, 5, 6, 8, 2, 9, 1, 2, 3]));

查找字符串中出现次数最多的字符

• 用对象

const str = 'wfeuh@ufjdkncpskskunfljsefhfeslshlnnb,xmnznzhzissksk';
const obj = {};

// 先遍历出所有字符出现次数
for (let i = 0, len = str.length; i < len; i++) {
  const char = str.charAt(i);

  if (obj[char]) {
    obj[char]++;
  } else {
    obj[char] = 1;
  }
}

// 字符串出现次数集
console.log(obj);
// 出现次数最多的
let maxCount = 0;
let maxKey = ''
for (const key in obj) {
  if (maxCount < obj[key]) {
    maxKey = key;
    maxCount = obj[key];
  }
}
console.log(maxKey, maxCount)

• reduce

const str = 'wfeuh@ufjdkncpskskunfljsefhfeslshlnnb,xmnznzhzissksk';
const strArr = str.split('');
const obj = strArr.reduce(function(prev, next) {
  if (next in prev) {
    prev[next]++;
  } else {
    prev[next] = 1;
  }

  return prev;
}, {})

// 字符串出现次数集
console.log(obj)
// 出现次数最多的
let maxCount = 0;
let maxKey = ''
for (const key in obj) {
  if (maxCount < obj[key]) {
    maxKey = key;
    maxCount = obj[key];
  }
}
console.log(maxKey, maxCount)

• 正则

const str = 'wfeuh@ufjdkncpskskunfljsefhfeslshlnnb,xmnznzhzissksk';
const maxCountStr = (str) => {
  // 转成数组，再排序，这样同样字符的集中在一起，再转成字符串
  const newStr = str.split('').sort().join('');
  // 正则按同样字符匹配拆成数组
  const strArr = newStr.match(/(\w+)(\1)/g);

  // 当没有重复的就返加第一个字符
  if (strArr === null) {
    return newStr[0];
  }
  
  // 倒序排序
  outStrArr = strArr.sort((a, b) => b.length - a.length);
  // 输出最大的，数组第一个
  return { key: outStrArr[0][0], count: outStrArr[0].length }
}
console.log(maxCountStr(str))