算法设计与分析(Java实现)—— 查找

【1】线性查找

有一个数列: {1,8, 10, 89, 1000, 1234} ,判断数列中是否包含此名称【顺序查找】 要求: 如果找到了,就提示找到,并给出下标值。

public class SeqSearch {
    public static void main(String[] args) {
        // 没有顺序的数组
        int arr[] = {1, 9, 11, -1, 34, 89};
        int index = seqSearch(arr,-1);
        if (index == -1){
            System.out.println("没有找到》》》》");
        }else {
            System.out.println("找到了,它在第 "+(index+1)+" 个位置");
        }
    }

    /**
     *
     * @param arr
     * @param value
     * @return
     */
    public static int seqSearch(int[] arr , int value){
        //线性查找是逐一比对,发现有相同值,就返回下标
        for(int i = 0;i < arr.length;i++){
            if (arr[i] == value){
                return i;
            }
        }
        return -1;
    }
}

【2】二分查找(戏多)

常规二分查找

public class BinarySearch {
    public static void main(String[] args) {
        int arr[] = { 1, 8, 10, 89,1000,1000, 1234 };
        int resIndex = binarrSearch(arr, 0, arr.length - 1, 1000);
//		System.out.println("resIndex=" + resIndex);
        System.out.println("找到了,它在第 "+(resIndex)+" 个位置");
    }

    /**
     *
     * @param arr 数组
     * @param left 左边的索引
     * @param right 右边的索引
     * @param findVal 要查找的值
     * @return 如果找到就返回下标,如果没有找到,就返回 -1
     */
    public static int binarrSearch(int[] arr,int left,int right,int findVal){
        // 当 left > right 时,说明递归整个数组,但是没有找到,目标值不在数组里面直接退出
        if (left > right){
            return -1;
        }
        int mid = (left +right)/2;
        int midVal = arr[mid];
        if (findVal >midVal){
            return binarrSearch(arr,mid +1,right,findVal);
        }else if (findVal <midVal){
            return binarrSearch(arr,left,mid-1,findVal);
        }else {
            return mid;
        }

    }
}

特殊的二分查找

//完成一个课后思考题:
/*
 * 课后思考题: {1,8, 10, 89, 1000, 1000,1234} 当一个有序数组中,
 * 有多个相同的数值时,如何将所有的数值都查找到,比如这里的 1000
 *
 * 思路分析
 * 1. 在找到mid 索引值,不要马上返回
 * 2. 向mid 索引值的左边扫描,将所有满足 1000, 的元素的下标,加入到集合ArrayList
 * 3. 向mid 索引值的右边扫描,将所有满足 1000, 的元素的下标,加入到集合ArrayList
 * 4. 将Arraylist返回
 */
import java.util.ArrayList;
import java.util.List;

public class BinarySearch2 {
    public static void main(String[] args) {
        int arr[] = { 1,8, 10, 89,1000,1000,1000,1234};
        List<Integer> resIndexList = binarrSearch(arr, 0, arr.length - 1, 1000);
        System.out.println("resIndexList=" + resIndexList);

    }


    public static List<Integer> binarrSearch(int[] arr,int left,int right,int findVal){
        // 当 left > right 时,说明递归整个数组,但是没有找到,目标值不在数组里面直接退出
        if (left > right){
            return new ArrayList<Integer>();
        }
        int mid = (left +right)/2;
        int midVal = arr[mid];
        if (findVal >midVal){
            return binarrSearch(arr,mid +1,right,findVal);
        }else if (findVal <midVal){
            return binarrSearch(arr,left,mid-1,findVal);
        }else {
//            * 1. 在找到mid 索引值,不要马上返回
//            * 2. 向mid 索引值的左边扫描,将所有满足 1000, 的元素的下标,加入到集合ArrayList
//            * 3. 向mid 索引值的右边扫描,将所有满足 1000, 的元素的下标,加入到集合ArrayList
//            * 4. 将Arraylist返回
            List<Integer> resIndexlist = new ArrayList<Integer>();

            //2. 向 mid 索引值的左边扫描,将所有满足 1000, 的元素的下标,加入到集合ArrayList
            int temp = mid -1;
            while (true){
                if (temp < 0 || arr[temp] != findVal){
                    break;
                }
                //否则,就temp 放入到 resIndexlist
                resIndexlist.add(temp);
                temp-=1;
            }

            resIndexlist.add(mid);

            //3. 向mid 索引值的右边扫描,将所有满足 1000, 的元素的下标,加入到集合ArrayList
            temp =mid +1;
            while (true){
                if (temp >arr.length -1 || arr[temp] != findVal){
                    break;
                }
                //否则,就temp 放入到 resIndexlist
                resIndexlist.add(temp);
                temp += 1; //temp右移

            }
            return resIndexlist;
        }
    }
}

二分查找非递归

public class BinarySearchNoRecur {
    public static void main(String[] args) {
        int[] arr = {1,3, 8, 10, 11, 67, 100};
        int index = binarySearch(arr, 100);
        System.out.println("index=" + index);
    }

    //二分查找的非递归实现
    /**
     *
     * @param arr 待查找的数组, arr是升序排序
     * @param target 需要查找的数
     * @return 返回对应下标,-1表示没有找到
     */
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length -1;
        while (left <= right ){ //说明继续查找
            int mid = (left +right)/2;
            if (arr[mid] == target){
                return  mid;
            }else if (arr[mid] >target){  //需要向左边查找
                right =mid -1;
            }else {
                left = mid +1; //需要向右边查找
            }
        }
        return -1;
    }
}

【3】差值查找 (自适应)

/**
 * 插值查找注意事项:
 * 1)对于数据量较大,关键字分布比较均匀的查找表来说,采用插值查找,速度较快.
 * 2)关键字分布不均匀的情况下,该方法不一定比折半查找要好
 */
public class InsertValueSearch {
    public static void main(String[] args) {
        int arr[] = { 1, 8, 10, 89,1000,1000, 1234 };
        int index = insertValueSearch(arr, 0, arr.length-1, 1234);
        System.out.println("index = " + index);
        System.out.println();
        int index2 = binarySearch(arr, 0, arr.length-1, 1234);
        System.out.println("index = " + index2);
    }

    //编写插值查找算法
    //说明:插值查找算法,也要求数组是有序的
    /**
     *
     * @param arr 数组
     * @param left 左边索引
     * @param right 右边索引
     * @param findVal 查找值
     * @return 如果找到,就返回对应的下标,如果没有找到,返回-1
     */
    public static int insertValueSearch(int[] arr, int left, int right, int findVal) {
        System.out.println("插值查找次数~~");

        //注意:findVal < arr[0]  和  findVal > arr[arr.length - 1] 必须需要
        //否则我们得到的 mid 可能越界
        if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
            return -1;
        }

        // 求出mid, 自适应
        int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
        int midVal = arr[mid]; //提取值做对比

        if (findVal > midVal) { // 说明应该向右边递归
            return insertValueSearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) { // 说明向左递归查找
            return insertValueSearch(arr, left, mid - 1, findVal);
        } else {
            return mid;
        }

    }

    public static int binarySearch(int[] arr, int left, int right, int findVal) {
		System.out.println("二分查找被调用~");
		// 当 left > right 时,说明递归整个数组,但是没有找到
		if (left > right) {
			return -1;
		}
		int mid = (left + right) / 2;
		int midVal = arr[mid];

		if (findVal > midVal) { // 向 右递归
			return binarySearch(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) { // 向左递归
			return binarySearch(arr, left, mid - 1, findVal);
		} else {

			return mid;
		}

	}
}

【4】斐波那契查找


import java.util.Arrays;

//增长数列达到黄金分割
//被查找的数组要有序
public class FibonacciSearch {
    public static int maxSize = 20;

    public static void main(String[] args) {
        int [] arr = {1,8, 10, 89, 1000, 1234};
        System.out.println("index=" + fibSearch(arr, 89));// 0

    }

    //后面 mid=low+F(k-1)-1 ,需要使用到斐波那契数列,因此我们需要先获取到一个斐波那契数列
    //非递归方法得到一个斐波那契数列
    public static int[] fib() {
        int[] f = 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;
    }
    //编写斐波那契查找算法
    //使用非递归的方式编写算法
    /**
     *
     * @param a  数组
     * @param key 我们需要查找的关键码(值)
     * @return 返回对应的下标,如果没有-1
     */
    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类,构造一个新的数组,并指向temp[]
        //不足的部分会使用0填充
        int[] temp = Arrays.copyOf(a, f[k]);//原数组 a 长度 k
        //实际上需求使用a数组最后的数填充 temp
        //举例:
        //temp = {1,8, 10, 89, 1000, 1234, 0, 0}  => {1,8, 10, 89, 1000, 1234, 1234, 1234,}
        for(int i = high + 1; i < temp.length; i++) {
            temp[i] = a[high];
        }

        // 使用while来循环处理,找到我们的数 key
        while (low <= high) { // 只要这个条件满足,就可以找
            mid = low + f[k - 1] - 1;
            if(key < temp[mid]) { //我们应该继续向数组的前面查找(左边)
                high = mid - 1;
                k--;
            } else if ( key > temp[mid]) { // 我们应该继续向数组的后面查找(右边)
                low = mid + 1;
                k -= 2;
            } else { //找到
                //需要确定,返回的是哪个下标
                if(mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

高高飞起的勇敢麦当

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值