常用查找算法汇总

1.折半查找

//折半查找的非递归实现
int BinSrch(SeqRList L, int K)//L为一个顺序查找表
{
    int low = 1, high = L.length, mid;
    while (low <= high)
    {
        mid = (low + high) / 2;
        if (k == L.r[mid].key) return mid;
        else if (K < L.r[mid].key) high = mid - 1;
        else low = mid + 1;
    }
    return 0;
}

2.基于二叉排序树查找的非递归实现

类似于折半查找

（1）若给定值等于根节点的关键字，则查找成功；

（2）若给定值小于根节点的关键字，则继续在左子树上进行查找；

（3）若给定值大于根节点的关键字，则继续在右子树上进行查找；

BSTree SearchBST(BSTree bst, KeyType K)
{
    BSTree q;
    q = bst;
    while (q)
    {
        if (q->key == K) return q;
        if (k->q - Key) q = qlchild;
        else q = q->child;
    }
    return NULL;
}

3.二叉排序树的插入

void InsertBST(BST *bst, KeyTYpe K)
{
    BinTree s;
    if (*bst == null)
    {
        s = (BSTree)malloc(sizeof(BSTNode));
        s->key = k;
        s->lchild = NULL;
        s->rchild = NULL;
        *bst = s;
    }
    else if (K < (*bst)->key) InsertBST(&((*bst)->lchild), k);
    else if (K > (*bst)->key) InsertBST(&((*bst)->rchild), k);
}

4.二叉排序树的建立

void CreatBST(BSTree *bst)
{
    KeyType key;
    *bst = NULL;
    scanf("%d", &key);
    while (key != ENDKEY)
    {
        InsertBST(bst, key);
        scanf("%d", &key);
    }
}

5.二叉排序树的删除

BSTNode *DelBST(BSTree bst, KeyType K)
{
    BSTNode *p, *f, *s, *q;
    p = bst;
    f = NUlL;
    while (p)
    {
        if (p->key == K) break;
        f = p;
        if (p->key > K) p = p->lchild;
        else p = p->rchild;
    }
    if (p == NULL) return bst;
    if (p->lchild == NULL)
    {
        if (f == NULL) bst = p->rchild;
        else if (f->lchild == p) f = lchild=p->rchild
        else   f = rchild=p->rchild;
        free(p);
    }
    else
    {
        q = p;
        s = p->child;
        while (s->rchild)
        {
            q = ;
            s = s->rchild;
        }
        if (q == p) q->lchild = s->lchild;
        else q->rchild = s->lchild;
        p->key = s->key;
        free(s);
    }
    return bst;
}

 6.顺序查找及折半查找测试

#include <stdio.h>
#include <string.h>
#include "malloc.h"
#define MAXSIZE 20

typedef int KeyType;
typedef struct
{
    KeyType key;
}RecordType;

typedef struct
{
    RecordType r[MAXSIZE + 1];
    int length;  //序列长度，即实际记录个数
}SeqList;

/*
该算法的时间代价主要消耗在while循环处
*/
int SeqSearch1(SeqList L, KeyType k)
{
    int i = L.length;
    while (i >= 1 && L.r[i].key != k)
    {
        i--;
    }
    if (i >= 1){
        return i;
    }
    else
        return 0;
}

/*
算大利用了0号位置作为监视哨，记录待查的关键字，平均查找长度为 （n+1）/2,
如果查找失败：  （n+1）/2 <平均查找次数<(n+1)
*/
int SeqSearch2(SeqList L, KeyType k)
{
    L.r[0].key = k;    //监视哨
    int i = L.length;
    while (L.r[i].key != k)
        i--;
    return i;
}

//折半查找(二分查找),平均查找长度为 (n+1)/n * (log 2) (n+1)-1
int BinSearch(SeqList L, KeyType k)
{
    int low = 1;
    int high = L.length;
    int mid;
    while (low < high)
    {
        mid = (low + high) / 2;
        if (L.r[mid].key == k)
            return mid;
        else if (L.r[mid].key >= k)
            high = mid - 1;
        else
            low = mid + 1;
    }
    return 0;

}
int main()
{
    int i = 0;
    SeqList L;
    for (int i = 1; i < MAXSIZE; i++){
        L.r[i].key = i;
        printf("%3d", L.r[i].key);
    }
    printf("
");
    L.length = MAXSIZE;
    i = SeqSearch1(L, i);
    printf("查找的位置为：%d
", i);
    i = SeqSearch2(L, i);
    printf("带监视哨查找：%d
", i);
    printf("折半查找：%d
", i);
    i = BinSearch(L, i);
    return 0;
}
/*
1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
查找的位置为：0
带监视哨查找：0
折半查找：0
请按任意键继续. . .
*/

 7.hash查找

1.哈希表的创建

void Createht(Hashtable ht, Datatype L[], int n)
{
    int i;
    for (i = 0; i < HASHSIZE; i++)
    {
        ht[i].data.key = NULL;
        ht[i].times = 0;
    }
    for (i = 0; i < n; i++)
        HashInsert(ht, L[i]);
}

2.哈希表的查找

int HashSearch(Hashtable ht, Datatype x)
{
    int address;
    address = HashFunc(x,key);  //计算散列地址
    while (ht[address].data.key!NULL&&ht[address].data.key!x.key)
        address = Collision(address);//没找到处理冲突
    if (ht[address].data.key == x.key) return address;
    else return -1;
}

3.哈希表的删除

int HashDel(Hashtable ht, Datatype x)
{
    int address;
    address = HashFunnc(x, key);
    if (address>=0)
    {
        ht[address].datakey = DEL;
        return 1;
    }
    return 0;
}

4.哈希表的插入

int HashInsert(Hashtable ht, Datatable x)
{
    int address;
    address = HashFunnc(x, key);
    if (address >= 0) return 0;
    ht[-address].data = x;
    ht[-address].times = 1;
    return 1;
}