JS算法

排序

冒泡排序

• 原理：

  • 1）从第一个元素开始，把当前元素与下一个元素进行比较，
  • 2）如果当前元素大于下一个元素，那么对两个元素进行位置交换，一直到最后一个元素，
  • 3）第一轮比较结束，此时最后元素即为数组中的最大值；
  • 4）之后再重复上述操作，由于此时最后一个元素已经是最大的元素，因此不需要比较最后一个元素，以此类推，直到比较结束，代码如下：

  function sort(ary){
    let len = ary.length;
    for (let i=0; i<len; i++){
      let curItem = ary[i];
      for (let j=0; j<len-1-i; j++){
        if (ary[j]>ary[j+1]){
          let temp = ary[j+1];
          ary[j+1] = ary[j];
          ary[j] = temp;
        }
      }
    }
    return ary;
  }
  

插入排序

• 原理：
  • 1）先给左手一张牌；
  • 2）拿右手的每张牌，跟左手最后一张牌进行比较，比他大，放在这张牌后一位的前面，这次比较结束；
  • 3）如果比他小，继续往左比较，如果比较完左边的每张牌；还是比他们小，插入左手所有的牌的最前面；

   function insertSort(ary){
      let tempAry = ary.splice(0, 1);
      for (let i=0; i<ary.length;i++){
        var cur = ary[i];
        for (let j=tempAry.length-1; j>=0;){
          if (cur < tempAry[j]){
            j--;
            if (j === -1){
              tempAry.unshift(cur);
            }
          }else {
            tempAry.splice(j+1, 0, cur);
            break;
          }
        }
      }
      return tempAry;
    }
  

快速排序

• 原理：
  • 1）先取出数组中间数据作为主元素，然后对数组进行循环，将比主元素小的项放于left，其它放于right，
  • 2）然后再分别对left了right数组进行上面操作
  • 3）直到分离的数组只有一项时，返回数组

  function quickSort(ary){
    if (ary.length<=1){
      return ary;
    }
    let num = Math.floor(ary.length / 2);
    let numVal = ary.splice(num, 1)[0];
    let left = [];
    let right = [];
    for (let i=0;i<ary.length;i++){
      if (ary[i]<numVal){
        left.push(ary[i]);
      }else {
        right.push(ary[i]);
      }
    }
    return [...quickSort(left), numVal, ...quickSort(right)]
  }
  

二分法搜索

• 原理：
  • 1）二分法的前提需要数组为有序数组
  • 2）将数组从中间分为两部分，取当前值与中间值做对比
  • 3）若比中间值小，则在左边进行查找
  • 4）若比中间值大，则在右边进行查找

function binarySearch(arr, item){
	 arr = quickSort(arr);
	 let low = 0;
	 let high = arr.length - 1;
	 let mid, element;
	 while(low<=high){
	   mid = Math.floor((low+high) / 2);
	   element = arr[mid];
	   if (item < element){
	     high = mid-1;
	   }else if (item > element){
	     low = mid+1;
	   }else {
	     return mid;
	   }
	 }
	 return -1;
}

斐波那契数列

• 又称黄金分割数列，指得是一个数列：0、1、2、3、5、8、13、21、34…

• 实现，使用递归获取到每一项的值

  function getfib(n){
    if (n == 0){
      return 0;
    }
    if (n == 1){
      return 1;
    }
    if (n > 1){
      return getfib(n-1)+getfib(n-2);
    }
  }
  function fibo(n){
    var fibo = [];
    for (var i=0; i<n; i++){
      fibo.push(getfib(i));
    }
    return fibo;
  }
  

查找当前字符串中连续重复最多的字符

• 1）使用正则/(\w)\1+/g匹配出连续重复的字符换，并将其放在数组
• 2）对数组的每一项进行循环找到重复最多的次数
• 3）对数组进行过滤找到重复次数最多的项，并将其放在一个数组中
• 4）将数组转为对象，并返回重复最多的字符，以及重复的次数

function getMaxCharacters(str) {
     const map = {}
     //match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。
     var arr = str.match(/(\w)\1+/g)
     var max = arr[0].length;
     arr.map(item => {
       max = Math.max(max, item.length);
     })
     const maxArr = arr.filter(item => item.length === max)
     maxArr.forEach(item => {
         map[item[0]] = item.length
     })
     return map
 }

持续更新…

参考资料
js 找出字符串中连续出现最多的字符和个数
前端常见算法(js)
前端面试算法