常見排序及查找算法的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;                            //返回排序後的數組
    }

7.使用JS方法並將形參減小爲僅輸入一個數組的快排

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

        return quickSort(left).concat(pivot,quickSort(right));
    }

8.JS實現歸併排序

function mergeSort (arr) {
    //合併兩個有序數組爲一個數組
    function merge(left,right) {
        let arr=[];
        while (left.length && right.length) {
            if (left[0] < right[0]) {
                arr.push(left.shift());
            } else {
                arr.push(right.shift());
            }
        }
        return arr.concat(left,right);
    }

    let len=arr.length;
    if (len <= 1) {
        return arr;
    } else {
        let index = Math.floor(len/2),
            left = arr.slice(0,index),
            right = arr.slice(index);
        return merge(mergeSort(left),mergeSort(right));//用遞歸對數組進行拆分，再返回合併後的數組
    }
}

9.堆排序

function heapSort(array) {
    var result = array.slice(0);
    function swap(array, i, j) {
        var temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    function maxHeapify(array, index, heapSize) {
        var iMax, iLeft, iRight;
        while (true) {
          iMax = index;
          iLeft = 2 * index + 1;
          iRight = 2 * (index + 1);
          
          if (iLeft < heapSize && array[index] < array[iLeft]) {
              iMax = iLeft;
          }

          if (iRight < heapSize && array[iMax] < array[iRight]) {
              iMax = iRight;
          }

          if (iMax != index) {
              swap(array, iMax, index);
              index = iMax;
          } else {
              break;
          }
        }
    }

    function buildMaxHeap(array) {
        var i, iParent = Math.floor(array.length / 2) - 1;

        for (i = iParent; i >= 0; i--) {
            maxHeapify(array, i, array.length);
        }
    }

    function sort(array) {
        buildMaxHeap(array);

        for (var i = array.length - 1; i > 0; i--) {
            swap(array, 0, i);
            maxHeapify(array, 0, i);
        }
        return array;
    }

        return sort(result);
}

10.JS實現順序查找

function listSearch(arr,data) {
    var result;
    for (var i = 0;i<arr.length; i++) {
        if (arr[i] === data) {
            result = i;
            break;
        }
    }
    if (result === undefined) {
        result = -1;
    }
    return result
}

11.JS實現二分查找

function binarySearch(arr,key) {
    var low = 0,
        high = arr.length-1;
    while (low <= high) {
            var mid = parseInt((low+high)/2);    
            if (key < arr[mid]) {
                high = mid-1;
            } else if (key > arr[mid]) {
                low = mid+1;
            } else {
                return mid;
            }
    }
    return -1;
}

12.統計字符串中出現次數最多的字符

function count(str) {
    var obj = {},
        mostStr = "",
        key;
    for(var i = 0; i<str.length; i++) {
        if (!obj[str[i]]) {
            obj[str[i]] = 1;
        } else {
            obj[str[i]]++;
        }
    }
    for(key in obj) {
        if (mostStr === "" || obj[key] > obj[mostStr]) {
            mostStr = key
        }
    }
    return [mostStr,obj[mostStr]]
}

13.斐波拉契數列遞歸寫法

function fibonicco(n) {
    if (n ===1 || n === 2) {
        return 1;
    } else {
        return fibonicco(n-1)+fibonicco(n-2);
    }
}

14.斐波拉契數列迭代寫法

function fibonicco(n) {
    var a,b,res;
    a = b = res =1;
    for (var i =3; i<=n; i++) {
        res = a+b;
        a = b;
        b = res;
    }
    return res;
}