【数据结构】查找与排序(一)—＞“监视哨”的学习

于 2023-06-26 13:40:36 发布
阅读量1.6k 收藏 31
点赞数 30
分类专栏： 数据结构 文章标签： 数据结构 学习 c语言 程序人生 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77112634/article/details/131354215
版权

一、前言

本篇以学生信息管理系统为背景，主要学习简单的查找与排序功能。

高级查找与排序会在接下来的文章中再做介绍，欢迎大家关注并留意博主动态。

查找主要涉及顺序查找、二分查找。

排序主要涉及直接插入排序、直接选择排序、冒泡排序。

 二、查找讲解

1、顺序查找

（1）普通的顺序查找

 顺序查找就是依托顺序表的存储特点：顺序存储，利用其相邻的存储位置进行查找操作。

void SqSearch(SqList L)
{
	int i = 0;
	int flag = 0;
	cout << "请输入你要查找的学生姓名>:";
	char arr[10] = "\0";
	scanf("%s", arr);
	for (i = 0; i < L.length; i++)
	{
		if (strcmp(L.elem[i].name, arr) == 0)
		{
			flag = 1;
			cout << "该学生信息如下>:" << endl;
			OutList(L, i);
			break;
		}
	}
	if (flag == 0)
		cout << "未找到该学生！" << endl;
}

根据函数我们可以清晰地了解到，这种普通的顺序查找方式每次循环都需要进入判断i<L.length。即这一算法需要进行两次判断，一是查找位置是否合法：i<L.length，二是该位置的元素是否是我们要查找的元素：strcmp(L.elem[i].name, arr) == 0，那么我们是否可以每次进行一次判断就得到我们想要的结果呢，答案是肯定的，请看下文“监视哨”顺序查找的介绍。

（2）“监视哨”顺序查找

“监视哨”就是在顺序表中留出一个位置，不管是头部还是尾部，每次只需要将待比较的元素与“监视哨”位置的元素比较即可，这样每次都能节省一次判断，算法如下：

int SqSearch(SqList L)
{
	int i = 0;
	cout << "请输入你要查找的学生姓名>:";
	char arr[10] = "\0";
	scanf("%s", arr);
    strcpy(L.elem[0].name,arr);
	for (i = L.length; strcmp(L.elem[i].name, arr) != 0; i--)
    {
        ;//空语句
    }
	return i;
}

 当返回值为0时，证明查找失败。 

利用监视哨的方式进行查找，只需要留出一个顺序表中的位置，所带来的效率提升还是比较明显的，尤其是在数据庞大的时候。

2、二分查找 

二分查找适用的是有序表，即原始数据必须有序，他的思想就是从表的中间记录开始，用给定值与中间值比较，如果相等，则查找成功，如果给定值大于或小于中间值，则在表中大于或小于的那一半中继续查找。

//二分查找
void binaryFld(SqList L)
{
	cout << "请输入你要查找的学生学号>:";
	int id = 0;
	cin >> id;
	int low = 0;
	int high = L.length - 1;
	int flag = 0;
	while (low <= high)
	{
		int mid = (low + high) / 2;//mid的赋值位置尤为重要
		if (L.elem[mid].stu_id < id)
		{
			low = mid + 1;
		}
		else if (L.elem[mid].stu_id > id)
		{
			high = mid - 1;
		}
		else
		{
			flag = 1;
			cout << "你要查找的学生信息如下>:" << endl;
			OutList(L, mid);
			break;
		}
	}
	if (flag == 0)
		cout << "未找到该学生！" << endl;
}

需要尤其注意的是，mid赋值的位置尤为重要，如果你不小心将mid的复制位置放在了循环外，就会引起程序错误，进入死循环。 

三、排序讲解

1、直接插入排序

直接插入排序的思想是将数据分为两部分，一部分为已排序部分，另一部分为待排序部分，每次从待排序部分的第一个元素插入到已排序部分中。

//直接插入排序
void Insert_sorting(SqList &L)
{
	int i = 0;
	for (i = 1; i < L.length; i++)//默认单个元素为有序，所以从第二个元素开始
	{
		Stu t={0};
		if (strcmp(L.elem[i].name,L.elem[i - 1].name)<0)比较元素大小
		{
			t= L.elem[i];
			L.elem[i]= L.elem[i - 1];
			//寻找插入位置
			int j = 0;
			for (j = i - 1; strcmp(L.elem[j].name,t.name)>0 ; j--)
			{
				L.elem[j + 1]= L.elem[j];//元素后移
			}
			L.elem[j + 1]= t;插入元素
		}
	}
}

思想滤清后，我们得到以下步骤 ：

 分析直接插入排序思想，我们需要解决的问题为三个，一是将待排序元素与已排序元素比较大小，二是寻找合适的插入位置，三是元素后移并插入。

2、直接选择排序

直接选择排序的思想就是每次从待排序数据中找到最小值，并从头开始替换。

//直接选择排序
void Choose_sorting(SqList& L)
{
	int i = 0;
	int k = 0;
	int j = 0;
	Stu tmp = {0};
	for (i = 0; i < L.length; i++)
	{
		k = i;
		for (j = i + 1; j < L.length; j++)//寻找最小值
		{
			if (L.elem[k].stru_score > L.elem[j].stru_score)
			{
				k = j;
			}
		}
		if (k != i)//替换数据
		{
			tmp = L.elem[i];
			L.elem[i] = L.elem[k];
			L.elem[k] = tmp;
		}
	}
}

分析直接选择排序思想，我们需要解决的问题为两个，一是将寻找最小值，二是逐个替换。

 3、冒泡排序

冒泡排序的思想是交换，即待排序数据依次两两比较，将较大者保持在每轮的最后一个。

这样每一轮的最大值就交换到了尾部，再进行新一轮的比较，将次大值交换到最大值的钱一个位置，依次循环进行。

void Bubbling_sorting(SqList& L)
{
	int i = 0;
	int m = L.length - 1;
	int flag = 1;
	Stu tmp = { 0 };
	while (m > 0 && flag == 1)
	{
		flag = 0;
		for (i = 0; i < m; i++)
		{
			if (L.elem[i].cpp_score > L.elem[i + 1].cpp_score)
			{
				flag = 1;
				tmp = L.elem[i + 1];
				L.elem[i + 1] = L.elem[i];
				L.elem[i] = tmp;
			}
		}
		--m;
	}
}

四、完整程序

1、头文件

#ifndef _Search_h
#define _Search_h

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<stdlib.h>

using namespace std;

typedef int Status;

#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define NUM 8//表长
#define OVERFLOW -1

typedef struct
{
	int stu_id;
	char name[10];
	char class_id[10];
	int cpp_score;
	int stru_score;
}Stu;

typedef struct
{
	Stu* elem;
	int length;
}SqList;

//菜单
void menu();
//信息初始化
Status InitList(SqList &L);
//输出数据
void OutList(SqList L, int i);
//输出全部数据
void OutAllList(SqList L);
//顺序查找
void SqSearch(SqList L);
//二分查找
void binaryFld(SqList L);
//直接插入排序
void Insert_sorting(SqList &L);
//冒泡排序
void Bubbling_sorting(SqList &L);
//直接选择排序
void Choose_sorting(SqList& L);
#endif

2、功能函数文件

#include"Search.h"

//菜单
void menu()
{
	printf("*******************学生成绩管理系统*******************\n");
	printf("*        1.信息初始化             2.顺序查找         *\n");
	printf("*        3.二分查找               4.直接插入排序     *\n");
	printf("*        5.冒泡排序               6.直接选择排序     *\n");
	printf("*        0.退出                                      *\n");
	printf("******************************************************\n");
}

//初始化
Status InitList(SqList& L)
{
	L.elem = new Stu[MAXSIZE];
	if (!L.elem)
		exit(OVERFLOW);
	L.length = NUM;
	int i = 0;
	for (i = 0; i < L.length; i++)
	{
		cout << "请依次输入学号，姓名，班级，C++成绩，数据结构成绩>:";
		scanf("%d", &L.elem[i].stu_id);
		scanf("%s", L.elem[i].name);
		scanf("%s", L.elem[i].class_id);
		scanf("%d", &L.elem[i].cpp_score);
		scanf("%d", &L.elem[i].stru_score);
	}
//	L.elem[0] = { 1,"王立","03511",85,76 };
//	L.elem[1] = { 2,"张秋","03511",78,88 };
//	L.elem[2] = { 3,"刘丽","03511",90,79 };
//	L.elem[3] = { 4,"王通","03511",75,86 };
//	L.elem[4] = { 5,"赵阳","03511",60,71 };
//	L.elem[5] = { 6,"李艳","03511",58,68 };
//	L.elem[6] = { 7,"钱娜","03511",95,89 };
//	L.elem[7] = { 8,"孙胜","03511",45,60 };
	return OK;
}

//输出某一数据
void OutList(SqList L, int i)
{
	cout << L.elem[i].stu_id << "\t" << L.elem[i].name << "\t" << L.elem[i].class_id << "\t"
		<< L.elem[i].cpp_score << "\t" << L.elem[i].stru_score << endl;
}

//输出全部数据
void OutAllList(SqList L)
{
	int i = 0;
	for (i = 0; i < L.length; i++)
	{
		cout << L.elem[i].stu_id << "\t" << L.elem[i].name << "\t" << L.elem[i].class_id << "\t"
			<< L.elem[i].cpp_score << "\t" << L.elem[i].stru_score << endl;
	}
}

//顺序查找
void SqSearch(SqList L)
{
	int i = 0;
	int flag = 0;
	cout << "请输入你要查找的学生姓名>:";
	char arr[10] = "\0";
	scanf("%s", arr);
	for (i = 0; i < L.length; i++)
	{
		if (strcmp(L.elem[i].name, arr) == 0)
		{
			flag = 1;
			cout << "该学生信息如下>:" << endl;
			OutList(L, i);
			break;
		}
	}
	if (flag == 0)
		cout << "未找到该学生！" << endl;
}

//二分查找
void binaryFld(SqList L)
{
	cout << "请输入你要查找的学生学号>:";
	int id = 0;
	cin >> id;
	int low = 0;
	int high = L.length - 1;
	int flag = 0;
	while (low <= high)
	{
		int mid = (low + high) / 2;
		if (L.elem[mid].stu_id < id)
		{
			low = mid + 1;
		}
		else if (L.elem[mid].stu_id > id)
		{
			high = mid - 1;
		}
		else
		{
			flag = 1;
			cout << "你要查找的学生信息如下>:" << endl;
			OutList(L, mid);
			break;
		}
	}
	if (flag == 0)
		cout << "未找到该学生！" << endl;
}

//直接插入排序
void Insert_sorting(SqList &L)
{
	int i = 0;
	for (i = 1; i < L.length; i++)
	{
		Stu t={0};
		if (strcmp(L.elem[i].name,L.elem[i - 1].name)<0)
		{
			t= L.elem[i];
			L.elem[i]= L.elem[i - 1];
			//寻找插入位置
			int j = 0;
			for (j = i - 1; strcmp(L.elem[j].name,t.name)>0 ; j--)
			{
				L.elem[j + 1]= L.elem[j];
			}
			L.elem[j + 1]= t; 
		}
	}
}



//冒泡排序
void Bubbling_sorting(SqList& L)
{
	int i = 0;
	int m = L.length - 1;
	int flag = 1;
	Stu tmp = { 0 };
	while (m > 0 && flag == 1)
	{
		flag = 0;
		for (i = 0; i < m; i++)
		{
			if (L.elem[i].cpp_score > L.elem[i + 1].cpp_score)
			{
				flag = 1;
				tmp = L.elem[i + 1];
				L.elem[i + 1] = L.elem[i];
				L.elem[i] = tmp;
			}
		}
		--m;
	}
}

//直接选择排序
void Choose_sorting(SqList& L)
{
	int i = 0;
	int k = 0;
	int j = 0;
	Stu tmp = {0};
	for (i = 0; i < L.length; i++)
	{
		k = i;
		for (j = i + 1; j < L.length; j++)
		{
			if (L.elem[k].stru_score > L.elem[j].stru_score)
			{
				k = j;
			}
		}
		if (k != i)
		{
			tmp = L.elem[i];
			L.elem[i] = L.elem[k];
			L.elem[k] = tmp;
		}
	}
}

3、主函数文件

#include"Search.h"

int main()
{
	SqList L;
	int input = 0;
	do
	{
		menu();
		printf("请选择>:");
		cin >> input;
		switch (input)
		{
		case 1:
			//信息初始化
			InitList(L);
			break;
		case 2:
			//顺序查找
			SqSearch(L);
			break;
		case 3:
			//二分查找
			binaryFld(L);
			break;
		case 4:
			//直接插入排序
			cout << "排序前表为>:" << endl;
			OutAllList(L);
			Insert_sorting(L);
			cout << "排序后表为>:" << endl;
			OutAllList(L);
			break;
		case 5:
			//冒泡排序
			cout << "排序前表为>:" << endl;
			OutAllList(L);
			Bubbling_sorting(L);
			cout << "排序后表为>:" << endl;
			OutAllList(L);
			break;
		case 6:
			//直接选择排序
			cout << "排序前表为>:" << endl;
			OutAllList(L);
			Choose_sorting(L);
			cout << "排序后表为>:" << endl;
			OutAllList(L);
			break;
		case 0:
			cout << "退出系统" << endl;
			break;
		}
	} while (input);
	return 0;
}

 四、总结

简单的查找与排序相信大家都很容易理解，博主会持续更新查找排序算法，欢迎大家关注博主动态🔥🔥🔥

樊梓慕
关注
  • 30
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 15
    评论
专栏目录
数据结构--第九章 查找
bebetter_的博客
05-01 926
目录第九章 查找1、顺序表查找1）顺序查找①无监视哨查找②有监视哨查找2）折半查找①非递归实现②递归实现3）分块查找2、树表的查找1）二叉排序树①插入②构造③查找④删除2）平衡二叉树①构造3）B树<1>性质①树中的叶子结点说明②树中关键字的要求③树中子树的要求<2>查找<3>插入<4>删除４）B＋树3、Hash查找1)散列技术的关键问题①散列函数的设...
数据结构-查找
m0_62292821的博客
05-08 1920
查找是所有数据处理中最基本、最常用的操作。 查找：在数据集合中寻找满足某种条件的数据元素的过程称为查找 查找表： 相同类型的数据元素(对象)组成的集合，每个元素通常由若干数据项构成。关键字(Key)： 数据元素中某个(或几个)数据项的值，它可以标识一个数据元素。若关键字能唯一标识一个数据元素，则关键字称为主关键字；将能标识若干个数据元素的关键字称为次关键字。查找/检索： 根据给定的K值，在查找表中确定一个关键字等于给定值的记录或数据元素。 平均查找长度：在查找的过程中，一次查找的长度是指需要比较的关键
顺序查找（带监视哨）
crazy_yyyyy的专栏
02-29 1万+
顺序查找 可以从前到后，也可以从后到前。这两种都可以 （1）最基本的顺序查找 int seqsearch(SeqList L,KeyType k) { i = L.length; while(i >= 1 && L.r[i].key != k) i--; if(i > = 1) return i; return 0; } (2)优化该顺序查找，就是添加监听哨，上面的查找方式时间主要
数据结构——线性表的查找：顺序查找、设置监视哨的顺序查找、折半查找
cwindyc的博客
05-25 6341
算法7.1顺序查找 #include<iostream> using namespace std; typedef int KeyType; typedef int InfoType; #define MAX 1000 typedef struct { KeyType key; InfoType otherinfo; }ElemType; typedef struct { ElemType* R; int length; }SSTable; int Search_Seq(SSTa
【数据结构（32）】7.2 线性表的查找
shangguanxiu的博客
01-25 1991
严蔚敏版【数据结构】1. 顺序查找：顺序查找算法、设置哨兵的顺序查找。2. 折半查找（二叉查找或对分查找）：折半查找算法、判定树。3. 分块查找：分块查找算法、分块查找算法分析。三种算法比较
算法 快速排序 冒泡排序 监视哨 折半查找
04-23
快速排序、冒泡排序、监视哨以及折半查找是计算机科学中非常重要的基础算法，对于理解和应用编程至关重要，特别是对于参与ACM（国际大学生程序设计竞赛）或其他算法竞赛的程序员来说，这些都是必须掌握的核心技能。...
有监视哨的顺序查找
04-14
"有监视哨的顺序查找"是一种在数据结构与算法领域中的搜索方法，它对传统的顺序查找进行了优化。顺序查找通常是在未排序的序列中寻找目标值，从序列的第一个元素开始，逐个比较直到找到目标或者遍历完整个序列。而...
数据结构-查找-PPT
02-04
数据结构中的查找是数据处理和计算机科学中的基本操作之一，主要目标是在一组数据中寻找特定信息。本主题主要关注在数据结构中实现查找的各种方法，特别是针对线性表的查找技术。 查找的基本概念： 查找是根据给定...
数据结构描述查找(共66张PPT)精选.pptx
11-30
数据结构中的查找技术是计算机科学中的核心概念，用于在数据集合中寻找特定信息。查找的主要目的是根据给定的关键字在数据结构中定位到相应的数据元素。在这个精选的66张PPT中，主要讨论了查找的基本概念、线性表的...
专升本数据结构第九章 排序.pdf
最新发布
01-14
《专升本数据结构》第九章探讨的核心主题是排序，这是数据处理中不可或缺的操作，它通过特定次序排列数据元素，以提升查找效率。排序分为内部排序和外部排序，本章主要关注内部排序，包括插入排序、快速排序、选择...
C++ 实现带监视哨的顺序查找算法
12-20
监视哨往往是程序里面的一个变量，如果是对数字排序的话，那么该变量一般是数值型变量。变量的赋值就相当于哨兵，当排序数列中出现与哨兵相等的值或有某种既定关系出现时，就做一种操作，比如说停止排序，或进行下一趟排序。 举例： 顺序检索的算法描述如下 int Search_Sequen(SSTable ST,KeyType key){ //在线性表ST中顺序检索其关键字等于Key的数据元素， //若找到，函数值为该元素在表中的位置，否则为-1. ST.element[ST.length].key=key; //设置监视哨 i=0; while(ST.element[i].key!=key) i++
2021-906终极预测卷一
01-16
2021-906终极预测卷一
数据结构-查找（顺序查找，加监视稍，折半查找（代码实现），分块查找 散链表（哈希表）查找（无代码））
qq_44799835的博客
11-22 1950
查找算法 一，顺序查找1 按照线性顺序，一个一个的比较，找到返回其位置，找不到返回值0 int Seq_Search1(SeqList p,DataType a) { int i=1; while(i<=p.length&&p.data[i]!=a) { i++; } if(i>p.length) return 0; else return i...
数据结构---顺序查找算法详解（C语言）
热门推荐
weixin_51781852的博客
11-21 1万+
顺序查找的实现 顺序查找的一般过程为：从表的一段开始，依次将记录的关键字和给定的值进行比较，若某个记录的关键字和给定值相等，则查找成功；反之，若扫描整个表后，仍未找到关键字和给定值相等的记录，则查找失败。 数据元素类型定义如下： typedef struct{ keytype key;//关键字域 InfoType otherinfo;//其他域 ｝ElemType; 顺序表的定义如下： typedef struct{ ElemType *R;//存储空间基地址 .
c语言监视哨用法,C++ 实现带监视哨的顺序查找算法
weixin_34637857的博客
05-22 1978
这篇文章主要介绍了C++实现带监视哨的顺序查找算法，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下。监视哨往往是程序里面的一个变量，如果是对数字排序的话，那么该变量一般是数值型变量。变量的赋值就相当于哨兵，当排序数列中出现与哨兵相等的值或有某种既定关系出现时，就做一种操作，比如说停止排序，或进行下一趟排序。举例：顺序检索的算法描述如下int S...
直接排序三种方法参考——监视哨
叼着零食打架
05-24 3524
直接插入排序三种方法参考——监视哨 今天复习所学过的数据结构的排序和查找方法，下面是对直接插入排序的几种方法的具体代码和思路，可以当做参考，当然也是方便自己加强记忆。这里只是具体一些代码，https://blog.csdn.net/k0115/article/details/78994101，我是参照的这位博主解释，挺详细的。 从前至后比较依次插入 #include<stdio.h> void insert_sort(int arr[],int length) { int i,j,k; for
查找1—线性表的查找（顺序；二分；分块）
充满好奇的threecat
11-30 900
提前看目录 1、设置监视哨的顺序查找 2、折半查找 3、分块查找 1、设置监视哨的顺序查找 普通的顺序查找就是利用循环遍历，例如n个数据查找，利用for(i=n;i>0;i--)循环，在进行if语句的判断，我们会发现每一次都会执行i>0的判断，而实际上只要存在这个元素，都是满足这个条件的，所以这就增加了时间的复杂度。因此就有了设置监视哨的顺序查找，简单来说就是将n[0]存...
数据结构课件：第10章 排序1插入排序和交换排序.pptx
06-01
具体实现中，代码展示了插入排序的步骤，包括查找插入位置、移动元素和设置监视哨等操作。 交换排序中的典型例子是冒泡排序和快速排序。冒泡排序通过反复遍历和交换相邻的元素来达到排序目的，而快速排序则是采用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

樊梓慕

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值