算法-线性表的查找

线性表-查找

• 定义
• 结构体
• 顺序查找
• 改进的顺序查找
• 快速顺序查找
• 有序表的顺序查找

1.定义

查找又称检索,查找的第一是根据定值,在数据元素集合中搜索是否存在与给定值对应的数据元素.

查找包含以下几个要素

1.查找表.查找表是查找的对象,是同类数据元素的集合.

2.查找关键字.用于表示查找表中数据元素的数据项组合.

3.查找值.查找的目标

4.查找结果.执行查找操作的输出.

5查找算法.实现查找执行的过程和一系列步骤.

2.结构体

在SequenStruct.c

#include <stdio.h>

#define M 100
typedef struct {
    int data[M];
    int n;
}SEQUENLIST;

3.顺序查找

顺序查找是最为简单的查找方法,是一般简单”扫描”查找方法的计算机实现.

查找顺序表中,数据值为value,是否存在,存在返回对应的角标,否则返回-1

在Algorithm.h写出方法声明

/*
 打印顺序表中数据元素
 */
void printSequenList(SEQUENLIST A);
/*
 顺序查找
 */
int orderSearch(SEQUENLIST S,int value);

在Algorithm.c中实现此方法

#include "Algorithm.h"


void printSequenList(SEQUENLIST A){
    printf("sequen={");
    printf("{");
    int isFrist=0;
    for(int i=0;i<A.n;i++){
        if(isFrist==0){
             printf("%d",A.data[i]);
            isFrist=1;
        }else{
            printf(",%d",A.data[i]);
        }

    }
    printf("},%d",A.n);
    printf("}\n");
}

int orderSearch(SEQUENLIST S,int value){

    for(int i=0;i<S.n;i++){
        if(S.data[i]==value){
            return i;
        }
    }

    return -1;
}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "Algorithm.h"
int main(int argc, const char * argv[]) {
    SEQUENLIST S={{4,6,1,5,9,7,4,6,8,3},10};
     printSequenList(S);
     printf("顺序查找\n");
    int  value=9;
     int position=orderSearch(S, value);
    if(position==-1){
        printf("%d 不存在于顺序表S\n",value);
    }else{
        printf("%d 存在于顺序表S,position=%d\n",value,position);
    }


}

打印结果:

sequen={{4,6,1,5,9,7,4,6,8,3},10}
顺序查找
9 存在于顺序表S,position=4

4.改进的顺序查找

改进的顺序表查找和顺序查找的思想是一样的,改进之处:就是把在顺序表的最后增加了一个附加信息,也就是”哨兵”,其结点的关键字值置为要查找的值,这样每次就不需要每次显示判断否结束循环,减少了n-1此循环

在Algorithm.h写出方法声明

#include "SequenStruct.c"

/*
 改进的顺序查找
 */
int orderSearchV(SEQUENLIST S,int value);

在Algorithm.c中实现此方法

#include "Algorithm.h"

int orderSearchV(SEQUENLIST S,int value){


    S.data[S.n]=value;
    int i=0;
    while (S.data[i]!=value) {
        i++;
    }

    if(i<S.n){
        return i;
    }
    return -1;
}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "Algorithm.h"
int main(int argc, const char * argv[]) {
  SEQUENLIST S={{4,6,1,5,9,7,4,6,8,3},10};
     printSequenList(S);
     printf("改进顺序查找\n");
     int  value=6;
//     int position=orderSearch(S, value);
    int position=orderSearchV(S, value);
    if(position==-1){
        printf("%d 不存在于顺序表S\n",value);
    }else{
        printf("%d 存在于顺序表S,position=%d\n",value,position);
    }
 }

打印结果:

sequen={{4,6,1,5,9,7,4,6,8,3},10}
改进顺序查找
6 存在于顺序表S,position=1

注意:改进的快速查找,在表的尾部增加哨兵,顺序存储的时候,一定要增加的这个结点后,小于定义申请的空间,即:S.n+1

5.快速顺序查找

快速顺序查找就是递增循环的时候,i++,改为了i=i+2;

查找顺序表中,数据值为value,是否存在,存在返回对应的角标,否则返回-1

在Algorithm.h写出方法声明

/*
 快速查找
 */
int orderSearchQuick(SEQUENLIST S,int value);

在Algorithm.c中实现此方法

#include "Algorithm.h"
int orderSearchQuick(SEQUENLIST S,int value){

    S.data[S.n]=value;
    int i=0;
    while (S.data[i]!=value) {

        if(S.data[i+1]!=value){
            i=i+2;
           }else{
            i++;
            break;
          }

      }

    if(i<S.n){
        return i;
    }
    return -1;

}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "Algorithm.h"
int main(int argc, const char * argv[]) {
   SEQUENLIST S={{4,6,1,5,9,7,4,6,8,3},10};
     printSequenList(S);
     printf("快速查找\n");
     int  value=9;
//     int position=orderSearch(S, value);
//    int position=orderSearchV(S, value);
     int position=orderSearchQuick(S, value);
    if(position==-1){
        printf("%d 不存在于顺序表S\n",value);
    }else{
        printf("%d 存在于顺序表S,position=%d\n",value,position);
    }
    return 0;


}

打印结果:

sequen={{4,6,1,5,9,7,4,6,8,3},10}
快速查找
9 存在于顺序表S,position=4

6.有序表的顺序查找

前几个顺序查找,必须从第一个数据元素查找,一个一个的顺序查找,不能遗漏任何一个元素,时间效率比较低.但如果查找表关于关键字有序(设定为递增顺序),情况就不一样了.从第一个结点开始顺序逐个查找,若出现某个数据元素的关键字值大于等于查找值时,查找就可以立即停止,此数据后面的元素都大于查找值,就不需要比较了.

在Algorithm.h写出方法声明

/*
 有序表查找
 */
int orderOrderlySearch(SEQUENLIST S,int value);

在Algorithm.c中实现此方法

#include "Algorithm.h"

int orderOrderlySearch(SEQUENLIST S,int value){
    int i=0;
    for(i=0;i<S.n;i++){
        //1.如果相等则直接返回,查找成功
        if(S.data[i]==value){
            return i;
            break;
        }
        //2.如果当前的值大于了查找的值value,那么就查找失败,算法结束
        if(S.data[i]>value){
            return -1;
            break;
        }
    }
    return -1;
}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "Algorithm.h"
int main(int argc, const char * argv[]) {

    SEQUENLIST S={{1,2,3,4,5,6,7,7,8,8},10};
     printSequenList(S);
     printf("有序表的顺序查找\n");
     int  value=7;
//     int position=orderSearch(S, value);
//    int position=orderSearchV(S, value);
     int position=orderSearchQuick(S, value);
    if(position==-1){
        printf("%d 不存在于顺序表S\n",value);
    }else{
        printf("%d 存在于顺序表S,position=%d\n",value,position);
    }
    return 0;


}

打印结果:

sequen={{1,2,3,4,5,6,7,7,8,8},10}
有序表的顺序查找
7 存在于顺序表S,position=6

这是顺序表查找的几种基本算法,请大家指点,有好的建议请大家指出,有好的书籍,还往大家推荐!

源码下载