实验十二 图+查找
一、实验目的与要求
1)掌握拓扑排序的应用;
2)掌握查找的概念和算法;
3)掌握查找的基本原理以及各种算法的实现;
4)掌握查找的应用。
二、实验内容
1. 用邻接表建立一个有向图的存储结构。利用拓扑排序算法输出该图的拓扑排序序列。
2. 0~n-1中缺失的数字
一个长度为n-1的递增排序数组中的所有数字都是唯一的,并且每个数字都在范围0~n-1之内。在范围0~n-1内的n个数字中有且只有一个数字不在该数组中,请使用折半查找算法找出这个数字。
示例 1:
输入: [0,1,3]
输出: 2
示例 2:
输入: [0,1,2,3,4,5,6,7,9]
输出: 8
三、实验结果
1)请将调试通过的主要源代码、输出结果粘贴在下面(必要的注释、Times New Roman 5号,行间距1.5倍)
2)简述算法步骤(选画技术路线图),格式如下:
S1:
S2:
3)请分析算法的时间复杂度。
4)请将源代码(必要的注释)cpp文件压缩上传
题目1:
(1.1)实验源代码
#include
using namespace std;
//拓扑排序
#define MVNum 100
typedef char VerTexType;
//图的邻接表存储表示
typedef struct ArcNode{
int adjvex;
struct ArcNode *nextarc;
}ArcNode;
typedef struct VNode{
VerTexType data;
ArcNode *firstarc;//指向第一条依附该顶点的边的指针
}VNode, AdjList[MVNum];
typedef struct{
AdjList vertices;//邻接表
AdjList converse_vertices;//逆邻接表
int vexnum, arcnum;//图的当前顶点数和边数
}ALGraph;
//定义顺序栈
typedef struct{
int *base;
int *top;
int stacksize;
}spStack;
int indegree[MVNum];//存放个顶点的入度
spStack S;
//初始化栈
void InitStack(spStack &S){
S.base = new int[MVNum];
if(!S.base)
exit(1);
S.top = S.base;
S.stacksize = MVNum;
}
//进栈
void Push(spStack &S , int i){
if(S.top - S.base == S.stacksize){
return;
}
*S.top++ = i;
}
//出栈
void Pop(spStack &S , int &i){
if(S.top == S.base){
return;
}
i = *--S.top;
}
//判断空栈
bool StackEmpty(spStack S){
if(S.top == S.base){
return true;
}
return false;
}
//确定点v在G中的位置
int LocateVex(ALGraph G , VerTexType v){
for(int i = 0; i < G.vexnum; ++i){
if(G.vertices[i].data == v){
return i;
}
}
return -1;
}
//创建有向图G的邻接表、逆邻接表
int CreateUDG(ALGraph &G){
int i , k;
cout <<"请输入总顶点数,总边数:";
cin >> G.vexnum >> G.arcnum;
cout << endl;
cout << "输入点的名称:" << endl;
for(i = 0; i < G.vexnum; ++i){
cout << "请输入第" << (i+1) << "个点的名称:";
cin >> G.vertices[i].data;
G.converse_vertices[i].data = G.vertices[i].data;
G.vertices[i].firstarc=NULL;//初始化表头结点的指针域为NULL
G.converse_vertices[i].firstarc=NULL;
}
cout << endl;
cout << "输入边依附的顶点:" << endl;
for(k = 0; k < G.arcnum;++k){
VerTexType v1 , v2;
int i , j;
cout << "请输入第" << (k + 1) << "条边依附的顶点:";
cin >> v1 >> v2;
i = LocateVex(G, v1);
j = LocateVex(G, v2);//确定v1和v2在G中位置,即顶点在G.vertices中的序号
ArcNode *p1=new ArcNode;//生成一个新的边结点*p1
p1->adjvex=j;//邻接点序号为j
p1->nextarc = G.vertices[i].firstarc;
G.vertices[i].firstarc=p1;//将新结点*p1插入顶点vi的边表头部
ArcNode *p2=new ArcNode;
p2->adjvex=i;
p2->nextarc = G.converse_vertices[j].firstarc;
G.converse_vertices[j].firstarc=p2;
}
return 1;
}
//求入度
void FindInDegree(ALGraph G){
int i , count;
for(i = 0 ; i < G.vexnum ; i++){
count = 0;
ArcNode *p = G.converse_vertices[i].firstarc;
if(p){
while(p){
p = p->nextarc;
count++;
}
}
indegree[i] = count;
}
}
//有向图G采用邻接表存储结构,若G无回路,则生成G的一个拓扑序列topo[]并,否则ERROR
int TopologicalSort(ALGraph G , int topo[]){
int i , m;
FindInDegree(G);
InitStack(S);
for(i = 0; i < G.vexnum; ++i){
if(!indegree[i]){
Push(S, i); //入度为0者进栈
}
}
m = 0;//对输出顶点计数,初始为0
while(!StackEmpty(S)){
Pop(S, i);//将栈顶顶点vi出栈
topo[m]=i;//将vi保存在拓扑序列数组topo中
++m;//对输出顶点计数
ArcNode *p = G.vertices[i].firstarc;//p指向vi的第一个邻接点
while(p){
int k = p->adjvex;//vk为vi的邻接点
--indegree[k];//vi的每个邻接点的入度减1
if(indegree[k] ==0){
Push(S, k); //若入度减为0,则入栈
}
p = p->nextarc;//p指向顶点vi下一个邻接结点
}
}
if(m < G.vexnum){
return 0;
}
return 1;
}
int main(){
ALGraph G;
CreateUDG(G);
int *topo = new int [G.vexnum];
cout << endl;
cout << "有向图的邻接表、逆邻接表创建完成" << endl<< endl;
if(TopologicalSort(G , topo)){
cout << "该有向图的拓扑有序序列为:";
for(int j = 0 ; j < G.vexnum; j++){
if(j != G.vexnum - 1){
cout << G.vertices[topo[j]].data << " , ";
}
else{
cout << G.vertices[topo[j]].data << endl << endl;
}
}
}
else{
cout << "网中存在环,无法进行拓扑排序!" <
(1.2)测试用例及其输出结果
测试用例1
程序运行结果1:
测试用例2:
程序运行结果2:
(2)简述算法步骤
S1:构建邻接表结构。
S2:构建栈,并定义初始化栈、进栈、出栈、判断空栈这四个函数体。初始化栈时,创建一个新的数组存放数据,并令顶指针为初始位置,栈空间大小为最大数。进栈时,先判断是否栈满,如果栈已满则直接return,如果栈未满则顶指针存入数据后后置++。出栈时,先判断是否栈空,如果栈空则直接return,如果栈非空则顶指针下移一位后弹出存放的数据。判断空栈时,如果顶指针和底指针相等,则当前栈为空栈,否则当前栈非空。
S3:构建“确定节点v在邻接表中的位置”函数。主要通过for循环遍历G,如果当前节点数据与目标节点v匹配,则返回当前节点的位置。如果循环结束后依然未匹配,则返回-1数值,表示节点v不存在于有向图G中。
S4:构建“创建有向图G的邻接表和逆邻接表”函数。首先需要输入总顶点数和总边数、各节点的名称、各边依附的节点信息。通过输入各节点的名称时生成邻接表和逆邻接表,并将指向第一条依附该节点的边的指针置空。接着通过输入各边依附的节点信息时,确定两个节点在有向图G中的位置,并生成两个个临时新边界点p1和p2,令p1、p2的邻接点序号分别为该边第二个节点的位置和第一个节点的位置,然后令p1、p2的下一条边为另外一个节点的第一条边指针。
S4:构建“求入度”函数。通过遍历节点,设置临时边指针p为逆邻接表中当前遍历节点的第一条边,当p非空的时候,p指向其下一条边,计数变量加一,然后输出当前节点的入度数。
S5:构建“邻接表存储结构”函数。先求出有向图G中各节点的入度,然后初始化一个栈,通过for循环遍历有向图G,并将入度为0的节点进行进栈操作。当存入的栈非空时,将顶指针指向的节点进行出栈操作,并保存在拓扑序列数组中,计数输出节点个数。接着,再临时新建一个p指针表示当前节点的第一条边指针。当p非空时,vk是vi的邻接点,vi的每个邻接点入度减去1。如果vk的入度为0,则将vk入栈,并令p指向vi的下一个邻接节点。最后通过if条件语句判断是否有回路,如果有回路则返回0,否则返回1。
S6:构造主函数。主要通过调用上述函数,得出拓扑序列。
(3)分析算法的时间复杂度
拓扑排序算法的主要思想为:
第一步,栈S初始化,累加器count初始化。
第二步,扫描顶点表,将没有前驱(即入度为0)的顶点压栈。
第三步,当栈S非空时循环,(1)vj=退出栈顶元素;输出vj;累加器加1;(2)将顶点vj的各个邻接点的入度减1;(3)将新的入度为0的顶点入栈。
第四步,if (count
如果AOV网络有n个顶点,e条边,在拓扑排序的过程中,搜索入度为零的顶点所需的时间是O(n)。在正常情况下,每个顶点进一次栈,出一次栈,所需时间O(n)。每个顶点入度减1的运算共执行了e次。所以总的时间复杂为O(n+e)。
题目2:
(1.1)实验源代码
#include
#include
using namespace std;
void half(int *a,int n){
int start=0,end=n-1;
while(start<=end){
int mid = start+((end-start)>>1); //折半查找
//a[mid]!=mid时,向前判断,因为肯定是之前的不等引发当前a[mid]!=mid
if(a[mid] != mid){
if(mid==0 || a[mid-1]==mid-1){
cout<>n;
cout<>a[i];
}
half(a,n);
return 0;
}
(1.2)测试用例及其输出结果
测试用例1:
n=3
array=【0,1,3】
程序运行结果1:
测试用例2:
n=9
array=【0,1,2,3,4,5,6,7,9】
程序运行结果2:
(2)简述算法步骤
S1:构造“折半查找”函数。首先设置下标值start、end和mid,mid即为缺失的数字的下标,之后利用while循环进行查找循环。每次折半查找都要更新min的值,由于该序列是隔1递增的,因此查找的终止条件为a[mid]!=mid。
S2:构造主函数。输入需要查找的数字和已知的递增序列,再通过调用half函数输出运行结果。
(3)分析算法的时间复杂度
折半查找判定树的构造:如果当前low和high之前有奇数个元素,则mid分隔后,左右两部分元素个数相等。如果当前low和high之间有偶数个元素,则mid分隔后,左半部分比右半部分少一个元素。
在折半查找的判定树中,若mid=(low+high)/2,向下取整,则对于任何一个结点,因此必有:右子树结点-左子树结点数=0或1。当有奇数个元素时等于0,有偶数个元素时等于1。所以折半查找判定数一定是平衡二叉树,树的深度为[log2n]+1。查找成功时所进行的关键码比较次数至多为[log2n]+1,查找不成功时和给定值进行比较的次数最多不超过树的深度。
综上所述,折半查找的时间复杂度为O(log2n)。
【补充:】请使用顺序查找算法进行时间复杂度对比分析。
【选作:】使用索引顺序表查找算法进行时间复杂度、空间复杂度的对比分析。
三、实验结果
顺序查找算法:
(1)源代码
//顺序查找算法
#include
#include
using namespace std;
int main(){
int n,a[1000],i;
cout<<"请输入n:";
cin>>n;
cout<<"请输入排序好的数组:";
for(i=0;i
(2)测试用例及其运行结果
(3)时间复杂度分析
最好情况:一次比较就找到所要查找的元素,时间复杂度为O(1)。最差情况:比较n次(共有n个元素),时间复杂度为O(n)。平均情况:综合两种情况,顺序查找的时间复杂度为O(n)。
索引顺序表查找算法:
(1)源代码
#include
#define BLOCK_NUMBER 3
#define BLOCK_LENGTH 6
typedef struct IndexNode
{
int data; //数据
int link; //指针
}IndexNode;
//索引表
IndexNode indextable[BLOCK_NUMBER];
//块间查找
int IndexSequlSearch(int s[], int l, IndexNode it[], int key){
int i = 0;
while (key > it[i].data && i < BLOCK_NUMBER){
i++;
}
if (i > BLOCK_NUMBER){
return -1;
}
else{//在块间顺序查找
int j = it[i].link - 1;
while (key != s[j] && j < l) {
j++;
}
if (key == s[j]){
return j + 1;
}
else{
return -1;
}
}
}
//建立索引表
void IndexTable(int s[], int l, IndexNode indextable[]){
int j = 0;
for (int i = 0; i < BLOCK_NUMBER; i++){
indextable[i].data = s[j];
indextable[i].link = j;
for (j; j < indextable[i].link + BLOCK_LENGTH && j < l; j++){
if (s[j] > indextable[i].data){
indextable[i].data = s[j];
}
}
}
for (int i = 0; i < BLOCK_NUMBER; i++){
indextable[i].link++;
}
}
//打印查找的数据元素以及其在线索表中的位置
void print(int searchNumber, int index){
if (index == -1){
printf("查找元素:%d\n", searchNumber);
printf("查找失败!\n");
return;
}
else{
printf("查找元素:%d\n", searchNumber);
printf("元素位置:%d\n", index);
return;
}
}
int main(){
int s[18] = {22,48,60,58,74,49,86,53,13,8,9,20,33,42,44,38,12,24};
IndexTable(s, 18, indextable);
printf("线索表:");
for (int i = 0; i < 18; i++){
printf("%d ",s[i]);
}
printf("\n");
int indexNumber1 = 38;
int index1 = IndexSequlSearch(s, 18, indextable, indexNumber1);
print(indexNumber1, index1);
int indexNumber2 = 28;
int index2 = IndexSequlSearch(s, 18, indextable, indexNumber2);
print(indexNumber2, index2);
return 0;
}
(2)测试用例及其运行结果
(3)时间、空间复杂度分析
算法思想:
首先,将n个数据元素"按块有序"划分为m块(m ≤ n)。每一块中的结点不必有序,但块与块之间必须"按块有序";即后一块中任一元素都必须大于前一块中最大的元素;然后,块之间进行二分或者顺序查找,块内进行顺序查找。
时间复杂度:
整体算法是对顺序查找的改进,介于顺序查找和二分查找之间,时间复杂度为O(log2m+n/m)。
空间复杂度:
一般情况下,为进行分块查找,可以将长度为n的表均匀分成b块,每块还有s个元素,即b = [n/s]。索引表采用顺序查找的方式,则查找成功时的平均查找长度为:(s+b+2)/2。