JS实现的常见算法

1.冒泡排序

function bubbleSort(arr) {
            var temp;                                //临时交换变量
            let n = arr.length;                      //记录数组长度
            let count=0;                             //计数，记录一共进行了多少次交换
            //document.write('数组长度为：'+n+'<br />') //输出数组成都
            for (let i=0; i<n; i++) {                //外层循环,排序出数组的arr[i]的值
                    
                let flag=0;                          //交换标志
                for (let j=n-1; j>i; j-- ) {        //内层循环，从底往上冒泡，将小泡浮到arr[i]位置
                    //alert(0);
                    if (arr[j-1]>arr[j]) {           //比较两个元素大小，并交换位置
                        temp=arr[j-1];
                        arr[j-1]=arr[j];
                        arr[j]=temp;
                        flag=flag+1;                 //确定交换标志
                        count=count+1;               //记录比较元素的次数             
                        //console.log(flag);           
                        //console.log('共交换了：'+count+'次');
                    }
                    //console.log(arr)                 //输出数组
                }
                if (flag==0) {                   //跳出循环
                    break;
                }
            }
            document.write('冒泡排序执行次数为：'+count+'<br />')
            return arr;                              //返回数组
        }

2.简单选择排序

function selectSort(arr) {
        let temp;
        let n = arr.length;
        let count =0;
        for (let i=0; i<n; i++) {
            for (let j= i+1; j<n; j++) {
                count++;
                if (arr[j]<arr[i]) {
                    temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                    
                }
            }
        }
        document.write('简单选择排序执行次数为：'+count);
        return arr;
}

3.直接插入排序

function insertSort(arr) {
        let i,j;
        let n= arr.length;
        let count = 0;
        for (i=1; i<n; i++) {
            if (arr[i]<arr[i-1]) {
                arr[-1] = arr[i];                  //将i位置的值给哨兵          
                for (j=i-1; arr[j]>arr[-1];j--) {  //当i位置前面的值比哨兵小，后移i位置的值，并插入哨兵到原先i位置
                    arr[j+1] = arr[j];
                    arr[j] = arr[-1];
                    count++;
                }
            }
        }
    document.write('直接插入排序执行次数为：'+count);
    return arr;
}

4.希尔排序

function shellSort(arr) {
     let d = arr.length;
     let i;
     let temp; //暂存
     do {
        //设置增量
       d = Math.floor(d / 3) + 1;
       for (i = d ; i < arr.length; i++) {
         if (arr[i] < arr[i - d]) {
           temp = arr[i];
           for (var j = i - d; j >= 0 && temp < arr[j]; j -=d) {
               arr[j + d] = arr[j];
               arr[j] = temp;
           }
         }
       }
     }
     while (d > 1)
     return arr;
    }

5.去重算法

function unique(arr) {
            let brr=[];
            for (let i=0; i<arr.length; i++) {
                if (brr.indexOf(arr[i]) < 0) {
                    brr.push(arr[i]);
                }
            }
            return brr;
        }

6.快速排序

function partition(arr,low,high) {
        let temp=arr[low],   //基准值
            changetemp;      //用于交换的临时变量
        while (low<high) {   
            while (low<high && arr[high]>=temp) {  
                high--;
            }               //当从high往前扫时，大于基准值时，high--
            //swap(arr, low, high);   //当从high往前扫时，小于基准值时，交换基准值和arr[high]位置
            changetemp=arr[low];
            arr[low]=arr[high];
            arr[high]=changetemp;
            while(low<high && arr[low]<=temp) {
                low++;
            }               //当从low往后扫时，小于基准值时，low++
            //swap(arr, low, high);  //当从low往后扫时，大于基准值时，交换基准值和arr[low]的位置
            changetemp=arr[low];
            arr[low]=arr[high];
            arr[high]=changetemp;

        }
        return low;
    }
    //快速排序
    function quick(arr,low,high) {
        let pivot;                 //定义枢轴值
        if (low < high) {
            pivot = partition(arr,low,high);    //求得第一个基准值第一次排序完的位置作为枢轴值
            quick(arr,low,pivot-1);             //对枢轴值前面的序列排序
            document.write(pivot+'<br />');
            quick(arr, pivot+1, high);          //对枢轴值后面的序列排序   
        }
        //return pivot;                        //返回枢轴值
        return arr;                            //返回排序后的数组
    }