数据结构与算法（十六）-静态查找和动态查找

zyqi_ddb
364 阅读7分钟

静态查找

定义：只做查找操作。

  1. 顺序表查找

    定义：

    顺序查找(Sequential Search),⼜称为线性查找.是最基本的查找技术.
它的查找过程:从表中的第⼀个(或最后⼀个)记录开始,逐个进⾏记录关键字和给定值⽐较;
1.若某个记录的关键字和给定值相等,则查找成功,找到所查记录;
2.如果直到最后⼀个(或第⼀个)记录, 其关键字和给定值⽐较都不等时, 则表中没有所查的记录,查找不成功.

    //a为数组,n为查找的数组个数,key为要查找的关键字;
int Sequential_Search(int *a,int n,int key) {
    for (int i = 1; i <= n ; i++)
        if (a[i] == key)
            return i;
   
    return 0;
}

//顺序查找_哨兵（优化）
int Sequential_Search2(int *a,int n,int key) {
    int i;
    //设置a[0]为关键字值,称为'哨兵'
    a[0] = key;
    //循环从数组尾部开始
    i = n;
    while (a[i] != key) {
        i--;
    }
    //返回0,则说明查找失败
    return i;
}

  2. 折半查找

    定义：

    折半查找(Binary Search)技术,⼜称为⼆分查找.
它的前提是线性表中的记录必须是关键码有序(通常是从⼩到⼤有序),线性表必须采⽤顺序存储; 
折半查找的基本思想是:
在有序表中,取中间记录作为⽐较对象,若给定值与中间记录的关键字相等则查找成功;
若给定值⼩于中间的记录关键字,则在中间记录的左半区继续查找;
若给定的值⼤于中间记录的关键字,则在中间记录的右半区继续查找;
不断重复以上的过程,直到查找成功,或所以查找区域⽆记录,查找失败为⽌

    折半查找公式

    //假设数组a,已经是有序的(从小到大)
int Binary_Search(int *a,int n,int key) {
    int low,high,mid;
    //定义最低下标为记录首位
    low = 1;
    //定义最高下标为记录末位
    high = n;
    while (low <= high) {
        //折半计算
        mid = (low + high) /2;
        if (key < a[mid]) {
            //若key比a[mid] 小,则将最高下标调整到中位下标小一位;
            high = mid-1;
        } else if(key > a[mid]) {
             //若key比a[mid] 大,则将最低下标调整到中位下标大一位;
            low = mid+1;
        } else
            //若相等则说明mid即为查找到的位置;
            return mid;
    }
    return 0;
}

  3. 插值查找

    定义：是根据查找的关键字key 与查找表中最⼤最⼩记录的关键字⽐较后的查找⽅法

    插值查找公式

    int Interpolation_Search(int *a,int n,int key) {
    int low,high,mid;
    low = 1;
    high = n;
    while (low <= high) {
        //插值
        mid = low+ (high-low)*(key-a[low])/(a[high]-a[low]);
        if (key < a[mid]) {
            //若key比a[mid]插值小,则将最高下标调整到插值下标小一位;
            high = mid-1;
        } else if(key > a[mid]) {
            //若key比a[mid]插值 大,则将最低下标调整到插值下标大一位;
            low = mid+1;
        } else
            //若相等则说明mid即为查找到的位置;
            return mid;
    }
    return 0;
}

  4. 斐波拉契查找

    斐波拉契查找公式

        F[0]=0;
    F[1]=1;
    for(i = 2;i < 100;i++)
    {
        F[i] = F[i-1] + F[i-2];
    }

    int F[100]; /* 斐波那契数列 */
int Fibonacci_Search(int *a,int n,int key) {
    int low,high,mid,i,k;
    //最低下标为记录的首位;
    low = 1;
    //最高下标为记录的末位;
    high = n;
    k = 0;
    
    //1.计算n为斐波拉契数列的位置;
    while (n > F[k]-1) {
        k++;
    }
    
    //2.将数组a不满的位置补全值;
    for (i = n;i < F[k]-1;i++)
        a[i] = a[n];
    
    //3.
    while (low <= high) {
        //计算当前分隔的下标;
        mid = low+F[k-1]-1;
        if (key < a[mid]) {
            //若查找的记录小于当前分隔记录;
            //将最高下标调整到分隔下标mid-1处;
            high = mid-1;
            //斐波拉契数列下标减1位;
            k = k-1;
        } else if(key > a[mid]) {
            //若查找的记录大于当前的分隔记录;
            //最低下标调整到分隔下标mid+1处
            low = mid+1;
            //斐波拉契数列下标减2位;
            k = k-2;
            
        } else {
            if (mid <= n) {
                //若相等则说明,mid即为查找的位置;
                return mid;
            } else {
                //若mid>n,说明是补全数值,返回n;
                return n;
            }
        }
    }
    return 0;
}

动态查找

定义：在查找或删除过程中同时插入表中不存在的数据元素。

  1. ⼆叉排序树(Binary Sort Tree)

    定义：

    ⼆叉排序树(Binary Sort Tree),⼜称为⼆叉查找树. 它或者是⼀颗空树.
或者是⼀颗具有下列性质的⼆叉树;
1.若它的左⼦树不空,则左⼦树上所有结点的值均⼩于它的根结构的值;
2.若它的右⼦树不空,则右⼦树上的所有结点的值均⼤于它的根结点的值;
3.它的左右⼦树也分别是⼆叉排序树

    #define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100
typedef int Status;

//二叉树的二叉链表结点结构定义
//结点结构
typedef struct BiTNode {
    //结点数据
    int data;
    //左右孩子指针
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

    //1.二叉排序树--查找
/*
 递归查找二叉排序树T中,是否存在key;
 指针f指向T的双亲,初始值为NULL;
 若查找成功,则指针p指向该数据元素的结点,并且返回TRUE;
 若指针p指向查找路径上访问的最后一个结点则返回FALSE;
 */
Status SearchBST(BiTree T,int key,BiTree f, BiTree *p) {
    if (!T) {//查找不成功
        *p = f;
        return FALSE;
    } else if (key == T->data) {//查找成功
        *p = T;
        return TRUE;
    } else if (key < T->data)
        return SearchBST(T->lchild, key, T, p);  /*  在左子树中继续查找 */
    } else {
        return SearchBST(T->rchild, key, T, p);  /*  在右子树中继续查找 */
    }
}

//2.二叉排序树-插入
/*  当二叉排序树T中不存在关键字等于key的数据元素时， */
/*  插入key并返回TRUE，否则返回FALSE */
Status InsertBST(BiTree *T, int key) {
    BiTree p,s;
    //1.查找插入的值是否存在二叉树中;查找失败则->
    if (!SearchBST(*T, key, NULL, &p)) {
        //2.初始化结点s,并将key赋值给s,将s的左右孩子结点暂时设置为NULL
        s = (BiTree)malloc(sizeof(BiTNode));
        s->data = key;
        s->lchild = s->rchild = NULL;
        
        //3.
        if (!p) {
            //如果p为空,则将s作为二叉树新的根结点;
            *T = s;
        } else if(key < p->data) {
            //如果key<p->data,则将s插入为左孩子;
            p->lchild = s;
        } else
            //如果key>p->data,则将s插入为右孩子;
            p->rchild = s;
        return  TRUE;
    }
    return FALSE;
}

//3.从二叉排序树中删除结点p,并重接它的左或者右子树;
Status Delete(BiTree *p) {
    BiTree temp,s;
    if ((*p)->rchild == NULL) {
        //情况1: 如果当前删除的结点,右子树为空.那么则只需要重新连接它的左子树;
        //①将结点p临时存储到temp中;
        temp = *p;
        //②将p指向到p的左子树上;
        *p = (*p)->lchild;
        //③释放需要删除的temp结点;
        free(temp);
        
    } else if((*p)->lchild == NULL) {
        //情况2:如果当前删除的结点,左子树为空.那么则只需要重新连接它的右子树;
        //①将结点p存储到temp中;
        temp = *p;
        //②将p指向到p的右子树上;
        *p = (*p)->rchild;
        //③释放需要删除的temp结点
        free(temp);
    } else {
        //情况③:删除的当前结点的左右子树均不为空;
        //①将结点p存储到临时变量temp, 并且让结点s指向p的左子树
        temp = *p;
        s = (*p)->lchild;
      
        //②将s指针,向右到尽头(目的是找到待删结点的前驱)
        //-在待删除的结点的左子树中,从右边找到直接前驱
        //-使用`temp`保存好直接前驱的双亲结点
        while (s->rchild) {
            temp = s;
            s = s->rchild;
        }
        
        //③将要删除的结点p数据赋值成s->data;
        (*p)->data = s->data;
        
        //④重连子树
        //-如果temp 不等于p,则将S->lchild 赋值给temp->rchild
        //-如果temp 等于p,则将S->lchild 赋值给temp->lchild
        if (temp != *p)
            temp->rchild = s->lchild;
        else
            temp->lchild = s->lchild;
        
        //⑤删除s指向的结点; free(s)
        free(s);
    }
    return  TRUE;
}

//4.查找结点,并将其在二叉排序中删除;
/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点, */
/* 并返回TRUE；否则返回FALSE。 */
Status DeleteBST(BiTree *T,int key) {
    //不存在关键字等于key的数据元素
    if(!*T) {
        return FALSE;
    } else {
        //找到关键字等于key的数据元素
        if (key == (*T)->data)
            return Delete(T);
        else if (key < (*T)->data)
            //关键字key小于当前结点,则缩小查找范围到它的左子树;
            return DeleteBST(&(*T)->lchild,key);
        else
            //关键字key大于当前结点,则缩小查找范围到它的右子树;
            return DeleteBST(&(*T)->rchild,key);
    }
}
avatar
文章
阅读
粉丝