JS-7種查找算法之順序查找、二分查找、插值查找、斐波那契查找

參考鏈接 https://www.cnblogs.com/yw09041432/p/5908444.html

1.順序查找

說明：順序查找適合於存儲結構為順序存儲或鏈接存儲的線性表。

基本思想：順序查找也稱為線形查找，屬於無序查找算法。從數據結構線形表的一端開始，順序掃描，依次將掃描到的結點關鍵字與給定值k相比較，若相等則表示查找成功；若掃描結束仍沒有找到關鍵字等於k的結點，表示查找失敗。

　　復雜度分析：　

　　查找成功時的平均查找長度為：（假設每個數據元素的概率相等） ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;

　　當查找不成功時，需要n+1次比較，時間復雜度為O(n);

　　所以，順序查找的時間復雜度為O(n)。

/**
 * 
 * @param {被查找數組} arr 
 * @param {查找的關鍵值} value 
 */
function SequenceSearch(arr, value){
    for(let i = 0; i < arr.length; i++){
        if (arr[i] == value){
            return i;
        }
    }
    return - 1;
}

 

 

2.二分查找

二分查找 也為折半查找
首先要找到一個中間值，通過與中間值比較，大的放又，小的放在左邊。再在兩邊中尋找中間值，持續以上操作，直到找到所在位置為止
找不到返回false

// 遞歸
function binarySearch(data, dest, start, end){
　　　　if (start > end){ // 新增否則找不到進入死循環了
　　　　　　return false;
　　　　}
    var end = end || data.length - 1;
    var start = start || 0;
    var m = Math.floor((start + end) / 2);
    //直接命中
    if (data[m] == dest){
        return m;
    }


    if (data[m] > dest){     // 放左
        end = m - 1;
        return binarySearch(data, dest, start, end);
    }else{         // 放右
        start = m + 1;
        return binarySearch(data, dest, start, end);
    }
    return false;
}

// 非遞歸 用while
//代碼中的判斷條件必須是while (left <= right)，
//否則的話判斷條件不完整，比如：array[3] = {1, 3, 5};
//待查找的鍵為5，此時在(low < high)條件下就會找不到，因為low和high相等時，指向元素5，但是此時條件不成立，沒有進入while()中

function binarySearch2(data, dest){
    var end = data.length - 1;
    var start = 0;
    while(start <= end){
        var m = Math.floor((end + 1) / 2);
        if(data[m] == dest){
            return m;
        }
        if (data[m] > dest){
            end = m - 1;
        }else{
            start = m + 1;
        }
    }
    return false
}

 

3. 插值查找

將二分查找的點改進為 mid=low+(key-a[low])/(a[high]-a[low])*(high-low)

基本思想：基於二分查找算法，將查找點的選擇改進為自適應選擇，可以提高查找效率。當然，差值查找也屬於有序查找。

　　注：對於表長較大，而關鍵字分布又比較均勻的查找表來說，插值查找算法的平均性能比折半查找要好的多。反之，數組中如果分布非常不均勻，那么插值查找未必是很合適的選擇。

　　復雜度分析：查找成功或者失敗的時間復雜度均為O(log2(log2n))。

function InsertionSearch(arr, val, start, end){
    var end = end || data.length - 1;
    var start = start || 0;

    var mid = start + (val - arr[low]) / (arr[end] - arr[start]) * (end - start);
    if(arr[mid] == val){
        return mid;
    }

    if(arr[mid] > val){
        return InsertionSearch(arr, val, start, mid - 1);
    }
    else{
        return InsertionSearch(arr, val, mid + 1, end);
    }
}

 

4. 斐波那契查找

斐波那契數列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89…….（從第三個數開始，后邊每一個數都是前兩個數的和）

// 斐波那契數組的實現
function getNum1(index){
    if (index == 1 || index == 2){
        return 1;
    }else{
        return getNum(index - 1) + getNum(index - 2);
    }
}

function getNum2(index){
    if (index == 1 || index == 2){
        return 1;
    }else{
        var one = 1; 
        var two = 1;
        for (var i = 3; i <= index; i++)
        {
            if (i == 3)
            {
                one = 1;
                two = 1;
            }
            else
            {
                var temp = one;
                one = two;
                two = temp + two;
            }
        }
        return one + two
    }
}

function getNum3(index)
{
    var F = [];
    F[0]=0;
    F[1]=1;
    for(var i=2; i < index - 1; i++){
        F[i]=F[i-1]+F[i-2];
    }
    return F[index];
}

 

顧名思義，該查找方法利用了斐波那契數列

該方法的主要思路為，先在斐波那契數列F中找到第k項，使其滿足，F[k]-1 > 有序數組的最大索引號 > F[k-1]-1，然后將數組擴充到長度為F[K]-1，並使擴充項的值都等於有序數組的最后一項。

分割點的索引為mid = low + F[K-1]-1，此時有序數組被mid划分為兩段，左段長度為F[K-1]-1，右段長度為F[k-2]-1。

若查找值大於mid值，則low等於mid+1，而k = k - 2；若查找值小於mid，則high = mid -1，k =k -1.

function search(array, value){
    let low = 0, high = array.length - 1, n = array.length - 1;
    let mid, k = 0;

    // 構建一個長度大於array數組的斐波那契數組
    var F = [];
    F[0]=0;
    F[1]=1;
    for(var i=2; i < high + 5; i++){
        F[i]=F[i-1]+F[i-2];
    }

    while(high > F[k] - 1){ //尋找第k項
        k++;
    }

    for (let i=high; i<F[k]-1; i++){   //補全有序數組
        array[i] = array[high];
    }

    while (low <= high){
        mid = low + F[k - 1] - 1;
        if (array[mid] > value){
            high = mid - 1;
            k = k - 1; //長度縮減為 F[k-1] -1
        }else if(array[mid] < value)
        {
            low = mid + 1;
            k =  k - 2;         //長度縮減為 F[k-2] -1
        }else{
            if (mid <= n)  //相等則找到位置
                return mid;
            else           //大於原始長度，則說明等於數組最后一項
                return n;
        }
    }
    return -1;
}