Java数据结构与算法:查找算法

一、查找算法:

(1)顺序查找

int[] arr = {-1,34,9,11,89};
public static int seqSearch(int[]arr,int key){
    逐一比对,发现有相同的值时返回下标
    for(int i = 0;i<arr.length;i++){
        if(arr[i]==key){
            return i;
        }
    }
    return -1;
}

(2)二分查找:

待查找的数组必须是有序的

思路分析:

a.首先确定该数组的中间的下标:mid = (left+right)/2

b.让需要查找的数的findVal和arr[mid]比较

c.如果findVal大于arr[mid]，则需要递归向右查找

d.如果findVal小于arr[mid]，则需要递归向左查找

e.如果findVal等于arr[mid]，则直接返回mid

结束递归的情况:

a.找到待查找的数据

b.递归完毕整个数组仍然没有找到待查找的数据；也就是left>right

代码实现:

public static int binarySearch(int[]arr,int left,int right,int key){
    int mid = (left+right)/2;
    int midVal = arr[mid];
    if(left>right){
        return -1;
    }
    if(midVal<key){
        return binarySearch(arr,mid+1,right,key);
    }else if(midVal>key){
        return binarySearch(arr,left,mid-1,key);
    }else{
        return mid;
    }
}
当需要返回多个值时，找到mid索引值时不要马上返回
向mid索引值的左边扫描,找到待查找的数据将其索引加入到ArrayList中
向mid索引值的右边扫描,找到待查找的数据将其索引加入到ArrayList中
public static ArrayList<Integer> binarySearch(int[]arr,int left,int right,int key){
    int mid = (left+right)/2;
    int midVal = arr[mid];
    ArrayList<Integer> a = new ArrayList<>();
    if(left>right){
        return new ArrayList<Integer>();
    }
    if(midVal<key){
        return binarySearch(arr,mid+1,right,key);
    }else if(midVal>key){
        return binarySearch(arr,left,mid-1,key);
    }else{
        int temp = mid - 1;
        while(true){
            if(temp<0||arr[temp]!=key){
                break;
            }
            a.add(temp);
            temp-=1;
        }
        a.add(mid);       
        int temp = mid + 1;
        while(true){
            if(temp<0||arr[temp]!=key){
                break;
            }
            a.add(temp);
            temp+=1;
        }
    }
    return a;
}

(3)插值查找:

插值查找算法类似于二分查找，不同的是插值查找每次从自适应mid处开始查找

对于数据量比较大，关键字比较分布均匀的情况下比较实用，如果分布不均匀，则推荐使用二分查找

代码实现:

public static int insertValueSearch(int[]arr,int left,int right,int key){
    int mid = left+(right-left)*(key-arr[left])/(arr[right]-arr[left]);
    int midVal = arr[mid];
    if(left>right||key<arr[0]||key>arr[arr.length-1]){
        return -1;
    }
    if(midVal<key){
        return binarySearch(arr,mid+1,right,key);
    }else if(midVal>key){
        return binarySearch(arr,left,mid-1,key);
    }else{
        return mid;
    }
}
当需要返回多个值时，找到mid索引值时不要马上返回
向mid索引值的左边扫描,找到待查找的数据将其索引加入到ArrayList中
向mid索引值的右边扫描,找到待查找的数据将其索引加入到ArrayList中
public static ArrayList<Integer> binarySearch(int[]arr,int left,int right,int key){
    int mid = left+(right-left)*(key-arr[left])/(arr[right]-arr[left]);
    int midVal = arr[mid];
    ArrayList<Integer> a = new ArrayList<>();
    if(left>right||key<arr[0]||key>arr[arr.length-1]){
        return new ArrayList<Integer>();
    }
    if(midVal<key){
        return binarySearch(arr,mid+1,right,key);
    }else if(midVal>key){
        return binarySearch(arr,left,mid-1,key);
    }else{
        int temp = mid - 1;
        while(true){
            if(temp<0||arr[temp]!=key){
                break;
            }
            a.add(temp);
            temp-=1;
        }
        a.add(mid);       
        int temp = mid + 1;
        while(true){
            if(temp<0||arr[temp]!=key){
                break;
            }
            a.add(temp);
            temp+=1;
        }
    }
    return a;
}

(4)斐波那契查找:

斐波那契查找原理与前两种相似，仅改变了中间结点(mid)的位置。此时mid不再是中间或插值得到的，而是位于黄金分割点附近，即mid=low+F(k-1)-1，其中F代表斐波那契数列。

对F(k-1)-1的理解:

只要顺序表的长度为F(k)-1，则可以将该表分成长度为F(K-1)-1和F(K-2)-1的两段，从而中间位置mid=low+F(k-1)-1;类似的，每一子段也可以用相同的方式分割;

但顺序表长度n不一定刚好等于F(K)-1，所以需要将原来的顺序表长度n增加至F(K)-1,这里的k值只要能使得F(K)-1恰好大于或等于n即可，新增的位置都赋为n位置的值即可。

代码实现:

static int maxSize = 20;
int[] arr = {1,8,10,89,1000,1234};
public static int[] fib(){
    int[] arr = new int[maxSize];
    f[0] = 1;
    f[1] = 1;
    for(int i = 2;i<maxSize;i++){
        f[i] = f[i-1] + f[i-2];
    }
    return f;
}
public static int fibSearch(int[]a,int key){
    int low = 0;
    int high = a.length - 1;
    int k = 0;//表示斐波那契分割数值的下标
    int mid = 0;//存放mid值
    int []f = fib();
    //获取到斐波那契分割数值的下标
    while(high>f[k]-1){
        k++;
    }
    //因为f[k]可能大于a的长度,因此需要使用Arrays构造一个新的数组并指向a
    //并使用a数组的最后数填充temp
    int[]temp = Arrays.copy(a,f[k]);
    for(int i = high+1;i<temp.length;i++){
        temp[i] = a[high];
    }
    while(low<=high){
        mid = low + f[k] - 1;
        if(key<temp[mid]){
            high = mid - 1;
            //全部元素 = 前部元素 + 后部元素
            //f[k] = f[k-1] + f[k-2];
            //因为前面有f[k-1]个元素，可以继续拆分为f[k-1] = f[k-2] + f[k-3]
            //即在f[k-1]前面继续查找,所以需要k--
            key--;
        }else if(key>temp[mid]){
            low = mid + 1;
            //全部元素 = 前部元素 + 后部元素
            //f[k] = f[k-1] + f[k-2];
            //因为后面有f[k-2]个元素，可以继续拆分为f[k-2] = f[k-3] + f[k-4]
            //即在f[k-2]前面继续查找,所以需要k-=2
            key-=2;
        }else{
            if(mid<=high){
                return mid;
            }else{
                return high;
            }
        }
    }
    return -1;
}