順二差查找(順序、二分、插值查找)

1.查找算法概述

	查找是在大量的信息中尋找一個特定的信息元素,在計算機應用中,查找是常用的基本運算,例如編譯程序中符號表的查找。
	本文簡單概括性的介紹了常見的七種查找算法,說是七種,其實*二分查找*、*插值查找*以及*斐波那契查找*都可以歸爲一類
	——插值查找。插值查找和斐波那契查找是在二分查找的基礎上的優化查找算法。
(1)查找定義

根據給定的某個值,在查找表中確定一個其關鍵字等於給定值的數據元素(或記錄)。

(2)查找算法分類
	1)靜態查找和動態查找
		注:靜態或者動態都是針對查找表而言的。動態表指查找表中有刪除和插入操作的表。

	2)無序查找和有序查找
		無序查找:被查找數列有序無序均可;

	有序查找:被查找數列必須爲有序數列。
(3)查找算法分析
		平均查找長度(Average Search Length,ASL):需和指定key進行比較的關鍵字的個數的期望值,
		稱爲查找算法在查找成功時的平均查找長度。

		對於含有n個數據元素的查找表,查找成功的平均查找長度爲:ASL = Pi*Ci的和。

		Pi:查找表中第i個數據元素的概率。

		Ci:找到第i個數據元素時已經比較過的次數。

2.順序查找

(1)方法說明
順序查找適合於存儲結構爲順序存儲或鏈接存儲的線性表。

(2)基本思想
順序查找也稱爲線形查找,屬於無序查找算法。從數據結構線形表的一端開始,順序掃描,
依次將掃描到的結點關鍵字與給定值k相比較,若相等則表示查找成功;若掃描結束仍沒有找到關鍵字等於k的結點,
表示查找失敗。

(3)複雜度分析
查找成功時的平均查找長度爲:(假設每個數據元素的概率相等) ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;當查找不成功時,需要n+1次 比較,時間複雜度爲O(n);所以,順序查找的時間複雜度爲O(n)。

代碼實現

  //順序查找
    public static int seqSearch(int[] arr, int index) {
        int temp = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == index) {
                temp = i;
                break;
            }
        }
        return temp;
    }

3.二分查找

概念:
	是一種在**有序數組**中查找某一特定元素的搜索算法。
思路:
搜索過程從數組的中間元素開始,如果中間元素正好是要查找的元素,則搜索過	程結束;
如果某一特定元素大於或者小於中間元素,則在數組大於或小於中間元素的那一半中查找,而且跟開始一樣從中間元素開始比較。
如果在某一步驟數組爲空,則代表找不到。這種搜索算法每一次比較都使搜索範圍縮小一半。

在這裏插入圖片描述

代碼實現:
   /**
     * 二分查找
     *
     * @param index
     * @return 返回一個集合
     */
    public static ArrayList<Integer> BinarySearch(int[] arr, int index, int left, int right) {
        if (left > right) return null;
        ArrayList<Integer> list = new ArrayList<Integer>();
        int mid = (left + right) / 2;
        int midVal = arr[mid];
        if (midVal > index) return BinarySearch(arr, index, left, mid - 1);
        else if (midVal < index) return BinarySearch(arr, index, mid + 1, right);
        else {
            //往左邊掃描,如果有相同值,則繼續加入集合
//                while (mid > left && arr[mid - 1] == index) if (arr[--mid] == index) list.add(mid);
//                while (mid < right && arr[mid + 1] == index) if (arr[++mid] == index) list.add(mid);
            //想着左邊掃秒
            int temp = mid - 1;
            while (true) {
                if (temp < 0 || arr[temp] != index) break;
                list.add(temp);
                temp--;
            }
            list.add(mid);
            //右邊掃描
            temp = mid + 1;
            while (true) {
                if (temp > right || arr[temp] != index) break;
                list.add(temp);
                temp++;
            }
            return list;
        }
    }

斐波拉契查找算法:

條件:
			(1)數據必須採用順序存儲結構;(2)數據必須有序。
原理:
			(1)最接近查找長度的斐波那契值來確定拆分點;(2)黃金分割。
時間複雜度:
與拆半查找一樣,也是logn。有博客說,在處理海量數據時,拆分查找的middle = (low + hight)/2,除法可能會影響效率,而斐波那契的middle = low + F[k-1] -1,純加減計算,速度要快一些。我覺得是扯淡,那咋不用middle = (loe+hight)>>2來代替,要知道相比於加減乘除而言,位運算的效率可是最高的喲。嘻嘻
代碼:

```java
 /**
     * 斐波拉契查找
     *
     * @param arr
     * @param index
     * @param left
     * @param right
     * @return
     */
    public static int FibonacciSearch(int[] arr, int index, int left, int right) {
        int[] f = fib(20);
        int n = 0;
        int low = 0;
        int high = arr.length - 1;
        int mid = 0;
        while (f[n] - 1 < high) n++;
        //對數組索引進行託管
        //如果索引對不上,則對數組進行擴容
        int[] temp = new int[f[n]];
        for (int i = 0; i < arr.length; i++) temp[i] = arr[i];
        for (int i = high + 1; i < temp.length; i++) temp[i] = arr[high];
        //進行查找
        while (low <= high) {
            mid = low + f[n - 1] - 1;
            if (temp[mid] < index) {
                low = mid + 1;
                n -= 2;
            } else if (temp[mid] > index) {
                n--;
                high = mid - 1;
            } else {
                if (mid > high) return high;
                return mid;
            }
        }
        return -1;
    }
  	

#### 插值算法:
```java
 /**
     * 插值查找
     *
     * @param index
     * @return
     */
    public static int InsertValSearch(int[] arr, int index, int left, int right) {
        if (left > right || arr[0] > index || index > arr[arr.length - 1]) {
            return -1;
        }
        int mid = left + (right - left) * (index - arr[left]) / (arr[right] - arr[left]);
        if (arr[mid] > index) InsertValSearch(arr, index, left, mid - 1);
        else if (arr[mid] < index) InsertValSearch(arr, index, mid + 1, right);
        else return mid;
        return -1;
    }
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章