js常见的几种简单算法

1、二分查找
二分查找又称折半查找，只适用于有序数组。二分查找原理很简单，针对有序数组的查找效率也很高。
具体原理为，每次拿目标数值（以下用value表示）与数组中间位置的数据（以下用arry[mid]表示，
mid表示数组中间位置索引值）进行比较，如果value大于arry[mid]，继续将value与大于arry[mid]部分的中间位置的值进行比较；
如果value小于arry[mid]，继续将value与小于arry[mid]部分的中间位置值进行比较

// javaScript 的二分查找算法
    var Arr = [3, 5, 6, 7, 9, 12, 15];
    function binary(find, arr, low, high) {
        if (low <= high) {
            if (arr[low] == find) {
                return low;
            }
            if (arr[high] == find) {
                return high;
            }
            var mid = Math.ceil((high + low) / 2);
            if (arr[mid] == find) {
                return mid;
            } else if (arr[mid] > find) {
                return binary(find, arr, low, mid - 1);
            } else {
                return binary(find, arr, mid + 1, high);
            }
        }
        return -1;
    }
    console.log("二分查找"+binary(15, Arr, 0, Arr.length - 1));

2、冒泡
<1>.比较相邻的元素。如果第一个比第二个大，就交换它们两个；
<2>.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
<3>.针对所有的元素重复以上的步骤，除了最后一个；
<4>.重复步骤1~3，直到排序完成。

    // 改进冒泡排序： 设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。
    // 由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。
    function bubbleSort2(arr) {
        console.time('改进后冒泡排序耗时');
        var i = arr.length-1;  //初始时,最后位置保持不变
        while ( i> 0) {
            var pos= 0; //每趟开始时,无记录交换
            for (var j= 0; j< i; j++){
                if (arr[j]> arr[j+1]) {
                    pos= j; //记录交换的位置
                    var tmp = arr[j]; arr[j]=arr[j+1];arr[j+1]=tmp;
                }
            }
            i= pos; //为下一趟排序作准备
         }
         console.timeEnd('改进后冒泡排序耗时');
         return arr;
    }
    var arr=[3,44,38,5,26,27,2,46,4,19,50];
    console.log(bubbleSort2(arr));

3、选择
它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
<1>.初始状态：无序区为R[1…n]，有序区为空；
<2>.第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
<3>.n-1趟结束，数组有序化了。

    // 选择排序
    function selectionSort(arr) {
        var len = arr.length;
        var minIndex, temp;
        console.time('选择排序耗时');
        for (var i = 0; i < len - 1; i++) {
            minIndex = i;
            for (var j = i + 1; j < len; j++) {
                if (arr[j] < arr[minIndex]) {     //寻找最小的数
                    minIndex = j;                 //将最小数的索引保存
                }
            }
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        console.timeEnd('选择排序耗时');
        return arr;
    }
    var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
    console.log(selectionSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

4、插入
<1>.从第一个元素开始，该元素可以认为已经被排序；
<2>.取出下一个元素，在已经排序的元素序列中从后向前扫描；
<3>.如果该元素（已排序）大于新元素，将该元素移到下一位置；
<4>.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
<5>.将新元素插入到该位置后；
<6>.重复步骤2~5。

    // 插入排序
    function insertionSort(array) {
        console.log(Object.prototype.toString.call(array))
        if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {
            console.time('插入排序耗时：');
            for (var i = 1; i < array.length; i++) {
                var key = array[i];
                var j = i - 1;
                while (j >= 0 && array[j] > key) {
                    array[j + 1] = array[j];
                    j--;
                }
                array[j + 1] = key;
            }
            console.timeEnd('插入排序耗时：');
            return array;
        } else {
            return 'array is not an Array!';
        }
    }
    var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
    console.log(insertionSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

5、检查括号的有效性

const str = "()[]{}";
const isValid = (str = '') => {
   const map=new Map();
   map.set('{','}');
   map.set('(',')');
   map.set('[',']');
   const b=[];
   for(let i=0;i<str.length;i++){
      if(map.has(str.charAt(i))){
         b.push(str.charAt(i));
      } else{
         let pop=b.pop();
         if(map.get(pop)!==str.charAt(i)){
            return false;
         }
      };
   };
   return b.length===0;
};
console.log(isValid(str));

我觉得上面几种会就行了，还想多了解的话可以点击 Javascript算法