基本查找算法

来源：互联网发布：淘宝手机详情页尺寸编辑：程序博客网时间：2024/05/08 09:09

基本查找算法简介

一、查找的基本概念

查找，也可称检索，是在大量的数据元素中找到某个特定的数据元素而进行的工作。查找是一种操作。

二、顺序查找

针对无序序列的一种最简单的查找方式。

时间复杂度为O(n)。

三、折半查找

针对已排序序列的一种查找方式。并且只适用于顺序存储结构的序列。要求序列中的元素基本不变，在需要做删除和插入操作的时候，会影响检索效率。时间复杂度为O(logN)。

四、二叉排序树（Binary Sort Tree）。

1、概念：

　它或者是一棵空树；或者是具有下列性质的二叉树：

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

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

　　(3)左、右子树也分别为二叉排序树；

2、查找：

时间复杂度与树的深度的有关。

　　步骤：若根结点的关键字值等于查找的关键字，成功。

　　否则：若小于根结点的关键字值，递归查左子树。

　　若大于根结点的关键字值，递归查右子树。

　　若子树为空，查找不成功。

3、插入：

首先执行查找算法，找出被插结点的父亲结点。

　　判断被插结点是其父亲结点的左儿子还是右儿子。将被插结点作为叶子结点插入。

　　若二叉树为空。则首先单独生成根结点。

　　注意：新插入的结点总是叶子结点，所以算法复杂度是O(h)。

4、删除：

　　如果删除的结点没有孩子，则删除后算法结束；

　　如果删除的结点只有一个孩子，则删除后该孩子取代被删除结点的位置；

如果删除的结点有两个孩子，则选择该结点的后继结点（该结点右孩子为根的树中的左子树中的值最小的点）作为新的根，同时在该后继结点开始，执行前两种删除算法，删除算法结束。

五、散列（hash）表（哈希查找）

关键字：哈希函数、装填因子、冲突、同义词；

关键字和和存储的地址建立一个对应的关系：

(一) 哈希函数Address =Hash(key) 可以用以下的规则定义：

1. 直接定址法:

比如有一组0-100的数据，用来表示人的年龄那么，采用直接定址的方法构成的哈希表为:

0岁

１岁

２岁

３岁

４岁

５岁

.....这样的一种定址方式，简单方便，适用于元数据能够用数字表述或者原数据具有鲜明顺序关系的情形。

2. 数字分析法:

有这样一组数据，用于表述一些人的出生日期

年

月

日

７５

１０

１

７５

１２

１０

７５

０２

１４

分析一下，年和月的第一位数字基本相同，造成冲突的几率非常大，而后面三位差别比较大，所以采用后三位

3. 平方取中法

取关键字平方后的中间几位作为哈希地址

4. 折叠法：

将关键字分割成位数相同的几部分，最后一部分位数可以不相同，然后去这几部分的叠加和（取出进位）作为哈希地址，比如有这样的数据20-1445-4547-3，可以

       5473
+      4454
+        201
=    10128
取出进位1,取0128为哈希地址

5. 取余法

取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址。H(key)=key MOD p (p<=m)

6. 随机数法

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key)=random(key) ,其中random为随机函数。通常用于关键字长度不等时采用此法。

(二) 解决冲突的方法有以下两种：　　

(1)开放地址法　　

如果两个数据元素的哈希值相同，则在哈希表中为后插入的数据元素另外选择一个表项。当程序查找哈希表时，如果没有在第一个对应的哈希表项中找到符合查找要求的数据元素，程序就会继续往后查找，直到找到一个符合查找要求的数据元素，或者遇到一个空的表项。　　

(2)链地址法

将哈希值相同的数据元素存放在一个链表中，在查找哈希表的过程中，当查找到这个链表时，必须采用线性查找方法。

算法实现

一、顺序查找

说明：顺序查找适合于存储结构为顺序存储或链接存储的线性表

/** *  在s[0]-s[n-1]中顺序查找关键字为Key的记录 ,查找成功时返回该记录的下标序号；失败时返回-1  */int SequelSearch(elemtype s[], keytype Key, int n){    int i;    i = 0;    while(i < n && s[i].Key != Key)        i++;    if(s[i].Key == Key)        return i;    else        return -1;}

二、二分查找

前提:元素必须是有序的，如果是无序的则要先进行排序操作

1.递归实现

/** * 在下届为low，上界为high的数组a中折半查找数据元素x */int binarySearch(elemtype a[], elemtype x, int low, int high){    int mid;    if(low > high)        return -1;    mid = (low + high)/2;    if(x == a[mid])        return mid;    if(x < a[mid])        return binarySearch(a, x, low, mid-1);    else        return binarySearch(a, x, mid+1, high);}

2.非递归实现

int binarySearch(elemtype a[], keytype key, int n){    int low, high, mid;    low  = 0;    high = n - 1;    while(low <= high){        mid= (low + high) / 2;        if(a[mid].key == key)            return mid;        else if (a[mid].key < key)            low  = mid + 1;        else            high = mid - 1;    }    return -1;}

三、分块查找

typedef intkeytype;typedef struct {    keytype Key;}elemtype; typedef struct{    keytype Key;    int Link;}indextype; /** * 分块查找关键字为Key的记录。索引表为ls[0]-ls[m-1],顺序表为s，块长为l */int IndexSequelSearch(indextype ls[], elemtype s[], int m, int l, keytype Key){    int i,j;    /*在索引表中顺序查找*/    i = 0;    while(i<m && Key>ls[i].Key) i++;        if(i>=m)            return -1;        else{            /*在顺序表中顺序查找*/            j = ls[i].Link;            while(Key!=s[j].Key && j-ls[i].Link<l)                j++;            if(Key==s[j].Key)                return j;            else                return -1;        }}

四、二叉树查找

1.二叉树查找算法

a.递归算法

btree *search(btree *b,int x){    /*在二叉树b中查找x的过程*/    if(b == NULL)        return NULL;    else {        if(b->data == x)            return b;        if(x < b->data)            return search(b->left, x);        else            return search(b->right, x);    }}

b.非递归算法

bsnodetype *Search(bsnodetype *bt, keytype Key){    /*在二叉树bt中查找元素为Key的元素*/    bsnodetype *p;    if(bt == NULL)        return bt;    p=bt;    while(p->Key != Key){        if(Key < p->Key)            p = p->Lchild;        else            p = p->Rchild;        if(p == NULL)            break;    }    return p;}

2.生成二叉树

a、向一个二叉树b中插入一个结点s的函数如下：

void insert(btree *b, btree *s){    if(b == NULL)        b = s;    else if(s->data == b->data)        return;    else if(s->data < b->data)        insert(b->left, s);    else if(s->data > b->data)        insert(b->right, s);}

b、创建二叉树

void create(btree *b){    int x;    bnode *s;    b == NULL;    while(x != -1){        scanf("%d",&x);        s = (bnode *)malloc(sizeof(bnode));        s->data  = x;        s->left  = NULL;        s->right = NULL;        insert(b,s);    }}

c、从二叉树中删除一个结点

bnode *Delete(bnode *bt, keytype Key){    /*在bt为根结点的二叉树中删除值为Key的结点*/    bnode *p,*q;    if(bt->Key==Key){        /*bt的左右子树均为空*/        if(bt->Lchild==NULL && bt->Rchild==NULL) {            free(bt); /*删除叶结点*/            return NULL;        } else if(bt->Lchild == NULL) {/*bt的左子树为空*/            p = bt->Rchild;            free bt;            return p;        } else if(bt->Rchild == NULL) {/*bt的右子树为空*/            p = bt->Lchild;            free bt;            return p;        } else {            p = q = bt->Rchild;            while(p->Lchild != NULL)                p = p->Lchild;            p->Lchild = bt->Lchild;            free bt;            return q;        }    }        /*在bt->Lchild为根结点的二叉树中删除值为Key的结点*/    if(bt->Key>Key && bt->Lchild!=NULL)        bt->Lchild = Delete(bt->Lchild, Key);    /*在bt->Rchild为根结点的二叉树中删除值为Key的结点*/    if(bt->Key<Key && bt->Rchild!=NULL)        bt->Rchild=Delete(bt->Rchild,Key);    return bt;}

五、哈希查找

实现哈希函数为“除法取余法”，解决冲突为“开放地址线性探测法”，代码如下：

public class HashSearch {        public static void main(String[] args)    {        //“除法取余法”        int hashLength = 13;        int [] array = { 13, 29, 27, 28,26, 30, 38 };        //哈希表长度        int[] hash = new int[hashLength];        //创建hash        for (int i = 0; i < array.length; i++)        {            insertHash(hash, hashLength, array[i]);        }        int result = searchHash(hash,hashLength, 29);        if(result != -1)            System.out.println("已经在数组中找到，索引位置为：" + result);        else            System.out.println("没有此原始");    }     /****     * Hash表检索数据     * @param hash     * @param hashLength     * @param key     * @return     */    public static int searchHash(int[] hash, int hashLength, int key)    {        //哈希函数        int hashAddress = key % hashLength;        //指定hashAdrress对应值存在但不是关键值，则用开放寻址法解决        while(hash[hashAddress] != 0 && hash[hashAddress] != key){            hashAddress= (++hashAddress) % hashLength;        }        //查找到了开放单元，表示查找失败        if(hash[hashAddress] == 0)            return -1;        return hashAddress;    }     /***     * 数据插入Hash表     * @param hash 哈希表     * @param hashLength     * @param data     */    public static void insertHash(int[] hash, int hashLength, int data)    {        //哈希函数        int hashAddress = data % hashLength;        //如果key存在，则说明已经被别人占用，此时必须解决冲突        while(hash[hashAddress] != 0) {            //用开放寻址法找到            hashAddress= (++hashAddress) % hashLength;        }        //将data存入字典中        hash[hashAddress]= data;    }}

运行结果：

已经在数组中找到，索引位置为：3

总结：

一、线性查找

又称顺序查找，是从数组的第一个元素开始查找，直到找到待查找元素的位置，直到查找到结果。

最佳的状况时间是1 ，就是第一个就是待查找的远射，最差的查找状况是O（n），就是最后一个是待查找的元素。

二、折半查找

折半查找是将待查找的数组元素不断的分为两部分，每次淘汰二分之一，但是有个大前提是，元素必须是有序的，如果是无序的则要先进行排序操作，这种查找的方法，类似于找英文字典的Java，我们可以一下子找到字母J开头的，再仔细找。

最佳的状况时间是1，就是第一次分开就查找到了，最差的查找状态是O（n），便是待查找的数据出现在最后一次。

三、插补查找

插补查找是一种类似折半查找的查找方法，插补查找是以比例的概念，求出待查找数据的可能位置，然后进行比较，如果该值比待查找的小，表示待查找的值可能出现在该值之前的范围，就这样一直缩小范围来确定最终的目标。

四、二叉查找树