查找算法合集

1、順序搜索法

因爲不知道要查找元素的具體位置，只能一個元素一個元素的去判斷。

平均查找(n+1)/2

int find(int array[], int  length, int value)
{
    if(NULL == array || 0 == length)
        return -1;

    for(int index = 0; index < length; index++){
        if(value == array[index])
            return index;
        }
    return -1;
}

2、折半查找

對於一個有序數組，咱們就能夠經過二分查找的方法來提升查找效率。時間複雜度O(lgn)

二分查找有兩種寫法，須要特別注意邊界。

（1）左閉右閉[left,right]

也就是left = 0, right = n-1。這時的判斷條件時left < right。而且當去一邊的時候要mid+1或mid-1

int search(int array[], int n, int v)
{
    int left, right, middle;

    left = 0, right = n - 1;    //左閉右閉

    while (left <= right){      //循環條件
        middle = (left + right) / 2;
        if (array[middle] > v){
            right = middle - 1; //因爲middle不符合，全部要middle-1知足右閉
        }
        else if (array[middle] < v){
            left = middle + 1;  //同上，知足左閉
        }
        else{
            return middle;
        }
    }

    return -1;
}

（2）左閉右開[left,right)

也就是left = 0,right = n。這時不相等時，有left = mid+1 或 right = mid;

int search3(int array[], int n, int v)
{
    int left, right, middle;

    left = 0, right = n;    //左閉右開

    while (left < right){   //判斷條件，因爲是開，就必須不能相等
        middle = (left + right) / 2;

        if (array[middle] > v){
            right = middle; //知足右開
        }
        else if (array[middle] < v){
            left = middle + 1;  //知足左閉
        }
        else{
            return middle;
        }
    }

    return -1;
}

在循環體內,計算中間位置的時候,使用的是這個表達式:

middle = (left + right) / 2;

假如,left與right之和超過了所在類型的表示範圍的話,那麼middle就不會獲得正確的值.
因此,更穩妥的作法應該是這樣的:

middle = left + (right - left) / 2;

3、搜索二叉樹

上面的查找是創建在連續內存基礎之上的，那麼若是是指針類型的數據呢？怎麼辦呢？那麼就須要引入排序二叉樹了。排序二叉樹的定義很簡單：（1）非葉子節點至少一邊的分支非NULL；（2）葉子節點左右分支都爲NULL；（3）每個節點記錄一個數據，同時左分支的數據都小於右分支的數據。能夠看看下面的定義：

typedef struct _NODE
{
    int data;
    struct _NODE* left;
    struct _NODE* right;
}NODE;

const NODE* find_data(const NODE* pNode, int data){
    if(NULL == pNode)
        return NULL;

    if(data == pNode->data)
        return pNode;
    else if(data < pNode->data)
        return find_data(pNode->left, data);
    else
        return find_data(pNode->right, data);
}

4、哈希表法-----鏈式查找，相同映射的，放在一個鏈表中

咱們看到（2）、（3）都是創建在徹底排序的基礎之上，那麼有沒有創建在折中基礎之上的查找呢？有，那就是哈希表。哈希表的定義以下：1）每一個數據按照某種聚類運算歸到某一大類，而後全部數據鏈成一個鏈表；2）全部鏈表的頭指針造成一個指針數組。這種方法由於不須要完整排序，因此在處理中等規模數據的時候頗有效。其中節點的定義以下：

typedef struct _LINK_NODE
{
    int data;
    struct _LINK_NODE* next;
}LINK_NODE;

 那麼hash表下面的數據怎麼查找呢？

LINK_NODE* hash_find(LINK_NODE* array[], int mod, int data)
{
    int index = data % mod;
    if(NULL == array[index])
        return NULL;

    LINK_NODE* pLinkNode = array[index];
    while(pLinkNode){
        if(data == pLinkNode->data)
            return pLinkNode;
        pLinkNode = pLinkNode->next;
    }

    return pLinkNode;
}

 hash表由於不須要排序，只進行簡單的歸類，在數據查找的時候特別方便。查找時間的大小取決於mod的大小。mod越小，那麼hash查找就越接近於普通查找；那麼hash越大呢，那麼hash一次查找成功的機率就大大增長。