常用查找算法（Java）

2018-01-22

 

1 順序查找

就是一個一個依次查找

2 二分查找

二分查找（Binary Search）也叫作折半查找。

二分查找有兩個要求，

• 一個是數列有序，
• 另一個是數列使用順序存儲結構（比如數組）。

/**
 * 二分查找
 */
public class BinarySearch {

    public static void main(String[] args)
    {
        int[] arr=new int[]{1,2,3,5,6,6,8,9};
        BinarySearch binarySearch=new BinarySearch(arr);
        System.out.println(binarySearch.searchRecursion(5));
        System.out.println(binarySearch.searchRecursion(4));
        System.out.println(binarySearch.searchRecursion(6));
        System.out.println(binarySearch.search(5));
        System.out.println(binarySearch.search(7));
        System.out.println(binarySearch.search(6));
    }

    private int[] arr;

    public BinarySearch(int[] arr)
    {
        this.arr=arr;
    }

    public int searchRecursion(int target)
    {
       return searchRecursion(target,0,arr.length-1);
    }

    private int searchRecursion(int target,int begin,int end)
    {
        if(begin<=end)
        {
            int mid=(begin+end)/2;
            if(arr[mid]==target) return mid;
            if(arr[mid]>target)
                return searchRecursion(target,begin,mid-1);
           else
                return searchRecursion(target,mid+1,end);
        }
        return -1;
    }

    private int search(int target)
    {
        int begin =0;
        int end=arr.length-1;
        while(begin<=end)
        {
            int mid=(begin+end)/2;
            if(arr[mid]==target) return mid;
            if(arr[mid]>target) end=mid-1;
            else begin=mid+1;
        }
        return -1;
    }
}

3 分塊查找

分塊查找是結合二分查找和順序查找的一種改進方法。在分塊查找里有索引表和分塊的概念。索引表就是幫助分塊查找的一個分塊依據。分塊查找只需要索引表有序。

分塊查找有點類似於哈希表，但又不如散列表好用，其實很多時候我們在編程中並不會直接用到這個算法，但是分塊的思想在很多時候還是很有用的。

public class BlockSearch {
    public static void main(String[] args) {
        int[] index = new int[]{10, 20, 30};
        BlockSearch blockSearch = new BlockSearch(index);
        blockSearch.insert(-1);
        blockSearch.insert(10);
        blockSearch.insert(25);
        //blockSearch.insert(31);
        blockSearch.search(0);
        blockSearch.search(-1);
        blockSearch.search(10);
        blockSearch.search(25);
    }


    private int[] index;
    private ArrayList[] list;
    public BlockSearch(int[] index) {
        if (index != null && index.length != 0) {
            this.index = index;
            list = new ArrayList[index.length];
            for (int i = 0; i < list.length; i++) {
                list[i] = new ArrayList();
            }
        } else {
            throw new Error("index cannot be null or empty.");
        }
    }

    public void insert(int data) {
        int i = binarySearch(data);
        list[i].add(data);
    }

    public void search(int data) {
        int i = binarySearch(data);
        for (int j = 0; j < list[i].size(); j++) {
            if (data == (int) list[i].get(j)) {
                System.out.println(String.format("'%d' Position: [%d,%d]", data, i, j));
                return;
            }
        }
        System.out.println(String.format("'%d' Position: Not found", data));
    }

    private int binarySearch(int data) {
        if(data>index[index.length-1])
            throw new Error("out of block range");

        int start = 0;
        int end = index.length - 1;
        int mid;
        while (start < end) {
            mid = (start + end) / 2;
            if (index[mid] > data) end = mid - 1;
            else
                //如果相等，也插入后面 <=index[start]
                start = mid + 1;
        }
            return start;
    }
}

4 搜索引擎與倒排索引

搜索引擎就是從大量的數據中根據關鍵字查找出對應的信息。搜索引擎之所以能夠快速地根據我們鍵入的關鍵字獲取結果列表，這都是索引的功勞。

索引分為倒排索引和正排索引，我們用到的一般都是倒排索引。

倒排索引的英文是Inverted Index。比如有一個文檔列表，每個文檔都會有唯一的ID，我們建立關鍵字和文檔id的索引表即可。

倒排索引的關鍵字提取，對於英文比較容易，可以以單詞分割；對於中文就比較復雜，不同的字組成的詞很多。比如“中華人民共和國”這個詞可以是一個詞，“中華”也可以是一個詞，並分出其他好多詞。