C/C++查找之一（顺序查找、折半查找（二分查找））

一、顺序查找

　　条件：无序或有序队列。

　　原理：按顺序比较每个元素，直到找到关键字为止。

时间复杂度：O(n)

 

二、二分查找（折半查找）

　　条件：有序数组

　　原理：查找过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；

　　　　　如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。

　　　　　如果在某一步骤数组为空，则代表找不到。

 

　　　　　这种搜索算法每一次比较都使搜索范围缩小一半。（递归与非递归算法）

时间复杂度：O(logn)

 

三、二叉排序树查找

　　条件：先创建二叉排序树：

　　　　　 1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

　　　　　 2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

　　　　　 3. 它的左、右子树也分别为二叉排序树。

　　原理：

　　　　在二叉查找树b中查找x的过程为：

　　　　1. 若b是空树，则搜索失败，否则：

　　　　2. 若x等于b的根节点的数据域之值，则查找成功；否则：

　　　　3. 若x小于b的根节点的数据域之值，则搜索左子树；否则：

　　　　4. 查找右子树。

时间复杂度：O(logn)

 

四、哈希表法（散列表）

　　条件：先创建哈希表（散列表）

　　原理：根据键值方式(Key value)进行查找，通过散列函数，定位数据元素。

时间复杂度：几乎是O(1)，取决于产生冲突的多少。

 

五、分块查找

　　原理：将n个数据元素"按块有序"划分为m块（m ≤ n）。

　　　　　每一块中的结点不必有序，但块与块之间必须"按块有序"；即第1块中任一元素的关键字都必须小于第2块中任一元素的关键字；

　　　　　而第2块中任一元素又都必须小于第3块中的任一元素，……。

然后使用二分查找及顺序查找。

 

http://www.cnblogs.com/butyoux/archive/2013/01/15/2861291.html

 

下面是顺序查找和折半查找的代码实现

进行查找算法，首先得明确数据的存储结构：顺序存储（数组）或链式存储（链表）

对于顺序存储，可以有：顺序查找和折半查找（对于后者的前提是此顺序表是有序的）；

对于链式存储，只能进行顺序查找。

1、顺序表的顺序查找

//顺序表的查找
#include <iostream>
void search(int *data, int n, int t)
{
    int i, num=0;
    for(i = 0; i < n; i++)
    {
        if(*(data + i) == t)
        {
            std::cout << t << "是数组中的第" << i + 1 << "元素!" << std::endl;
            num ++;
        }
    }
    if(num == 0)
        std::cout << "无待查找的数" << t << std::endl;
}
int main()
{
    int data[] = {1, 43, 32, 32, 56, 22, 34};
    search(data, 7, 6);//7代表数组元素个数，6代表待查找的数
    search(data, 7, 32);
    return 0;
}

 2、有序顺序表的折半查找

//有序顺序表的折半查找
#include <iostream>

int binary_search(int *begin, int *end, int t)
{
    int *middle;
    
    while(begin <= end)
    {
        middle = begin + (end - begin) / 2;
        
        if(*middle > t)
        
            end = middle - 1;
            
        else if(*middle < t)
        
            begin = middle + 1;
            
        else
        {
            std::cout << t << "存在"<< std::endl;
            
            return *middle;
        }

    }
    if(begin > end)
    
        std::cout << "无此数" << t << std::endl;
}
int main()
{
    int data[] = {1, 3, 4, 8, 12, 34, 45, 56, 100};
    
    binary_search(data + 0, data + 8, 12);//12为待查找的数
    
    binary_search(data + 0, data + 8, 32);
    
    return 0;
}

 3、线性链表的顺序查找

#include <iostream>
#include <stdlib.h>

struct list
{
    int data;
    struct list *next;
};

//头插法建立链表
struct list *headcreate()
{
    struct list *head, *p;
    int N, i;
    head = NULL;
    std::cout << "输入要建立的链表结点个数N=";
    std:: cin >> N;
    std::cout << "输入" << N << "个数:";
    for(i = 0; i < N; i ++)
    {
        p = (struct list *)malloc(sizeof(struct list));
        std::cin >> p->data;
        p->next = head;
        head = p;
    }
    return head;
}

//打印链表
void print(struct list *head)
{
    struct list *p;
    p = head;
    while(p)
    {
        std::cout << p->data << " ";
        p = p->next;
    }
    std::cout << std::endl;
}

//顺序查找链表结点
void search(struct list *head, int X)
{
    struct list *p;
    p = head;
    while(p)
    {
        if(p->data == X)
        {
            std::cout << X << "存在" << std::endl;
            break;
        }
        else
            p = p->next;
    }
    if(!p)
        std::cout << X << "不存在" << std::endl;
}

int main()
{
    struct list *head;

    head=headcreate();
    std::cout << "头插法建立链表:";
    print(head);

    search(head,10);//10为待查找的数

    return 0;
}