​

1. 概念

计算机行业的对于这个都是老生常谈，我这里简单写一点。
① 算法是用来解决某个问题而提出或设计的，不同的场景有不同的算法。
② 设计算法就要用到——数据结构。常见的数据结构有：数组、链表、队列、堆、栈、树等。
③ 评估一个算法的效率，我们常用时间复杂度和空间复杂度。
时间复杂度：简而言之就是指我们算法中某项基本操作（赋值、循环、判断、运算等）重复执行的次数/频度。常见的时间复杂度：O(1)、O(㏒₂n)、O(n)、O(n㏒₂n)、O(n²)、O(n³)、O(2^n)、O(n!)。

空间复杂度：算法所在的程序从开始执行到结束所占用多大的内存容量和空间。针对算法时，只考虑算法内部/本身所定义的变量、使用的存储结构等。

2. 顺序查找

• 顺序查找

查找算法：二分查找、顺序查找

zip 4星 超过85%的资源 1.07MB

下载

又称线性查找。是最简单的查找方法。
方法：从数组的一头开始，将待查找key和数组元素进行逐个比较。如果找到与key相同的元素，则查找成功，结束后未找到，则查找失败。
算法示例：

public class SequentialSearch {
    public static void main(String[] args) {
        int[] array = {4, 8, 9, 3, 100, 99, 22, 23, 77, 23};
        int target = 23;
        int i = sequentialSearch(array, target);
        System.out.println("目标元素的数组下标为：" + i);
    }

    // 顺序查找（for循环）
    public static int sequentialSearch(int[] array, int target) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target) {
                System.out.println("目标元素：" + target + "，所在的数组下标为：" + i);
                return i;
            }
        }
        System.out.println("没有查找到该目标元素");
        return -1;
    }
    
    //顺序查找（foreach）
    public static int sequentialSearch2(int[] array, int target) {
        for (int element : array) {
            if (element == target) {
                System.out.println("目标元素：" + target + "，所在的数组下标为：" + element);
                return element;
            }
        }
        System.out.println("没有查找到该目标元素");
        return -1;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

• 折半查找
  也称二分查找。
  算法前提：数组元素已经有序。
  核心思想：尽快缩小搜索区间。所以要求元素排列有序。
  算法示例：

public class SearchUtils {
    public static void main(String[] args) {
        SearchUtils su = new SearchUtils();
        int[] arr = {1,3,6,9,12,23,33,44,45,67,78,98,100,111,123,1234,2345,9999,11111,12345,666666,900000};
        int res = su.binarySearch(arr, 44);
        System.out.println("res=" + res);
    }
 
    /**
     * 二分查找
     * @param arr 要进行查找的数组，要求数组必须是有序的
     * @param findElem 要查找的元素
     * @return 返回要查找的元素在数组的索引位置， 返回-1表示没找到
     */
    public int binarySearch(int[] arr, int findElem) {
        int low = 0;
        int high = arr.length - 1;
        int mid;
        while (low <= high) {
            mid = (low + high) / 2;
            //如果要查找的元素findElem小于中间位置的元素mid，指向数组的较大端的high索引重新指向中间索引mid的左边（mid-1）
            if (findElem < arr[mid]) {
                high = mid - 1;
            }
            //如果要查找的元素findElem大于中间位置的元素mid，指向数组的较小端的low索引重新指向中间索引mid的右边（mid+1）
            if (findElem > arr[mid]) {
                low = mid + 1;
            }
            if (arr[mid] == findElem) {
                return mid;
            }
        }
        return -1;
    }
 
}

//  递归方式  arr数组；front数组起始位，end数组结束位，n待查找数
public static int seek(int[] arr, int front, int end, int n) {
        int mid = (end + front) / 2;
        if (front <= end) {
            if (arr[mid] == n) {
                return mid;
            } else if (arr[mid] > n) {
                return seek(arr, front, mid - 1, n);
            } else {
                return seek(arr, mid + 1, end, n);
            }
        } else {
            return -1;
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

• 索引查找
  索引查找又分为基本索引查找和分块查找。是一种介于顺序查找和二分查找之间的查找方法。 块间有序，块内无序
  核心思想：针对无需的数据集合，先建立索引表，让索引表有序或者分块有序，再结合顺序查找或索引查找的方法完成查找。
  具体： 首先查找索引表，因为索引表是有序表，故可以采用二分查找或顺序查找，以确定待查记录在那一块；然后在已确定的块中进行顺序查找（因为块内无序，只能用顺序查找）。如果在块中找到该记录则查询成功，否则查找失败。

import java.util.Scanner;

public class splitSearch {
    private static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        int[] ints = new int[18];
        int[] suoYin = new int[5];
        System.out.println("录入数据:");
        for(int i = 0;i < 18;i++)
            ints[i] = sc.nextInt();
        for(int i = 0;i < ints.length / 6;i++){
            int max = i;
            for(int j = i * 6;j < (i + 1) * 6;j++)
                if(ints[j] > ints[max])
                    max = j;
            suoYin[i] = max;
        }
        /* 测试数据 : 22 12 13 8 9 20 33 42 44 38 24 48 60 58 74 49 86 53 */
        System.out.print("请输入查找信息:");
        new splitSearch().splitS(ints,suoYin,sc.nextInt());
    }

    private void splitS(int[] ints,int[] xx,int data){
        int low = 0;
        int high = ints.length / 6 - 1;
        int sure = -1;
        int middle;
        while(low <= high){
            middle = (low + high) / 2;

            if(data > ints[xx[middle]] && high - middle == 1){
                sure = high;
                break;
            }else if(data < ints[xx[middle]] && middle - low == 1 && data > ints[xx[low]]){
                sure = middle;
                break;
            }else if(data < ints[xx[middle]] && data < ints[xx[low]]){
                sure = low;
            }

            if(data > ints[xx[middle]]){
                low = middle + 1;
            }else if(data < ints[xx[middle]]){
                high = middle - 1;
            }else{
                System.out.println("[ index = " + xx[middle] + " ]");
                return;
            }
        }
        for(int i = sure * 6;i < (sure + 1) * 6 && sure >= 0;i++)
            if(ints[i] == data){
                System.out.println("[ index = " + i + " ]");
                return;
            }
        System.out.println("[ 无此数据 ]");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

活动地址：CSDN21天学习挑战赛

​