js查找—顺序表和有序表的

/*
    1. 顺序表查找
 */
/* 一般方法。 */
function search0(arr,data) {
    for(var i=0,len=arr.length;i<len;i++){
        if(data===arr[i]){
            return i;
        }
    }
    return -1;
}

console.log(search0([1,2,3,4],3)); // 2
/* 设置哨兵的方法，旨在消除一般方法中每次都要判断下标是否越界的开销。 */
function search1(arr,data) {
    var n=arr.length-1;
    // js数组越界时的值为undefined，与要找的值也是不相等的，可能会导致无线循环下去！
    // 所以也需要arr[n]!==undefined来判断是否越界，这样的话，与上面的一般方法似乎差别不大
    while (arr[n]!==undefined&&arr[n]!==data){
        n--;
    }
    return n;
}

console.log(search1([1,2,0,4],2)); // 1

/* forEach的方法，可以找到所有的目标元素的下标 */
function search2(arr,data) { //返回值为data的元素的下标
    var sub=[];
    arr.forEach(function (item,index) {
        if(item===data){sub.push(index);}
    });
    return sub;
}
console.log(search2([1,2,3,4,2],2)); // [ 1, 4 ]

/*
    2. 有序表查找
 */
/* 二分查找，时间复杂度O(logn) */
function binSearch(arr,data) {
    var low=0,
        high=arr.length-1,
        mid;
    while (low<=high){
        mid=Math.floor((low+high)/2);
        if(arr[mid]<data){
            low=mid+1;
        }else if(arr[mid]>data){
            high=mid-1;
        }else{
            return mid;
        }
    }

    return -1;
}

var b=[2,6,9,14,46,67,99];
console.log(binSearch(b,67)); //5

/* 插值查找，时间复杂度O(logn) ,不适合数据分布极端不均匀的情况（[0,1,2,2000,2001,...,99998,99999]）*/
/*
    原理：由二分查找，有mid=(low+high)/2=low+1/2*(high-low),将1/2用(data-arr[low])/(arr[high]-arr[low])来替换
 */
function interpSearch(arr,data) {
    var low=0,
        high=arr.length-1,
        mid;
    while (low<=high){
        //mid=Math.floor((low+high)/2);
        mid=Math.floor( low+(high-low)*((data-arr[low])/(arr[high]-arr[low])) );
        if(arr[mid]<data){
            low=mid+1;
        }else if(arr[mid]>data){
            high=mid-1;
        }else{
            return mid;
        }
    }

    return -1;
}
var c=[2,6,9,14,46,67]; 
console.log(interpSearch(c,2)); // 0