【数据结构】5.1 顺序表的查找以及二分查找的实现

最新推荐文章于 2023-04-16 10:00:20 发布
最新推荐文章于 2023-04-16 10:00:20 发布
阅读量1k 收藏 3
点赞数
文章标签： 数据结构与算法 c/c++
原文链接：http://www.cnblogs.com/robotpaul/p/10148374.html
版权

类的结构如下：

class StaticSearchTable {
private:
    int *data;
    int data_number;
    bool search_seq(int loc,int key);
    void select_sort();
    bool flag;//区分是否为顺序表
    
public:
    StaticSearchTable(int n,bool flag);
    int Search_Seq(int key);//顺序查找
    int Search_Bs(int key);//折半查找（前提是必须是有序表）
    void print();
};

类的构造函数，这里加入了一个标志flag用来区分要创建的是顺序表还是无序表（有序表即执行一次选择排序）

StaticSearchTable::StaticSearchTable(int n,bool flag)
{
    this->flag = flag;
    srand(time(NULL));
    //n为数组元素个数，但是0是不存放数值的故data空间要多开一个
    data = new int[n + 1];
    for (int i = 0; i < n; i++)
    {
        data[i + 1] = rand()%100;//0~99
    }
    data_number = n + 1;
    if (flag)
    {
        select_sort();
    }
    
}

二分法查找：

int StaticSearchTable::Search_Bs(int key)
{
    
    //设置三个变量low,mid,high保存数组的开始中间和末尾的序号
    int low = 1;
    int high = data_number;
    int result = 0;
    /*1.如果序号为mid的数组元素的值与x相等，相当于查找到了数据，返回mid
      2.如果x<a[mid]，表示要查找的数据x位于low与mid-1序号之间
      就不需要再去查找mid与high序号之间的元素了。因此将high变量的值改为mid-1,
      重新查找low与mid-1(即high变量的新值)之间的数据
    3.如果x>a[mid],表示要查找的数据x位于mid+1与high序号之间，就不需要再去查找low
      与mid序号之间的元素了。因此，将low变量的值改为mid+1，重新查找mid+1(即low变
      量的新值)与high之间的数据
    4.逐步循环，如果到low>high时还未找到目标数据x，则表示数组中无此数据*/
    while (low <= high)
    {
        int mid = (low + high) / 2;
        if (data[mid] == key)
        {
            result = mid;
            break;
        }
        else if (key < data[mid])
        {
            high = mid - 1;
        }
        else
        {
            low = mid + 1;
        }
    }
    return result;
}

直接查找，引入哨兵机制，减少判断次数：

int StaticSearchTable::Search_Seq(int key)
{
    int i;
    data[0] = key;//哨兵，判断是否已经完成整个顺序表的遍历操作
    for (i = data_number; !search_seq(i, key); i--);//从后往前查找
    return i;//i若返回0即查找失败
}

所有查找如果失败都是返回0，在主函数代码中加一个判断即可

下面给出菜单设计：

第一层菜单

void menu()//模拟菜单选项
{
    cout << " ------------------------------------------------------" << endl;
    cout << " |       1____________无序顺序表查找                  |" << endl;
    cout << " |       2____________有序顺序表查找                  |" << endl;
    cout << " |       0____________退出系统                        |" << endl;
    cout << " ------------------------------------------------------" << endl;
}
View Code

第二层菜单

void SortedMenu()//有序顺序表模拟菜单选项
{
    cout << " ------------------------------------------------------" << endl;
    cout << " |       1____________有序顺序查找                    |" << endl;
    cout << " |       2____________有序折半查找                    |" << endl;
    cout << " |       0____________返回                            |" << endl;
    cout << " ------------------------------------------------------" << endl;
}
View Code

总测试函数（通过switch case 和死循环来实现，最后的return 0以及 system(pause)可以删去，因为按0直接是exit(0)）

int main()
{

    while (1)
    {
        menu();
        int select;
        cout << "请输入您的选择：";    
        cin >> select;
        switch (select)
        {
        case 1:    //无序顺序表查找
        {    
            cout << "请输入无序表中的元素个数：";
            int n;
            cin >> n;
            StaticSearchTable L(n,false);
            L.print();//输出产生的无序表的元素
        while (1)
        {
            cout << "请输入待查找的关键字：";
            int k;
            cin >> k;
            int result = L.Search_Seq(k);
            if (result > 0)
                cout << "查找成功，为第" << result << "个元素." << endl;
            else
                cout << "查找失败，没有关键字为" << k << "的元素." << endl;
            char finish;
            cout << "继续查找吗？(y/n)";
            cin >> finish;
            if (finish == 'n' || finish == 'N')
                break;
        }
        break;
        }
        case 2://有序顺序表查找
        {
            
            cout << "请输入有序表中的元素个数：";
            int n;
            cin >> n;
            StaticSearchTable L(n,true);
            L.print();//输出产生的有序表的元素
            SortedMenu();//有序顺序表查找选项菜单
            while (1)
            {
                int subSelect;
                cout << "请输入选择：";
                cin >> subSelect;
                if (subSelect == 0)//返回上一级
                    break;
                int k;
                cout << "请输入待查找的关键字：";
                cin >> k;
                int result;
                if (subSelect == 1)
                    result = L.Search_Seq(k);//有序顺序查找
                else if (subSelect == 2)
                    result = L.Search_Bs(k);//折半查找
                else
                {
                    cout << "选择错误，请重新输入！" << endl;
                    continue;
                }
                if (result > 0)
                    cout << "查找成功，为第" << result << "个元素." << endl;
                else
                    cout << "查找失败，没有关键字为" << k << "的元素." << endl;
            }
            break;
        }
        case 0:
            exit(0);
        default:
            cout << "您输入的选项有误，请重新输入：";
        }
    }
    system("pause");
    return 0;
}
View Code

完整代码：

/*设计查找顺序表类，实现顺序表（在无序和有序两种情况）
的顺序查找和折半查找等操作。*/
#include<iostream>
#include<ctime>
using namespace std;
class StaticSearchTable {
private:
    int *data;
    int data_number;
    bool search_seq(int loc,int key);
    void select_sort();
    bool flag;//区分是否为顺序表
    
public:
    StaticSearchTable(int n,bool flag);
    int Search_Seq(int key);//顺序查找
    int Search_Bs(int key);//折半查找（前提是必须是有序表）
    void print();
};
StaticSearchTable::StaticSearchTable(int n,bool flag)
{
    this->flag = flag;
    srand(time(NULL));
    //n为数组元素个数，但是0是不存放数值的故data空间要多开一个
    data = new int[n + 1];
    for (int i = 0; i < n; i++)
    {
        data[i + 1] = rand()%100;//0~99
    }
    data_number = n + 1;
    if (flag)
    {
        select_sort();
    }
    
}
bool StaticSearchTable::search_seq(int loc,int key)
{
    if (!data)
    {
        exit(1);
    }
    return data[loc] == key;
}
int StaticSearchTable::Search_Seq(int key)
{
    int i;
    data[0] = key;//哨兵，判断是否已经完成整个顺序表的遍历操作
    for (i = data_number; !search_seq(i, key); i--);//从后往前查找
    return i;//i若返回0即查找失败
}
int StaticSearchTable::Search_Bs(int key)
{
    
    //设置三个变量low,mid,high保存数组的开始中间和末尾的序号
    int low = 1;
    int high = data_number;
    int result = 0;
    /*1.如果序号为mid的数组元素的值与x相等，相当于查找到了数据，返回mid
      2.如果x<a[mid]，表示要查找的数据x位于low与mid-1序号之间
      就不需要再去查找mid与high序号之间的元素了。因此将high变量的值改为mid-1,
      重新查找low与mid-1(即high变量的新值)之间的数据
    3.如果x>a[mid],表示要查找的数据x位于mid+1与high序号之间，就不需要再去查找low
      与mid序号之间的元素了。因此，将low变量的值改为mid+1，重新查找mid+1(即low变
      量的新值)与high之间的数据
    4.逐步循环，如果到low>high时还未找到目标数据x，则表示数组中无此数据*/
    while (low <= high)
    {
        int mid = (low + high) / 2;
        if (data[mid] == key)
        {
            result = mid;
            break;
        }
        else if (key < data[mid])
        {
            high = mid - 1;
        }
        else
        {
            low = mid + 1;
        }
    }
    return result;
}
void StaticSearchTable::select_sort()
{
    for (int i = 1; i < data_number; i++)
    {
        for (int j = i + 1; j < data_number; j++)
        {
            if (data[i] > data[j])
            {
                int temp = data[j];
                data[j] = data[i];
                data[i] = temp;
            }
        }
    }
    flag = true;//是顺序表
}
void StaticSearchTable::print()
{
    if (flag)
    {
        cout << "顺序表为:  ";
    }
    else
    {
        cout << "无序表为:  ";
    }
    for (int i = 1; i < data_number; i++)
    {
        cout << data[i] << " ";
    }
    cout << endl;
    
}
void menu()//模拟菜单选项
{
    cout << " ------------------------------------------------------" << endl;
    cout << " |       1____________无序顺序表查找                  |" << endl;
    cout << " |       2____________有序顺序表查找                  |" << endl;
    cout << " |       0____________退出系统                        |" << endl;
    cout << " ------------------------------------------------------" << endl;
}
void SortedMenu()//有序顺序表模拟菜单选项
{
    cout << " ------------------------------------------------------" << endl;
    cout << " |       1____________有序顺序查找                    |" << endl;
    cout << " |       2____________有序折半查找                    |" << endl;
    cout << " |       0____________返回                            |" << endl;
    cout << " ------------------------------------------------------" << endl;
}

int main()
{

    while (1)
    {
        menu();
        int select;
        cout << "请输入您的选择：";    
        cin >> select;
        switch (select)
        {
        case 1:    //无序顺序表查找
        {    
            cout << "请输入无序表中的元素个数：";
            int n;
            cin >> n;
            StaticSearchTable L(n,false);
            L.print();//输出产生的无序表的元素
        while (1)
        {
            cout << "请输入待查找的关键字：";
            int k;
            cin >> k;
            int result = L.Search_Seq(k);
            if (result > 0)
                cout << "查找成功，为第" << result << "个元素." << endl;
            else
                cout << "查找失败，没有关键字为" << k << "的元素." << endl;
            char finish;
            cout << "继续查找吗？(y/n)";
            cin >> finish;
            if (finish == 'n' || finish == 'N')
                break;
        }
        break;
        }
        case 2://有序顺序表查找
        {
            
            cout << "请输入有序表中的元素个数：";
            int n;
            cin >> n;
            StaticSearchTable L(n,true);
            L.print();//输出产生的有序表的元素
            SortedMenu();//有序顺序表查找选项菜单
            while (1)
            {
                int subSelect;
                cout << "请输入选择：";
                cin >> subSelect;
                if (subSelect == 0)//返回上一级
                    break;
                int k;
                cout << "请输入待查找的关键字：";
                cin >> k;
                int result;
                if (subSelect == 1)
                    result = L.Search_Seq(k);//有序顺序查找
                else if (subSelect == 2)
                    result = L.Search_Bs(k);//折半查找
                else
                {
                    cout << "选择错误，请重新输入！" << endl;
                    continue;
                }
                if (result > 0)
                    cout << "查找成功，为第" << result << "个元素." << endl;
                else
                    cout << "查找失败，没有关键字为" << k << "的元素." << endl;
            }
            break;
        }
        case 0:
            exit(0);
        default:
            cout << "您输入的选项有误，请重新输入：";
        }
    }
    system("pause");
    return 0;
}
View Code

 

测试结果：

转载于:https://www.cnblogs.com/robotpaul/p/10148374.html

weixin_30588827
关注
查找算法之顺序查找和二分查找
xiaoyong5854的博客
05-24 8862
1.顺序查找 代码如下： #include<cstdio> #include<iostream> using namespace std; const int maxn = 110; int arr[maxn]; int SequenceSearch(int arr[],int key, int n); int main(){ int n,key; printf("请输入元素的个数:\n"); scanf("%d",&n); printf("请输入数组
python实现算法与数据结构基础-链表、栈、队列、排序算法、二分查找、二叉树
Sun123234的博客
01-11 675
python实现算法与数据结构基础-链表、栈、队列、排序算法、二分查找、二叉树
【数据结构】编程实现有序顺序表的顺序查找和二分查找算法。C++版
qq_52978240的博客
12-01 5774
一、实验目的: 熟悉各种查找算法及其复杂性，能够根据实际情况选择合适的存储结构。二、实验要求: 算法完善，考虑时间复杂度。三、实验内容: 编程实现有序顺序表的顺序查找和二分查找算法。 代码段 #include <iostream> using namespace std; #define MAXSIZE 100 typedef int KeyType; //数据元素类型定义 typedef struct{ KeyType key;//数据域 }ElemType; //顺序表的定.
顺序查找与二分查找的算法实现
yangzhanghui的专栏
11-23 1328
二分查找算法
diaobaaiqiqi的博客
10-17 273
使用循环方式实现二分查找： int BinSearch(SeqList *R，int n,KeyType K) { //在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回-1 int low=0,high=n-1,mid； //置当前查找区间上、下界的初值 while(low&lt;=high) { if(R[lo...
有序顺序表查询（二分查找）
王小平
08-09 3640
Problem Description 顺序表内按照由小到大的次序存放着n个互不相同的整数，任意输入一个整数，判断该整数在顺序表中是否存在。如果在顺序表中存在该整数，输出其在表中的序号；否则输出“No Found!”。 Input 第一行输入整数n (1 <= n <= 100000)，表示顺序表的元素个数； 第二行依次输入n个各不相同的有序非负整数，代表表里的元素； 第三行输入整数t
查找-顺序+折半+索引+哈希【数据结构与算法】
weixin_44972997的博客
02-20 3095
顺序查找 二分查找 索引查找 哈希查找【数据结构与算法】
数据结构实验报告（包括线性表、栈和队列、串、二叉树、图、查找与排序算法的设计与实现）
最新发布
06-09
- **折半查找算法设计**：`Project9.2`部分介绍了折半查找（又称二分查找）的基本思想和实现方法，并分析了其时间复杂度。 - **分块查找算法设计**：`Project9.3`部分探讨了分块查找的实现方法，该方法通过预先建立...
数据结构 查找
03-07
折半查找又称二分查找，适用于已排序的线性表。其特点是每次都能排除一半的候选区域，从而大大提高了查找效率。 **3.2 设计思路** 折半查找的基本思想如下： 1. 比较中间元素与目标关键字。 2. 如果中间元素等于...
C语言实现数据结构：查找与排序
John_bill的博客
04-07 787
设计并实现一个管理系统（学生管理、图书管理、产品管理等等），系统中需包含1000条以上的记录，系统至少包含以下功能： (1) 自动生成记录信息（或者从文件中读取）； (2) 逐条显示所有记录信息； (3) 利用时间复杂度O(n2)的排序算法（例如直接插入排序或者折半插入排序）按照关键字进行排序； (4) 利用时间复杂度O(nlogn)的排序算法（例如快速排序）按照关键字进行排序； (5) 程序中统计（3）和（4）的算法在数据正序、逆序、乱序情况下的比较次数与移动次数并输出，在报告中对比较次数与移动次数并输出
C语言版数据结构二分法查找代码
12-27
C语言版数据结构中利用二分查找实现在顺序表的查找。同时包含循序表的插入等操作。
顺序表查找（顺序查找、二分查找） C语言实现
热门推荐
WTF
12-14 3万+
1、基本概念 a. 从大量以前存储的数据中检索特定的一段信息或几段信息的操作称为查找或搜索。 b. 平均查找长度ASL的计算公式为： 其中，n 为查找表的长度（元素个数），pi 为查找第 i 个元素的概率，ci 是查找第 i 个元素时同给定值 K 所需比较的次数。 若查找每个元素的概率相同，则公式可简化为：        c. 顺序表：是指采用数组对集合或线性表进
Python实现顺序查找和二分查找算法
Wangtuo1115的博客
06-21 772
查找表 查找表是由同一类型的数据元素构成的集合。例如电话号码簿和字典都可以看作是一张查找表。 一般对于查找表有以下几种操作： 在查找表中查找某个具体的数据元素； 在查找表中插入数据元素； 从查找表中删除数据元素； 静态查找表与动态查找表 在查找表中只做查找操作，而不改动表中数据元素，称此类查找表为静态查找表； 在查找表中做查找操作的同时进行插入数据或者删除数据的操作，称此类表为动态查找表。 关键字 关键字又细分为主关键字和次关键字。 若某个关键字可以唯一地识别一个数据元素时，称这个关键字为主关键字，例如
二分法查找(C语言实现) 分类： 数据结构 2014...
weixin_34119545的博客
12-17 425
//二分法查找 int BinarySearch() { int arr[] = {1,2,3,4,5,6,7,8,9,10,11,12}; int key=3; int head=0, tail=11, middle; while (tail>head) { middle = (head + tail) / 2; if (key > ar...
顺序查找与二分查找的代码实现
qq_47564006的博客
09-08 1029
顺序查找与二分查找的代码实现 顺序查找： 基本思想 1.依次扫描A中的所有元素，将每个元素与x比较； 2.如果在i次比较后1<=i<=n搜索成功，即x==A[j]，则返回j的值； 3.否则返回0，表示没有找到。 对于一个大小为n的排序数组，算法执行比较的最大次数为n 二分查找： 基本思想 1.令A [low…high]为元素按升序排列的非空数组， A [mid]为中间元素，假定x>A [mid]； 2.注意到如果x在A中，则它必定是A[mid+l],A[mid+2] ,…,A[hign]当
顺序查找与二分查找
weixin_64443786的博客
04-16 214
基本查找
（顺序表处理）二分查找
EDGNB6666的博客
01-30 1721
#include<iostream> //二分查找binary search using namespace std; int main() { //定义数组 int array[] = { 0,5,13,19,22,41,55,68,72,81,98 }; int targetNumber; //要查找的数字，查找结果 int arrLength = sizeof(array) / sizeof(array[0]); //获得数组长度 printf("请输入在一下数组中.
数据结构与算法（三）——顺序查找和二分查找
hold_on_qlc的博客
01-17 1225
顺序查找也叫线性查找，从列表第一个元素开始，顺序进行搜索，直到找到元素或搜索到列表最后一个元素为止；二分查找又叫折半查找，从有序列表的初始候选区li[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。
顺序表的冒泡排序算法及二分法查找代码实现
guguizi的专栏
05-06 4069
本文主要实现了比较经典的冒泡排序算法（对已经有序或者基本有序的顺序表复杂度大大降低），和二分法查找，各位看官看代码吧//冒泡排序算法及二分法查找 #include "stdio.h" typedef struct { int key; }SSTable_Elem_Type; typedef struct { SSTable_Elem_Type*elem; int length
数组和广义表的数据结构：顺序表示与存储
本课件主要探讨了数组的类型定义、顺序表示和实现，以及与之相关的广义表和稀疏矩阵的压缩存储。 首先，我们来看5.1节关于数组的类型定义。数组的数据对象通常由一系列同类型的元素组成，例如在二维数组中，D={aij|...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值