【数据结构-查找-学习笔记】

查找算法

基本查找

package searchdemo;

public class SearchDemo1 {
    public static void main(String[] args) {
        //基本查找
        int[] arr = {131,127,147,81,103,23,7,79};
        boolean b = basicSearch(arr, 81);
        System.out.println(b);
    }
    public static boolean basicSearch(int[] arr,int number){
        for (int i = 0; i < arr.length; i++) {
            if(number == arr[i])
                return true;
        }
        return false;
    }
}

package searchdemo;

import java.util.ArrayList;

public class SearchDemo2 {
    public static void main(String[] args) {
        //基本查找,元素无重复
        int[] arr = {131,127,147,81,103,23,7,79};
        ArrayList<Integer> list = basicSearch(arr, 81);
        if(list == null){
            System.out.println(false);
        }else{
            System.out.println(list);
        }

    }
    //如果返回多个数据,则将数据放到数组或集合当中
    public static ArrayList<Integer> basicSearch(int[] arr, int number){
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if(number == arr[i]){
                list.add(i);
            }
        }
        return list;
    }
}

二分查找/折半查找

package searchdemo;

public class SearchDemo3 {
    public static void main(String[] args) {
        //折半查找
        //min和max表示当前要查找的范围,mid是在min和max中间.
        int[] arr = {7,23,79,81,103,127,131,147};
        System.out.println(binarySearch(arr,81));
    }
    public static int binarySearch(int[] arr,int number){
        int min = 0;
        int max = arr.length-1;
        while(true){
            if(min > max){
                return -1;
            }
            int mid = (min + max) / 2;
            if(arr[mid] > number){
                max = mid - 1;
            }else if(arr[mid] < number){
                min = mid + 1;
            }else{
                return mid;
            }
        }
    }
}

插值查找

mid尽可能的靠近要查找的数据,但是要求数据尽可能的分布均匀

斐波那契查找

根据黄金分割点来计算mid指向的位置

分块查找

**分块原则1:**前一块中的最大数据,小于后一块中所有的数据(块内无序,快间有序)
**分块原则2:**块数数量一般等于数字的个数开根号.比如:16个数字一般为分为4块左右
**核心思路:**先确定查找的元素在哪一块,然后在块内挨个查找

package searchdemo;

public class BlockSearch {
    public static void main(String[] args) {
        int[] arr = {16,5,9,12,21,18,
                32,23,37,26,45,34,
                50,48,61,52,73,66};
        Block b1 = new Block(16,0,5);
        Block b2 = new Block(45,6,11);
        Block b3 = new Block(73,12,17);
        Block[] blockArr = {b1,b2,b3};
        int number = 32;
        int flag = -1;
        int indexBlock = findIndexBlock(blockArr, number);
        if(indexBlock == -1){
            System.out.println(false);
        }
        boolean flagg = false;
        for (int i = blockArr[flag].getStartIndex(); i <= blockArr[flag].getEndIndex(); i++){
            if(number == arr[i]){
                flagg = true;
                System.out.println(true);
                break;
            }
        }
        if(!flagg){
            System.out.println(false);
        }
    }
    private static int findIndexBlock(Block[] blockArr,int number){
        for (int i = 0; i < blockArr.length; i++) {
            if(blockArr[i].getMax() < number) {
                continue;
            }else if(blockArr[i].getMax() >= number){
                return i;
            }
        }
        return -1;
    }
}
class Block{
    private int max;
    private int startIndex;
    private int endIndex;

    public Block() {
    }

    public Block(int max, int startIndex, int endIndex) {
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    /**
     * 获取
     * @return max
     */
    public int getMax() {
        return max;
    }

    /**
     * 设置
     * @param max
     */
    public void setMax(int max) {
        this.max = max;
    }

    /**
     * 获取
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }

    /**
     * 设置
     * @param startIndex
     */
    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }

    /**
     * 获取
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }

    /**
     * 设置
     * @param endIndex
     */
    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }

    public String toString() {
        return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

分块查找的扩展

package searchdemo;

public class BlockSearchDemo2 {
    public static void main(String[] args) {
        int[] arr = {27,22,30,40,36,
                13,19,16,20,
                7,10,
                43,50,48};
        int number = 30;
        BlockSearch2 block1 = new BlockSearch2(22,40,0);
        BlockSearch2 block2 = new BlockSearch2(13,20,5);
        BlockSearch2 block3 = new BlockSearch2(7,10,9);
        BlockSearch2 block4 = new BlockSearch2(43,50,11);
        BlockSearch2[] blockArr = {block1,block2,block3,block4};
        int index = findIndex(blockArr, number);
        if(index == -1) {
            System.out.println(false);
        }else{
            boolean flag = false;
            for (int i = blockArr[index].getIndex(); i < blockArr[index + 1].getIndex(); i++) {
                if(number == arr[i]){
                    flag = true;
                    System.out.println(true);
                    break;
                }
            }
            if(!flag){
                System.out.println(false);
            }
        }
    }
    private static int findIndex(BlockSearch2[] blockArr,int number){
        for (int i = 0; i < blockArr.length; i++) {
            if(number >= blockArr[i].getMin() && number <= blockArr[i].getMax()){
                return i;
            }
        }
        return -1;
    }
}
class BlockSearch2 {
    private int min;
    private int max;
    private int index;


    public BlockSearch2() {
    }

    public BlockSearch2(int min, int max, int index) {
        this.min = min;
        this.max = max;
        this.index = index;
    }

    /**
     * 获取
     * @return min
     */
    public int getMin() {
        return min;
    }

    /**
     * 设置
     * @param min
     */
    public void setMin(int min) {
        this.min = min;
    }

    /**
     * 获取
     * @return max
     */
    public int getMax() {
        return max;
    }

    /**
     * 设置
     * @param max
     */
    public void setMax(int max) {
        this.max = max;
    }

    /**
     * 获取
     * @return index
     */
    public int getIndex() {
        return index;
    }

    /**
     * 设置
     * @param index
     */
    public void setIndex(int index) {
        this.index = index;
    }

    public String toString() {
        return "BlockSearch2{min = " + min + ", max = " + max + ", index = " + index + "}";
    }
}

扩展的分块查找(查找过程中还需要添加数据)