顺序查找和折半查找

三种查找方式

总结了三种查找方式：

1.顺序查找
2.折半查找
3.索引查找

---

• 查找是对数组进行比对
• int a[10] = {1,2,3,4,5,6,7,8,9,10};
• int key = 5

顺序查找

顺序查找是针对已存在的数组a[n]中查找和我们所希望查找的关键字进行一个一个的比对并且相同返回我们所需的数据
1. 返回关键字在数组中的位置
2. 返回关键字是否存在与数组中

具体实现的代码

package 查找;

import java.util.ArrayList;
import java.util.List;

public class 顺序查找 {

    public static void main(String[] args) {
        int a[] = {1,5,3,4,5,6,7,8,9};
        int x = 5;
        List<Integer> list = find(x, a);
        for (Integer i:list) {
            System.out.print(i+1+" ");
        }
    }

    public static List<Integer> find(int x,int[] a) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < a.length; i++) {
            if(x==a[i]) {
                list.add(i);
            }
        }
        return list;
    }

}

解释

针对数组中存在的多个数据进行比对，查找数组中存在关键字的个数和位置，通过添加到list中，返回list，然后判断list中是否存在值，如果list的中不存在值的话，说明查找过程中的数组中不存在关键字，否则的话根据list中的值得到在关键字在数组中的位置和个数。

折半查找

折半查找是针对已存在的有序数组a[n]中查找通过先对数组的第一个后和最后一个的中间值进行比较，判断是否大于或小于，然后对第一个和最后一个的值进行重新赋值，再重新对第一个和最后一个的中间值进行比较。
1. 返回关键字在数组中的位置
2. 返回关键字是否存在与数组中

具体实现的代码

package 查找;

public class 折半查找 {

    public static void main(String[] args) {
        int a[] = {1,5,3,4,5,6,7,8,9};
        int x = 5;
        System.out.print( find(x, a));
    }

    //折半查找
    public static int find(int x,int[] a){
        int low = 0;
        int high = a.length-1;
        int mid = (low+high)/2;
        while(low<=high) {
            if(x==a[mid]) {
                return mid;
            }else if(x>a[mid]) {
                low = mid + 1;
            }else if(x<a[mid]) {
                high = mid - 1;
            }
        }


        return 0;

    }

}

解释

在折半查找中就是不停的首先判断中间位置的值是否等于然后对左右边界的不停缩小直至查找到关键字，如果没有查找到就返回0；

索引查找

索引查找的方法是根据数据进行分块，针对查找的数组有以下特征

1. 数组中一定数据块间的数据是有顺序的的 例如：数据块一的所有数据 < 数据块二的所有数据 < 数据块三的所有数据。
2. 对于数据块中我们需要得到数据块中的特征有每个数据块中的最大关键字和数据块的第一个数据在数组中的位置。

具体实现的代码

package 索引查找;

import java.util.Scanner;

public class IndexSearch {

    public static long stu[] = {
        1080101,1080102,1080103,1080104,1080105,1080106,0,0,0,0,
        1080201,1080202,1080203,1080204,0,0,0,0,0,0,
        1080301,1080302,1080303,1080304,0,0,0,0,0,0
    };

    static Item[]indexTable = {
            new Item(10801,0,6),
            new Item(10802,10,4),
            new Item(10803,20,4)
    };

    public static int indexSearch(int key){
        int i,index1,start = 0,length = 0;
        index1 = key/100;
        for (i = 0;i<indexTable.length;i++) {
            if (indexTable[i].index == index1) {
                start = indexTable[i].start;
                length = indexTable[i].length;
                break;
            }
        }
        if (i >= indexTable.length) {
            return -1;
        }
        for (i = start;i<start+length;i++) {
            if (stu[i] == key) {
                return i;
            }
        }
        return -1;
    }

    //向主表中插入元素，从stu这个数组中我们可以看出来里面有0的值，这些值就是预留的空间
    /**
     * 我们只需要把这些0的值替换掉就行了，值涉及到了索引表和相应的字表，而不是整个表
     * 所以比较和移动的效率比较高
     */

    public static int insertNode(int key){
        int i,index1,start = 0,length = 0;
        index1 = key/100;
        for (i = 0;i<indexTable.length;i++) {
            if (indexTable[i].index == index1) {
                start = indexTable[i].start;
                length = indexTable[i].length;
                break;
            }
        }
        if (i >= indexTable.length) {
            return -1;
        }

        //保存关键字到主表中
        stu[start+length] = key;
        indexTable[i].length++;
        return 0;
    }


    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("原始数据：");
        for (int i = 0;i<stu.length;i++) {
            System.out.print(stu[i]+" ");
        }
        System.out.println();
//      System.out.println("输入查找的关键字");
//      int key = input.nextInt();
//      int pos = indexSearch(key);
//      if (pos >= 0) {
//          System.out.printf("查找成功，该关键字位于数组的第%d个位置\n",pos);
//      }else{
//          System.out.println("查找失败！");
//      }

        System.out.println("输入插入的关键字");
        int num = input.nextInt();
        if (insertNode(num) == -1) {
            System.out.println("插入失败！");
        }else {
            for (int i = 0;i<stu.length;i++) {
                System.out.print(stu[i]+" ");
            }
            System.out.println();
        }




    }




}