研发工程师面经——常见查找算法

1. 查找算法

1.1 顺序查找

1.1.1 简单顺序查找

• 最简单的查询算法，只需要一个个对比就可以了

public static int sequentialSearch(int[] nums,int key){
    for(int i=0;i<nums.length;i++){
        if(nums[i]==key){
            return i;
        }
    }
    return -1;
}

1.1.2 哨兵顺序查找

• 一种基于哨兵的顺序查找：
  • 首先对比数组的最后一位是否于要进行查找的数字相等，如果相等则直接返回，否则，要查找的数字代替最后一位；
  • 然后进行一位位查找，直到最后nums[i]==key；
  • 最后进行对比返回。
• 这样的好处就是，不需要考虑会越界。

public static int sentrySequentialSearch(int[] nums,int key){
        int index=nums.length-1;
        if(nums[index]==key){
            return index;
        }
        nums[index]=key;
        int i=0;
        while(nums[i++]!=key);
        return i==index+1?-1:i-1;
}

1.2 二分查找

1.2.1 基础二分查找

• 二分查找也是一种比较常见的查找方式。不过查找前提是这个数组已经是有序排列了。这种方法的时间复杂程度为O(logN)
  • 首先是将要查找的值与中间值进行比较，然后慢慢缩小，直至找到或者产生越界返回-1.
• 非递归实现

public static int BinarySearch(int[] nums,int key){
       int left=0;
       int right=nums.length-1;
       while(left>=right){
           // 表示的就是（left+right)/2的效果
           // 不要直接使用（left+right）>>1,可能会导致溢出
           int middle=left+((right-left)>>1);
           if(key==nums[middle]){
               return middle;
           }else if(key>nums[middle]){
               left=middle+1;
           }else{
               right=middle-1;
           }
       }
       return -1;
   }

• 递归实现

public static int BinarySearchRecursion(int[] nums,int key){
    return searchMy(nums,0,nums.length-1,key);
}

public static int searchMy(int[] nums,int left,int right,int key){
    if(left>right)
        return -1;
    int middle=left+((right-left)>>1);
    if(key==nums[middle]){
        return middle;
    }else if(key>nums[middle]){
        return searchMy(nums,middle+1,right,key);
    }else{
        return searchMy(nums,left,middle-1,key);
    }
}

1.2.2 差值二分查找

• 为了能更快的进行查找，在二分的基础上进行改进。根据差值的大小确定上下限。
• 非递归实现

public static int DifferenceSearch(int[] nums,int key){
    int left=0;
    int right=nums.length-1;
    while(left>=right){
        int middle=left+(key-nums[left])/(nums[right]-nums[left])*(right-left);
        if(key==nums[middle]){
            return middle;
        }else if(key>nums[middle]){
            left=middle+1;
        }else{
            right=middle-1;
        }
    }
    return -1;
}

• 递归实现

public static int DifferenceSearchRecursion(int[] nums,int key){
    return searchMy(nums,0,nums.length-1,key);
}

public static int searchMy(int[] nums,int left,int right,int key){
    if(left>right)
        return -1;
    int middle=left+(key-nums[left])/(nums[right]-nums[left])*(right-left);
    if(key==nums[middle]){
        return middle;
    }else if(key>nums[middle]){
        return searchMy(nums,middle+1,right,key);
    }else{
        return searchMy(nums,left,middle-1,key);
    }
}

1.3 分块查找

• 分块查找是折半查找和顺序查找的一种改进方法，分块查找由于只要求索引表是有序的，对块内节点没有排序要求，因此特别适合于节点动态变化的情况。分块查找要求把一个数据分为若干块，每一块里面的元素可以是无序的，但是块与块之间的元素需要是有序的。即第1块中任一元素的关键字都必须小于第2块中任一元素的关键字；而第2块中任一元素又都必须小于第3块中的任一元素，……。

public static int BlockSearch(int[] index,int[] array,int key,int m){
    int i=Search(index,key);
    if(i<0){
        return -1;
    }
    for(int j=i*m;j<(i+1)*m;j++){
        if(array[j]==key)
            return j;
    }
    return -1;
}

public static int Search(int[] nums,int key){
    int left=0;
    int right=nums.length-1;
    if(key>nums[right]){
        return -1;
    }
    while(left>=right){
        // 表示的就是（left+right)/2的效果
        // 不要直接使用（left+right）>>1,可能会导致溢出
        int middle=left+((right-left)>>1);
        if(key==nums[middle]){
            return middle;
        }else if(key>nums[middle]){
            left=middle+1;
        }else{
            right=middle-1;
        }
    }
    return left;
}