C++查找实验

最新推荐文章于 2023-03-26 20:20:57 发布
最新推荐文章于 2023-03-26 20:20:57 发布
阅读量699 收藏 4
点赞数 1
分类专栏： C++数据结构 文章标签： c++ 算法 数据结构 学习 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51495235/article/details/128155891
版权

1.顺序查找

运行结果如图所示：
在这里插入图片描述
seqSearch.cpp

#include <stdio.h>
//定义表中最多记录个数
#define MAXL 100
typedef int KeyType;
typedef char InfoType[10];

typedef struct {
    //KeyType为关键字的数据类型
    KeyType key;
    //其他数据
    InfoType data;
} NodeType;
//顺序表类型
typedef NodeType SeqList[MAXL];

//顺序查找算法
int SeqSearch(SeqList R, int n, KeyType k) {
    int index = 0;
    for (int i = 0; i < n; i++) {
        if (R[i].key == k) {
            index = i;
        }
        printf("%d ", R[i].key);
    }
    return index;
}

int main() {
    SeqList R;
    int n = 10;
    KeyType k = 5;

    int a[] = {3, 6, 2, 10, 1, 8, 5, 7, 4, 9};
    int i;
    //建立顺序表
    for (i = 0; i < n; i++) {
        R[i].key = a[i];
    }
    printf("\n");

    if ((i = SeqSearch(R, n, k)) != -1) {
        printf("\n元素%d的位置是%d\n", k, i);
    } else {
        printf("\n元素%d不在表中\n", k);
    }
    printf("\n");
}

运行截图
在这里插入图片描述

2. 折半查找

运行结果如图所示：
在这里插入图片描述
binSearch.cpp

#include <stdio.h>
//定义表中最多记录个数
#define MAXL 100                    

typedef int KeyType;
typedef char InfoType[10];

typedef struct {
    //KeyType为关键字的数据类型
    KeyType key;
    //其他数据
    InfoType data;
} NodeType;

//顺序表类型
typedef NodeType SeqList[MAXL];

//二分查找算法
int BinSearch(SeqList R, int n, KeyType k) {
    int low = 1;
    int high = n;
    int count = 1;
    int res = 0;
    while (low <= high && count < 4) {
        int mid = (low + high) / 2;
        if (count < 3) {
            printf("第%d次查找:在[%d,%d]中查找到元素R[%d]:%d\n", count, low - 1, high - 1, mid - 1, R[mid - 1].key);
        }
        if (k == R[mid].key) {
            res = mid;
            high = n;
            low = R[mid].key;
            count++;
            printf("第%d次查找:在[%d,%d]中查找到元素R[%d]:%d\n", count, low - 1, high - 1, res, R[res].key);
        } else if (k < R[mid].key) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
        count++;
    }
    return res;
}

int main() {
    SeqList R;
    KeyType k = 9;
    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, i, n = 10;
    //建立顺序表
    for (i = 0; i < n; i++) {
        R[i].key = a[i];
    }
    printf("\n");

    if ((i = BinSearch(R, n, k)) != -1) {
        printf("元素%d的位置是%d\n", k, i);
    } else {
        printf("元素%d不在表中\n", k);
    }
    printf("\n");
}

运行截图
在这里插入图片描述

3. 二叉排序树的基本运算

运行结果如图所示：
在这里插入图片描述
BST.cpp

#include <stdio.h>
#include <malloc.h>

#define MaxSize 100
//定义关键字类型
typedef int KeyType;
typedef char InfoType;
//记录类型
typedef struct node {
    //关键字项
    KeyType key;
    //其他数据域
    InfoType data;
    //左右孩子指针
    struct node *lchild;
    struct node *rchild;
} BSTNode;
//全局变量,用于存放路径
int path[MaxSize];

//函数说明
void DispBST(BSTNode *b);

//在以*p为根结点的BST中插入一个关键字为k的结点
int InsertBST(BSTNode *&p, KeyType k) {
    //原树为空, 新插入的记录为根结点
    if (p == nullptr) {
        p = (BSTNode *) malloc(sizeof(BSTNode));
        p->key = k;
        p->lchild = p->rchild = nullptr;
        return 1;
    } else if (k == p->key) {
        return 0;
    } else if (k < p->key) {
        //递归调用，插入到*p的左子树中
        return InsertBST(p->lchild, k);
    } else {
        //递归调用，插入到*p的右子树中
        return InsertBST(p->rchild, k);
    }
}

//由数组A中的关键字建立一棵二叉排序树
BSTNode *CreatBST(KeyType A[], int n) {
    //初始时bt为空树
    BSTNode *bt = nullptr;
    int i = 0;
    while (i < n)
        //将A[i]插入二叉排序树T中
        if (InsertBST(bt, A[i]) == 1) {
            printf("    第%d步,插入%d: ", i + 1, A[i]);
            DispBST(bt);
            printf("\n");
            i++;
        }
    //返回建立的二叉排序树的根指针
    return bt;
}

//以括号表示法输出二叉排序树bt
void DispBST(BSTNode *bt) {
    if (bt != nullptr) {
        printf("%d", bt->key);
        if (bt->lchild != nullptr || bt->rchild != nullptr) {
            printf("(");
            DispBST(bt->lchild);
            if (bt->rchild != nullptr) {
                printf(",");
            }
            DispBST(bt->rchild);
            printf(")");
        }
    }
}

//以递归方式输出从根结点到查找到的结点的路径
int SearchBST(BSTNode *bt, KeyType k) {
    printf("%d ", bt->key);
    if (k == bt->key) {
        return bt->key;
    } else if (k < bt->key) {
        return SearchBST(bt->lchild, k);
    } else if (k > bt->key) {
        return SearchBST(bt->rchild, k);
    }
}

//当被删*p结点有左右子树时的删除过程
void Delete1(BSTNode *p, BSTNode *&r) {
    BSTNode *s;
    BSTNode *q;
    q = p;
    s = p->lchild;
    while (s->rchild) {
        q = s;
        s = s->rchild;
    }
    p->key = s->key;
    if (q != p) {
        q->rchild = s->lchild;
    } else {
        q->lchild = s->lchild;
    }
    delete s;
    /*
    if (r->rchild != nullptr)
        Delete1(p, p->lchild);    //递归找最右下结点
    else                        //找到了最右下结点*r
    {
        p->key = r->key;            //将*r的关键字值赋给*p
        q = r;
        r = r->lchild;            //将*r的双亲结点的右孩子结点改为*r的左孩子结点
        free(q);                //释放原*r的空间
    }
     */
}

//从二叉排序树中删除*p结点
void Delete(BSTNode *&p) {
    BSTNode *q;
    //*p结点没有右子树的情况
    if (p->rchild == nullptr) {
        q = p;
        p = p->lchild;
        free(q);
    } else if (p->lchild == nullptr) { //*p结点没有左子树的情况
        q = p;
        p = p->rchild;
        free(q);
    } else { //*p结点既有左子树又有右子树的情况
        Delete1(p, p->lchild);
    }
}

//在bt中删除关键字为k的结点
int DeleteBST(BSTNode *&bt, KeyType k) {
    //空树删除失败
    if (bt == nullptr) {
        return 0;
    } else {
        //小于说明在左边
        if (k < bt->key) {
            //递归在左子树中删除关键字为k的结点
            return DeleteBST(bt->lchild, k);
        } else if (k > bt->key) {
            //递归在右子树中删除关键字为k的结点
            return DeleteBST(bt->rchild, k);
        } else { //k=bt->key的情况
            //调用Delete(bt)函数删除*bt结点
            Delete(bt);
            return 1;
        }
    }
}

int flag = true;
int prev=-256;
bool isBinaryTree(BSTNode *&bt) {
    if (bt->lchild != nullptr && flag) {
        isBinaryTree(bt->lchild);
    }
    if(bt->data<prev){
        flag= false;
    }
    if(bt->rchild!= nullptr&&flag){
        isBinaryTree(bt->rchild);
    }
    return flag;
}


//predt为全局变量,保存当前结点中序前趋的值,初值为-∞
KeyType predt = -32767;

int main() {
    BSTNode *bt;
    KeyType k = 6;
    int a[] = {4, 9, 0, 1, 8, 6, 3, 5, 2, 7}, n = 10;
    /*
    4
   / \
  0   9
   \ /
   1 8
   \  /
   3 6
  /  /\
  2  5 7
     */
    printf(" 创建一棵BST树:");
    printf("\n");
    bt = CreatBST(a, n);

    printf("\n\n BST: ");
    DispBST(bt);
    printf("\n\n");

    printf(" 查找%d关键字: ", k);
    SearchBST(bt, k);
    printf("\n\n");

    printf(" 是否是二叉排序树: \n");
    if(isBinaryTree(bt)){
        printf(" 是二叉排序树 \n");
    } else{
        printf(" 不是二叉排序树 \n");
    }

    printf("\n\n 删除操作:\n");
    printf("   原BST: ");
    DispBST(bt);
    printf("\n");

    printf("   删除结点4: ");
    DeleteBST(bt, 4);
    DispBST(bt);
    printf("\n");

    printf("   删除结点5: ");
    DeleteBST(bt, 5);

    DispBST(bt);
    printf("\n\n");
}

运行截图
在这里插入图片描述

4.自行设计一个算法，判别给定的一棵二叉树是否为二叉排序树

根据第三题结构，添加如下算法代码

#include <stdio.h>
#include <malloc.h>

#define MaxSize 100
//定义关键字类型
typedef int KeyType;
typedef char InfoType;
//记录类型
typedef struct node {
    //关键字项
    KeyType key;
    //其他数据域
    InfoType data;
    //左右孩子指针
    struct node *lchild;
    struct node *rchild;
} BSTNode;
//全局变量,用于存放路径
int path[MaxSize];

//函数说明
void DispBST(BSTNode *b);

//在以*p为根结点的BST中插入一个关键字为k的结点
int InsertBST(BSTNode *&p, KeyType k) {
    //原树为空, 新插入的记录为根结点
    if (p == nullptr) {
        p = (BSTNode *) malloc(sizeof(BSTNode));
        p->key = k;
        p->lchild = p->rchild = nullptr;
        return 1;
    } else if (k == p->key) {
        return 0;
    } else if (k < p->key) {
        //递归调用，插入到*p的左子树中
        return InsertBST(p->lchild, k);
    } else {
        //递归调用，插入到*p的右子树中
        return InsertBST(p->rchild, k);
    }
}

//由数组A中的关键字建立一棵二叉排序树
BSTNode *CreatBST(KeyType A[], int n) {
    //初始时bt为空树
    BSTNode *bt = nullptr;
    int i = 0;
    while (i < n)
        //将A[i]插入二叉排序树T中
        if (InsertBST(bt, A[i]) == 1) {
            printf("    第%d步,插入%d: ", i + 1, A[i]);
            DispBST(bt);
            printf("\n");
            i++;
        }
    //返回建立的二叉排序树的根指针
    return bt;
}

//以括号表示法输出二叉排序树bt
void DispBST(BSTNode *bt) {
    if (bt != nullptr) {
        printf("%d", bt->key);
        if (bt->lchild != nullptr || bt->rchild != nullptr) {
            printf("(");
            DispBST(bt->lchild);
            if (bt->rchild != nullptr) {
                printf(",");
            }
            DispBST(bt->rchild);
            printf(")");
        }
    }
}

int flag = true;
int prev=-256;
bool isBinaryTree(BSTNode *&bt) {
    if (bt->lchild != nullptr && flag) {
        isBinaryTree(bt->lchild);
    }
    if(bt->data<prev){
        flag= false;
    }
    if(bt->rchild!= nullptr&&flag){
        isBinaryTree(bt->rchild);
    }
    return flag;
}


//predt为全局变量,保存当前结点中序前趋的值,初值为-∞
KeyType predt = -32767;

int main() {
    BSTNode *bt;
    KeyType k = 6;
    int a[] = {4, 9, 0, 1, 8, 6, 3, 5, 2, 7}, n = 10;
    /*
    4
   / \
  0   9
   \ /
   1 8
   \  /
   3 6
  /  /\
  2  5 7
     */
    printf(" 创建一棵BST树:");
    printf("\n");
    bt = CreatBST(a, n);
    printf("\n");
    printf(" 是否是二叉排序树: \n");
    if(isBinaryTree(bt)){
        printf(" 是二叉排序树 \n");
    } else{
        printf(" 不是二叉排序树 \n");
    }
}

运行截图
在这里插入图片描述

康小庄
关注
专栏目录
数据结构 实验十一：（查找实验，设计性） 代码部分
m0_47161653的博客
06-13 675
数据结构 实验十一：（查找实验，设计性） 代码 代码参考 代码参考1 代码参考2
查找与排序综合实验-代码实现(c语言,实验代码)
scfvlog的博客
01-09 571
代码实现：采用了对应的排序算法，结构体，时间函数，随机数，文件操作等等操作，切勿用于非法用途，仅供学习参考使用！代码有任何问题都可以私聊我！
二分查找实验代码
zwhc的专栏
04-21 186
新代码 [code="java"] package test; /** * http://www.cn-cuckoo.com/2010/04/20/are-you-one-of-the-10-percent-of-programmers-who-can-write-a-binary-search-1530.html * * 二分查找 * 2010-04-21 12:00...
JAVA 折半查找 实验代码
01-10
JAVA 数据结构二分法查找代码。（实验）
数据结构 查找 上机实验代码 上海大学
myvanilla1的博客
05-10 329
验收过的代码，放心食用。实现方法不是最优，因为懒得改。大佬轻喷。 文章目录BSTAVL主函数 BST #ifndef BST_H #define BST_H #include <bits/stdc++.h> using namespace std; class BSTnode{ public: int data; BSTnode *ls,*rs; BSTnode(){} BSTnode(int ndata,BSTnode *l=nullptr,BSTnode
数据查找实验报告
06-24
本实验报告主要涉及C++编程，涵盖了数据结构中的静态查找表和动态查找表——特别是二叉排序树。以下是实验内容的详细说明： 1. **静态查找表**： - **顺序存储结构**：在静态查找表中，数据通常是线性存储的，比如...
3种查找算法——数据结构实验
05-17
本实验主要探讨了三种基本的查找算法：顺序查找、折半查找（二分查找）和索引查找，这些算法都是在数组或集合中寻找特定元素的重要方法。下面将详细解释这三种查找算法，并结合C语言编程环境进行深入分析。 1. **...
C++数据结构实验五：查找排序
01-16
3. 掌握查找的概念、静态查找与动态查找、顺序查找、二分查找、索引查找等算法思想。 4. 掌握二叉排序树的概念、平衡二叉树等算法思想。 5. 掌握哈希查找、直接插入排序、快速排序、冒泡排序、简单选择排序等算法...
数据结构实验报告(C++) 实验4:查找与排序实验指导（含源码）
05-03
一、查找与排序实验（1）——查找 题目1. 输出二叉排序树中所有的关键字值不小于key的元素值 题目2. (选做题)判断二叉排序树是否为平衡二叉树 题目3. 链地址法处理冲突的哈希表 二、查找与排序实验（2）——排序 ...
基于 C++实现查找和排序算法的实现课程实验（课程实验报告+源码）
最新发布
06-27
【作品名称】：基于 C++实现查找和排序算法的实现【课程实验】（课程实验报告+源码） 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 ...
C++数据结构 查找和排序的实验
12-11
1．掌握顺序查找、折半查找及二叉排序树上查找的基本思想和算法实现，了解怎样对各种查找方法进行时间性能（平均查找长度）分析。 2．掌握各种排序方法的基本思想、排序过程、算法实现，能进行时间和空间性能的分析，根据实际问题的特点和要求选择合适的排序方法。 二、实验内容： 1．将（45，24，55，12，37，53，60，28，40，70）中关键字依次插入初态为空的二叉排序树中，给出树的中序序列。 2．设计一组随机数据输入，分别对线性表进行顺序查找；选择一种合适排序算法排序，排序后对线性表采用折半查找（递归和非递归）。 3．实现直接插入排序、快速排序、归并排序算法。 4．设计一个程序，任意给出n个学生信息（包括：学号，姓名，成绩等），实现按照分数高低打印出学生的考试名次、学号、姓名和成绩，同一名次的学生按照学号有小到大排序，并能根据选号查看任意学生信息。
合肥工业大学数据结构查找实验
12-27
数据结构查找实验代码 (1) 对下列数据表，分别采用二分查找算法实现查找，给出查找过程依次所比较的元素（的下标），并以二分查找的判定树来解释。 第一组测试数据： 数据表为 (1,2,3,4,6,7,8,9,10,11,12,13,17,18,19,20,24,25,26,30,35,40,45,50,,100) 查找的元素分别为： 2，8，20, 30，50，5，15，33，110 第二组数据： 数据表为 (2,3,5,7,8,10,12,15,18,20,22,25,30,35,40,45,50,55,60, 80,100) 查找的元素分别为： 22，8，80，3，100，1，13，120 (2) 设计出在二叉排序树中插入结点的算法，在此基础上实现构建二叉排序树的算法。 测试数据：构建二叉排序树的输入序列如下： 第一组数据： 100，150，120，50，70，60，80，170，180，160，110，30，40，35，175 第二组数据： 100，70，60，80，150，120，50，160，30，40，170，180，175，35 (3) 设计算法在二叉排序树中查找指定值的结点。 测试数据：在任务中第一组测试数据所构造的二叉排序树中，分别查找下列元素： 150，70，160，190，10，55，175 (4) 设计算法在二叉排序树中删除特定值的结点。 测试数据：在任务(1)中第一组测试数据所构造的二叉排序树中，分别删除下列元素：30，150，100 (5) 已知整型数组A[1..26]递增有序，设计算法以构造一棵平衡的二叉排序树来存放该数组中的所有元素。 测试数据：数组元素分别为： 第一组数据： （1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26） 第二组数据： （1,3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210,231,253,277,302,328）
c语言折半查找法_C++常用查找算法总结（一）
weixin_39630909的博客
11-22 527
查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算，例如编译程序中符号表的查找，字段的查找，等等。1、查找算法总结(1). 最容易理解的查找算法，顺序查找法　说明：顺序查找适合于存储结构为顺序存储或链接存储的线性表。　　基本思想：顺序查找也称为线形查找，属于无序查找算法。从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成...
C++数据结构之查找——静态查找表（顺序查找、折半查找、分块查找 带有gif以及图示）
m0_56398315的博客
09-15 6110
本文对查找进行介绍并对静态查找进行重点解释和实现，附有GIF动图以及相关图示方便读者进行阅读
数据结构，查找专题，顺序查找、折半查找详解及C++详细实现
weixin_45651616的博客
08-05 2569
数据结构，查找专题，顺序查找、折半查找详解及C++代码实现
顺序查找，折半查找和斐波那契查找实现（C++）
SGL_LGS的博客
05-07 737
代码实现了四种方法对顺序表进行顺序查找和折半查找。 1、主要函数功能介绍： // 顺序查找方法一：for循环遍历 int Binary_Search(int *arr, const int n, const int key); // 顺序查找方法二： 设置“哨兵”位，优化边界判断比较 int Sequential_Search(int *arr, const int n, const int ke...
顺序查找算法、二分（折半）查找算法详解【数据结构实验报告】
Viewinfinitely的博客
06-24 4974
文章目录一、顺序查找算法二、折半查找算法（二分查找） 一、顺序查找算法 1、算法核心 在顺序表ST中顺序查找其关键字等于key的元素，若找到，则函数值为该元素所在元素表中的位置。 2、实现过程（详解在每一步的注释里） #include<iostream> using namespace std; typedef int KeyType; //给int的别名KeyType typedef int InfoType; //给int的别名InfoType //数据元素类型定义 typedef
顺序表查找（C++）
qq_41884952的博客
03-26 702
本文章只介绍了折半查找、插值查找和斐波那契查找。
C++程序设计基础实验：折半查找法实现
"C++程序设计基础实验题目-05，涉及折半查找法的应用" 实验5的目的是训练学生运用C++编程解决实际问题的能力，强调将实际问题转化为数学模型，并熟练掌握C++语言中的相关知识。实验同时也要求学生理解并应用基本的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值