顺序查找算法实验报告

顺序查找算法实验报告（精选7篇）

1.顺序查找算法实验报告 篇一

实验六

查找

实验目的：

掌握几种查找的思想及算法 问题分析：

（一）顺序查找 1.查找思想

从表的一端开始逐个将记录的关键字和给定K值进行比较，若某个记录的关键字和给定K值相等，查找成功；否则，若扫描完整个表，仍然没有找到相应的记录，则查找失败。2.算法实现

int Seq_Search(SSTable ST,int key){

int p;

} ST.data[0].key=key;/* 设置监视哨兵,失败返回0 */ for(p=ST.length;ST.data[p].key!=key;p--);return(p);

3.算法分析

设查找每个记录成功的概率相等，即Pi=1/n；查找第i个元素成功的比较次数Ci=n-i+1 ； ◆ 查找成功时的平均查找长度ASL：

◆

包含查找不成功时：查找失败的比较次数为n+1，若成功与不成功的概率相等，对每个记录的查找概率为Pi=1/(2n)，则平均查找长度ASL：

（二）折半查找

前提条件：查找表中的所有记录是按关键字有序(升序或降序)。

查找过程中，先确定待查找记录在表中的范围，然后逐步缩小范围(每次将待查记录所在区间缩小一半)，直到找到或找不到记录为止。1.查找思想

用Low、High和Mid表示待查找区间的下界、上界和中间位置指针，初值为Low=1，High=n。

⑴

取中间位置Mid：Mid=(Low+High)/2 ；

⑵

比较中间位置记录的关键字与给定的K值： ①

相等： 查找成功；

②

大于：待查记录在区间的前半段，修改上界指针： High=Mid-1，转⑴ ； ③

小于：待查记录在区间的后半段，修改下界指针：Low=Mid+1，转⑴ ； 直到越界(Low>High)，查找失败。2.算法实现

int Bin_Search(SSTable ST , KeyType k){

int low=1，high=ST.length, mid;

while(low<=high){

mid=(low+high)/2;

if(EQ(ST.data[mid].key, k))

return(mid);

else if(LT(ST.dat[mid].key, k))

low=mid+1;

else high=mid-1;

}

return(0);

/*

查找失败

*/ } 3.算法分析

①

查找时每经过一次比较，查找范围就缩小一半，该过程可用一棵二叉树表示： ◆

根结点就是第一次进行比较的中间位置的记录； ◆ 排在中间位置前面的作为左子树的结点； ◆ 排在中间位置后面的作为右子树的结点；

对各子树来说都是相同的。这样所得到的二叉树称为判定树(Decision Tree)。②

将二叉判定树的第㏒2n+1层上的结点补齐就成为一棵满二叉树，深度不变，h= ㏒2(n+1)。4.算法分析

①

查找时每经过一次比较，查找范围就缩小一半，该过程可用一棵二叉树表示： ◆

根结点就是第一次进行比较的中间位置的记录； ◆ 排在中间位置前面的作为左子树的结点； ◆ 排在中间位置后面的作为右子树的结点；

对各子树来说都是相同的。这样所得到的二叉树称为判定树(Decision Tree)。②

将二叉判定树的第㏒2n+1层上的结点补齐就成为一棵满二叉树，深度不变，h= ㏒2(n+1)。

③

由满二叉树性质知，第i 层上的结点数为2i-1(i≤h)，设表中每个记录的查找概率相等，即Pi=1/n，查找成功时的平均查找长度ASL：

当n很大(n>50)时，ASL≈ ㏒2(n+1)-1。

（三）BST树 1.BST树的插入（1）插入思想

在BST树中插入一个新结点x时，若BST树为空，则令新结点x为插入后BST树的根结点；否则，将结点x的关键字与根结点T的关键字进行比较：

① 若相等： 不需要插入；

②

若x.keykey：结点x插入到T的左子树中； ③

若x.key>T->key：结点x插入到T的右子树中。（2）算法实现

递归算法

void Insert_BST(BSTree T , KeyType key){ BSTNode *s;s=(BSTNode *)malloc(sizeof(BSTNode));s->key=key;s->Lchild=s->Rchild=NULL;if(T==NULL)T=s;else { if(EQ(T->key, s->key))return;/* 已有结点

*/ else if(LT(s->key, T->key))Insert_BST(T->Lchild, key);else Insert_BST(T->Rchild, key);

} 非递归算法

void Insert_BST(BSTree T , KeyType key){ BSTNode *s, *p , *f;s=(BSTNode *)malloc(sizeof(BSTNode));s->key=key;s->Lchild=s->Rchild=NULL;if(T==NULL)T=s;else { p=T;

while(p!=NULL)

{

if(EQ(p->key, s->key))return;

f=p;

/*q作为p的父结点

*/

if(LT(s->key, p->key))p=p->Lchild;

else p=p->Rchild;

}

if(LT(s->key, f->key))f->Lchild=s;else f->Rchild=s;} }

利用BST树的插入操作，可以从空树开始逐个插入每个结点，从而建立一棵BST树，算法如下：

#define ENDKEY 65535 BSTree create_BST(){

KeyType key;BSTree T=NULL;scanf(“%d”, &key);while(key!=ENDKEY){

Insert_BST(T, key);scanf(“%d”, &key);} return(T);}

2.BST树的查找

（1）查找思想

首先将给定的K值与二叉排序树的根结点的关键字进行比较：若相等： 则查找成功； ① 给定的K值小于BST的根结点的关键字：继续在该结点的左子树上进行查找； ②

给定的K值大于BST的根结点的关键字：继续在该结点的右子树上进行查找。（2）算法实现

递归算法

BSTNode *BST_Serach(BSTree T , KeyType key)

{

if(T==NULL)return(NULL);else

{ if(EQ(T->key, key))return(T);else if(LT(key, T->key))

return(BST_Serach(T->Lchild, key));

else

return(BST_Serach(T->Rchild, key));} } 非递归算法

BSTNode *BST_Serach(BSTree T , KeyType key){ BSTNode * p=T;while(p!=NULL&&!EQ(p->key, key)){ if(LT(key, p->key))p=p->Lchild;else p=p->Rchild;} if(EQ(p->key, key))return(p);else return(NULL);} 在随机情况下，二叉排序树的平均查找长度ASL和㏒(n)(树的深度)是等数量级的。3.BST树的删除

（1）

删除操作过程分析

从BST树上删除一个结点，仍然要保证删除后满足BST的性质。设被删除结点为p，其父结点为f，删除情况如下： ①

若p是叶子结点： 直接删除p

②

若p只有一棵子树(左子树或右子树)：直接用p的左子树(或右子树)取代p的位置而成为f的一棵子树。即原来p是f 的左子树，则p的子树成为f 的左子树；原来p是f 的右子树，则p的子树成为f的右子树

③ 若p既有左子树又有右子树 ：处理方法有以下两种，可以任选其中一种。◆

用p的直接前驱结点代替p。即从p的左子树中选择值最大的结点s放在p的位置(用结点s的内容替换结点p内容)，然后删除结点s。s是p的左子树中的最右边的结点且没有右子树，对s的删除同②

◆ 用p的直接后继结点代替p。即从p的右子树中选择值最小的结点s放在p的位置(用结点s的内容替换结点p内容)，然后删除结点s。s是p的右子树中的最左边的结点且没有左子树，对s的删除同②（2）算法实现

void Delete_BST(BSTree T , KeyType key)

// 在以T为根结点的BST树中删除关键字为key的结点

{ BSTNode *p=T , *f=NULL , *q , *s;while(p!=NULL&&!EQ(p->key, key)){ f=p;//f 指向p的父结点

if(LT(key, p->key))p=p->Lchild;//搜索左子树

else p=p->Rchild;// 搜索右子树

} if(p==NULL)return;

// 没有要删除的结点 s=p;

// 找到了要删除的结点为p

if(p->Lchild!=NULL&& p->Rchild!=NULL)

{ f=p;s=p->Lchild;

// 从左子树开始找

while(s->Rchild!=NULL)

{

f=s;s=s->Rchild;

} // 左、右子树都不空，找左子树中最右边的结点

p->key=s->key;p->otherinfo=s->otherinfo;

// 用结点s的内容替换结点p内容

}

// 将第3种情况转换为第2种情况

if(s->Lchild!=NULL)

// 若s有左子树，右子树为空

q=s->Lchild;else q=s->Rchild;if(f==NULL)T=q;else if(f->Lchild==s)f->Lchild=q;

else f->Rchild=q;free(s);}

（四）哈希查找

1.基本思想：在记录的存储地址和它的关键字之间建立一个确定的对应关系；这样，不经过比较，一次存取就能得到所查元素的查找方法。2.哈希函数 除留余数法

取关键字被某个不大于哈希表表长m的数p除后所得余数作哈希地址，即H(key)=key

MOD p

(pm)3.冲突处理

★链地址法（拉链法）

方法：将所有关键字为同义词(散列地址相同)的记录存储在一个单链表中，并用一维数组存放链表的头指针。

设散列表长为m，定义一个一维指针数组： RecNode *linkhash[m]，其中RecNode是结点类型，每个分量的初值为空。凡散列地址为k的记录都插入到以linkhash[k]为头指针的链表中，插入位置可以在表头或表尾或按关键字排序插入。（1）链地址法查找

int Hash_Insert2(HTNode *T[ ], HTNode *s, int m)

{ HTNode *p=Hash_Search(T,s->key,m);

if(p!=NULL)

return 0;

//表中已有该结点

else {

d=h(s->key);

s->next=T[d];

T[d]=s;

return 1;

//插入成功

}

}

（2）链地址法插入

typedef struct node { KeyType key;struct node *next;}HTNode;

HTNode *hash_search2(HTNode *T[ ], KeyType k){ HTNode *p;

int i;p=T[h(k)];while(p!=NULL&&p->key!=k)

p=p->next;return p;} /*用链地址法解决冲突

*/

源程序清单：

#include #include typedef struct RecType{

int key;char info;}RecType;#define MAX_SIZE 100 typedef struct SSTable{

// 顺序表结构

RecType data[MAX_SIZE];

int length;}SSTable;

typedef struct Node{

//二叉树结构

int key;char info;struct Node *Lchild,*Rchild;}BSTNode;

typedef BSTNode * BSTree;

int Seq_Search(SSTable ST,int key){

//顺序查找

int p;

ST.data[0].key=key;for(p=ST.length;ST.data[p].key!=key;p--);return(p);}

void Bin_Search(SSTable ST,int key){ //折半查找

int low=1,high=ST.length,mid;int i,j,k;

} for(i=1;i

if(ST.data[j].key

k=j;} if(k!=i){

ST.data[0].key=ST.data[i].key;

ST.data[i].key=ST.data[k].key;

ST.data[k].key=ST.data[0].key;

ST.data[0].info=ST.data[i].info;

ST.data[i].info=ST.data[k].info;

ST.data[k].info=ST.data[0].info;} } while(low<=high){ mid=(low+high)/2;if(ST.data[mid].key==key)break;else if(ST.data[mid].keyhigh)printf(“Error!”);else printf(“%d,%cn”,ST.data[mid].key,ST.data[mid].info);BSTree Insert_BST(BSTree T,int key,char info){

//BST树的插入

BSTNode *s,*p,*f;s=(BSTNode *)malloc(sizeof(BSTNode));s->key=key;s->Lchild=s->Rchild=NULL;s->info=info;if(T==NULL)T=s;else{

p=T;

while(p!=NULL){

if(p->key==s->key)break;

f=p;

if(s->key

key)p=p->Lchild;

else p=p->Rchild;

}

if(s->keykey)f->Lchild=s;

else f->Rchild=s;} return T;}

void InorderTraverse(BSTree T){ if(T!=NULL){

InorderTraverse(T->Lchild);

printf(“%d,%ct”,T->key,T->info);

InorderTraverse(T->Rchild);} }

#define ENDKEY 65535 BSTree create_BST(SSTable ST){

//BST树的建立

BSTree T=NULL;int i,key,info;for(i=1;i<=ST.length;i++){

key=ST.data[i].key;

info=ST.data[i].info;

T=Insert_BST(T,key,info);} return T;} BSTNode *BST_Serach(BSTree T,int key){

if(T==NULL)return(NULL);else{

if(T->key==key)return(T);

else if(keykey)

return(BST_Serach(T->Lchild,key));

else

return(BST_Serach(T->Rchild,key));} }

BSTree Delete_BST(BSTree T, int key){

//BST树的删除

BSTNode *p=T,*f=NULL,*q,*s;while(p!=NULL&&(p->key!=key)){

f=p;

if(key

key)p=p->Lchild;

else p=p->Rchild;} if(p==NULL)return T;else s=p;if(p->Lchild!=NULL&&p->Rchild!=NULL){

f=p;s=p->Lchild;

while(s->Rchild!=NULL){

f=s;s=s->Rchild;

}

p->key=s->key;p->info=s->info;} if(s->Lchild!=NULL)q=s->Lchild;else q=s->Rchild;if(f==NULL)T=q;else if(f->Lchild==s)f->Lchild=q;else f->Rchild=q;free(s);return T;}

typedef struct node2{ int key;char info;struct node2 *next;}HTNode;HTNode *Hash_Search(HTNode *T[],int key,int m){

//链地址查找

HTNode *p;p=T[key%m];while(p!=NULL&&p->key!=key)p=p->next;return p;} HTNode *Hash_Insert(HTNode *T[],int key,char info,int m){

//链地址插入，建立哈希表

HTNode *s=(HTNode *)malloc(sizeof(HTNode));s->key=key;s->info=info;s->next=NULL;HTNode *p=Hash_Search(T,s->key,m);int d;if(p!=NULL)return *T;else{

d=s->key%m;

s->next=T[d];

T[d]=s;

} return *T;}

void main(){ int a,key,p,i,m;char info;SSTable ST;BSTree T=NULL;BSTNode *s;HTNode *HT[20];HTNode *ht;printf(“1.输入数据n2.顺序查找n3.折半查找n4.BST树的查找n5.BST树的插入n6.BST树的删除n7.链地址法查找n8.链地址法插入n0.退出n”);while(1){

printf(“n请选择：”);scanf(“%d”,&a);getchar();switch(a){ case 1: printf(“请输入记录数量n：”);scanf(“%d”,&ST.length);

printf(“请输入除数：”);scanf(“%d”,&m);

for(i=0;i<20;i++)HT[i]=NULL;for(i=1;i<=ST.length;i++){

printf(“请输入关键字码与数据：”);scanf(“%d,%c”,&ST.data[i].key,&ST.data[i].info);*HT=Hash_Insert(HT,ST.data[i].key,ST.data[i].info,m);}

T=create_BST(ST);printf(“已建立！”);break;case 2:printf(“请输入要查找的关键字码：”);scanf(“%d”,&key);p=Seq_Search(ST,key);printf(“%d,%cn”,ST.data[p].key,ST.data[p].info);break;case 3:printf(“请输入要查找的关键字码：”);scanf(“%d”,&key);Bin_Search(ST,key);break;case 4:printf(“请输入要查找的关键字码：”);scanf(“%d”,&key);s=BST_Serach(T,key);printf(“%d,%cn”,s->key,s->info);break;case 5:printf(“请输入要添加的关键字码及数据：”);scanf(“%d,%c”,&key,&info);T=Insert_BST(T,key,info);printf(“添加后的结果：”);InorderTraverse(T);printf(“n”);

}

} break;case 6:printf(“请输入要删除的关键字码：”);scanf(“%d”,&key);T=Delete_BST(T,key);

printf(“删除后的结果：”);InorderTraverse(T);printf(“n”);break;case 7:printf(“请输入要查找的关键字码：”);scanf(“%d”,&key);ht=Hash_Search(HT,key,m);printf(“%d,%cn”,ht->key,ht->info);break;case 8:printf(“请输入要添加的关键字码及数据：”);scanf(“%d,%c”,&key,&info);*HT=Hash_Insert(HT,key,info,m);for(i=0;i

ht=HT[i];

while(ht!=NULL){

printf(“%d,%ct”,ht->key,ht->info);

ht=ht->next;

} } break;case 0: exit(0);} 运行结果：

2.顺序查找算法实验报告 篇二

1 三种查找算法对比

三种算法都以700KB的藏文文本作为测试语料, 以7万条记录的数据库作为分词词典。

1.1 顺序查找

当采用顺序查找时, 其查找成功的平均查找长度为:

1.2 索引查找

1.3 二分查找

二分查找适用于表轻易不变, 且又经常进行查找的情况。其查找过程可以用一棵称作折半查找判定树的二叉树描述。设结点总数为n=2h-1, 则判定树是深度为h=log2 (n+1) 的满二叉树。在等概率情况下, 二分查找的平均查找长度为:

三种查找算法中二分查找效率最高, 且对分词词典不需频繁进行插入和删除操作, 因此, 二分查找算法最宜采用。

2 VC++.NET2010 下二分查找算法进行藏语自动分词过程

2.1 利用Excel软件给词典排序

因为作为二分查找对象的数据表必须是顺序存储的有序表, 所以首先要给词表排序, Microsoft Excel2007 和Microsoft Excel2010 中的排序功能可对藏文Unicode词表按内码大小排序。排序后, 将其导入Access数据库, 见表1。

2.2 二分查找代码

上面这段VC++.NET程序是利用二分查找算法在词表中进行匹配检索的核心代码, 其中Word是待匹配词, Dict是字符串数组即词表, 因它是全局变量, 已在TFind Word之外定义, 所以不必通过函数形参传递其值。第八行的String::Compare () 函数用于字符串比较, 它的两个参数分别是待匹配词和词表中的词, 若匹配成功, 函数将返回true, 否则返回false。

3 结语

随着Unicode编码的产生, 诸如Visual C++.NET等一些软件开发工具对藏文的兼容性越来越好, 使英汉信息处理领域比较成熟的处理手段可方便地运用到藏文文本处理上。本文先按藏文字符内码对藏文串进行排序, 然后在此基础上比较字符串大小, 旨在说明用特定的开发工具和程序设计语言编写藏文文本处理程序时, 在定义变量、自定义数组和函数调用等问题上如何作特殊化处理。

参考文献

[1]姚徐, 郭淑妮, 李永宏, 等.多级索引的藏语分词词典设计[J].计算机应用, 2009 (6) .

[2]王亚平.数据库系统工程师教程[M].北京:清华大学出版社, 2004:101, 394.

[3]陈玉忠.藏文自动分词系统的设计与实现[J].中文信息学报, 2003 (3) .

[4]郑阿奇.Visual C++.NET2010开发实践---基于C++/CLI[M].北京:电子工业出版社, 2010:12.

3.五种查找算法总结 篇三

一、顺序查找

条件：无序或有序队列。

原理：按顺序比较每个元素，直到找到关键字为止。

时间复杂度：O(n)二、二分查找（折半查找）

条件：有序数组

原理：查找过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；

如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。

如果在某一步骤数组为空，则代表找不到。

这种搜索算法每一次比较都使搜索范围缩小一半。

时间复杂度：O(logn)三、二叉排序树查找

条件：先创建二叉排序树：

1.若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

2.若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

3.它的左、右子树也分别为二叉排序树。

原理：

在二叉查找树b中查找x的过程为：

1.若b是空树，则搜索失败，否则：

2.若x等于b的根节点的数据域之值，则查找成功；否则：

3.若x小于b的根节点的数据域之值，则搜索左子树；否则：

4.查找右子树。

时间复杂度：

四、哈希表法（散列表）

条件：先创建哈希表（散列表）

原理：根据键值方式(Key value)进行查找，通过散列函数，定位数据元素。

时间复杂度：几乎是O(1)，取决于产生冲突的多少。

五、分块查找

原理：将n个数据元素“按块有序”划分为m块（m ≤ n）。

每一块中的结点不必有序，但块与块之间必须“按块有序”；即第1块中任一元素的关键字都必须小于第2块中任一元素的关键字；

而第2块中任一元素又都必须小于第3块中的任一元素，……。

4.页面置换算法模拟,实验报告 篇四

专

业

软件工程

课程名称

计算机操作系统

学

号

姓

名

辅导教师

张

静

成绩

实验日期 2015、１1、20 实验时间实验名称 :实验四

页面置换算法模拟 ２、实验目得(１）了解内存分页管理策略（2）掌握调页策略(3）掌握一般常用得调度算法（4）学会各种存储分配算法得实现方法。

（5）了解页面大小与内存实际容量对命中率得影响。

3、实验要求 编程实现页面置换算法，最少实现两种算法，比较算法得优劣,并将调试结果显示在计算机屏幕上，并检测机算与笔算得一致性。

（1）采用页式分配存储方案，通过分别计算不同算法得命中率来比较算法得优劣，同时也考虑页面大小及内存实际容量对命中率得影响;（2）实现 OＰT 算法(最优置换算法)、ＬRU 算法(Lｅast Recｅｎtly）、FIFO 算法（Fｉrst IN Firｓｔ Out）得模拟;（3)使用某种编程语言模拟页面置换算法.4、实验算法描述 （1）ＦIFO（先进先出）

Y

Ｎ

N

Y

开始 页面走向存入数组 p[]中,内存块用page[]表示初始化为 0 当前p[]中第i个元素就是否已在内Page[]就是否有空把 page[]中最先装入得页面置换出去、i++ 把 p[i]得内容直接装入最上面一个空内存块,i++ 输出当前内存块状态 i++

图 4－1FIFＯ算法流程图

结束

(2）

LＲU（最近最久未使用）

Y

N

Y

Ｎ

图 4—2

LＲU 算法流程图

开始 页面走向存入数组 p[]中,内存块用 page[]表示初始化为 0 当前 p[]中第 i 个元素就是否已在内存 Page[]就是否有空把 page[]中最近最久未使用得页面置换出去、i++ 把 p[i]得内容直接装入最上面一个空内存块,i++ 输出当前内存块状态

结束 i++

(3）OＰＴ（最佳置换算法）

Y

N

Y

Ｎ

图４－3 ＯPT 流程图

开始 页面走向存入数组 p[]中,内存块用 page[]表示初始化为 0 当前 p[]中第 i 个元素就是否已在内存 Page[]就是否有空把 page[]中以后一段时间都不使用或就是使用时间离现在最远得换出、i++ 把 p[i]得内容直接装入最上面一个空内存块,i++ 输出当前内存块状态

结束 i++

6、实验代码 ＃iｎcｌuｄe ＜iostreａm〉 usiｎｇ ｎａmespace sｔｄ;#defiｎe Bｓｉzｅ ３ #dｅfine Psｉｚe 20 ｓｔruct ｐaｇｅInｆor ｛

号面页//

;ｔneｔｎoc tniﻩ int tｉmer;

//被访问标记 ｝;ｃlasｓ ＰＲA{ ｐuｂｌiｃ：

PRA(ｖoid）；

存内闲空有否是就找查/／

;)diov（eｃaｐSdnif tniﻩ iｎt ｆindExist（int curpage）;

／／查找内存中就是否有该页面

int findReplacｅ（vｏid）;

//查找应予置换得页面

void ｄisplay(void）;

//显示

法算 OＦIF//;）dioｖ（OFIＦ ｄiovﻩ 法算 UＲL／/；)dｉov(URL diovﻩ vｏid Ｏptimａl(ｖoid);／／ＯPTIＭAL 算法

ｖoｉd BlockＣlear（voiｄ)；/／ＢLOCK 恢复

pageＩｎfor ＊ ｂlｏck；//物理块

pageInfoｒ ＊ page；／／页面号串 privaｔe: };PＲA：：PＲＡ(vｏid）{

ｉnt QStriｎg［２0］=｛7，0，1，２,0，3,0，4,２，3,0,3,２,1，2，0，1,7,0,１};

block = ｎew paｇeIｎfor[Bｓizｅ］;)++i;ｅzisB＜ｉ;0＝i ｔnｉ(rofﻩ {

;1— = tnｅtnｏc、］ｉ［ｋcolbﻩ ；0 ＝ remｉt、]ｉ［kcolbﻩﻩ }

page = ｎew pageInfｏｒ［Psｉze];）＋+ｉ;eｚiｓP〈i ；０=i（ｒofﻩ {

；]i[gｎiｒtSQ = tｎetnoｃ、］i[egａpﻩ;0 = rｅmit、]i[eｇａｐﻩﻩ }ﻩ} iｎt ＰRA：：fｉndSpace（voiｄ）

{

for（iｎt i=0； i

if(bｌocｋ[i]、cｏntent =＝ －1）

置位中 KＣOLＢ回返，存内闲空到找//;i nrutｅｒﻩ;1— ｎruteｒﻩ｝ inｔ ＰRA：：fiｎｄExisｔ（iｎt cｕrpage）

{

ｆor（int i=0;ｉ<Ｂsizｅ； i++））tｎetnｏc、]egapruc［ｅgａp =＝ tneｔｎoc、］ｉ［kｃoｌb(fiﻩﻩ

置位中 KCOＬB 回返,面页该有中存内到找//;i nrｕterﻩ ；1— nruterﻩ｝ iｎt PRA：：findReplａce(void）

{

;0 ＝ sop tｎiﻩ foｒ（iｎt i=0;i<Ｂsｉzｅ； ｉ+＋）)rｅmit、］soｐ[ｋcｏlb =＞ rｅmit、］i［kcｏlb（fiﻩﻩ

ﻩ pos = i;//找到应予置换页面,返回 BLOCＫ中位置

ｒeturn pos； } voｉd ＰRＡ：:display（voiｄ）

{

for（inｔ i=0;i＜Ｂsiｚe； ｉ++）

ｉｆ(bｌock［ｉ］、coｎteｎｔ!＝-１）

ﻩ；” ”<〈ｔnetnoc、］i[kcｏlb〈〈tuocﻩ ；ldｎe＜＜tuocﻩ｝ void PRA：：Optimａｌ（ｖoid)｛

； noｉtisop,ecapｓ，tsiｘe tｎiﻩ fｏr（ｉnt i=0； i

｛ﻩ;)i（tsixEdｎif = tｓｉxeﻩﻩ）1-=！

ｔsixe（fｉﻩ

{ﻩ

;ｌdnｅ〈〈”页缺不“<<ｔｕoｃﻩ ｝ﻩﻩ

esｌｅﻩ

{ﻩﻩ ﻩﻩ spａｃe = findSpacｅ（）；

ﻩ）1— ＝！

eｃaｐs（fiﻩ ﻩ

{ﻩ ﻩ

；]i［egaｐ = ］eｃapｓ［kcolｂﻩ

ﻩ

;）（yalpsidﻩﻩ

ﻩ }

ﻩ

ｅslｅﻩ

{ﻩﻩ ﻩ)+＋k ；ezisB<ｋ ；0＝k tｎｉ（roｆﻩ

ﻩ for（iｎｔ j＝i； j＜Psize； ｊ+＋)

ﻩ

{ﻩﻩﻩ

ﻩﻩ)ｔnetnoc、]ｊ［ｅgaｐ =!ｔnｅtnoc、］k[ｋcolb（ｆiﻩ

｛ 为 RＥMＩT 置设，用会不来将//};00０1 = ｒemiｔ、］k［kcoｌbﻩﻩ一个很大数

ﻩﻩ

esleﻩ

ﻩﻩ

｛

ﻩﻩ

ﻩ

ﻩ bloｃk［k]、ｔｉmeｒ = j;

ﻩ

ﻩﻩ ｂreaｋ；

｝ ﻩﻩﻩ }ﻩﻩﻩﻩﻩ

ﻩ ｐoｓition ＝ fiｎdReｐｌａce（）；

ﻩ

；］i［ｅｇap ＝ ]ｎｏiｔｉｓｏｐ[ｋcolｂﻩ

；）(yalｐsｉｄﻩﻩ

｝ﻩﻩ ﻩ }

}ﻩ｝ voiｄ PRA:：LRU（ｖoid){

int ｅxｉsｔ,ｓpace，ｐositioｎ ；

for(int ｉ ＝ 0； i < Psizｅ;ｉ++）

｛ﻩ ﻩ ｅxist = fｉndEｘｉst(i);)1－ =！

tsｉxｅ(ｆiﻩ

{

ﻩﻩ cout＜<”不缺页”＜

ﻩ

blｏck［eｘisｔ］、tiｍｅｒ = —1；//恢复存在得并刚访问过得ＢLOCK 中页面 TＩMＥR 为－1

ﻩ }

ﻩ else

｛ﻩ ﻩﻩ sｐace = fｉｎdSpace();ﻩ）１-=!ecaｐs（fiﻩ ﻩ

{ﻩ;]i[ｅgａp = ］ecaｐs［ｋｃolｂﻩﻩ ﻩ

；)（ｙalpｓidﻩ ﻩﻩ ｝

ﻩ

eｓleﻩ

｛ﻩﻩ

；）（eｃａｌｐeRｄｎif = noｉtiｓopﻩﻩ

ﻩ

bｌoｃk[positiｏn］ = ｐagｅ［i］；

ﻩ

;）(yａlｐsidﻩ

｝ﻩﻩ

｝ﻩ

for(int ｊ=0;j〈Ｂsizｅ;j++)

;+＋rｅmit、］j[kcolbﻩﻩ ｝ﻩ｝ ｖoｉd PRA:：ＦIFO（ｖoid）

{

int exｉｓt,ｓpace,position ；

for（iｎt i=0;i

｛ﻩ

exｉｓt ＝ findExist(ｉ）；

ﻩ ｉf（eｘist!＝-１）

{cout＜<＂不缺页＂＜

esleﻩ

｛

sｐａce = findSｐａｃe（）；

ﻩ)1-=！

ecaｐs（ｆiﻩ ﻩﻩ ｛

ﻩ

block［spaｃｅ］ = paｇe[ｉ]；

ﻩ

ﻩ displaｙ();

｝ﻩﻩ

ｅsｌeﻩﻩ ﻩ

｛

ﻩﻩ

pｏsition = findReplaｃe（）；

ﻩﻩ

block［pｏsitioｎ] ＝ paｇe[i］；

;)（yａlｐsｉdﻩﻩ ﻩﻩ ｝

}ﻩ）＋+j;ezｉsB

ｂlock[j］、tｉmｅr+＋；//BLOCK 中所有页面ＴIMER+＋

｝ﻩ｝ void ＰＲA：：BlockＣleａr（vｏiｄ)｛

for(inｔ ｉ=０;i

{ﻩ

blocｋ[i］、contｅnt =-1；

ﻩ ｂｌｏcｋ[i]、timeｒ = ０;

｝

} ｖoid mａｉn(vｏiｄ)｛

;lｄne<〈”:法 算 换 置 面 页“＜＜tuｏcﻩ ｃｏｕｔ〈〈”页面号引用串：7,０,1,2，0,3,0，4,2，３，0，３,2,1,2，0，1，7，０,1＂<〈ｅndｌ；

cout〈〈”选择<１＞应用 LＲU 算法”〈＜eｎdl；

coｕt<＜”选择<２〉应用 FIFO 算法”〈

ｃout<<”选择＜3>应用 Optｉmａl 算法“<〈ｅndl;

；ldne<<＂出退>0〈择选”〈＜ｔuocﻩ int select；

ＰRA tesｔ;ﻩ whｉle(seleｃｔ)

｛

ﻩ cｉｎ〉>select;）tcｅｌｅs（ｈctｉwsﻩ

｛ﻩ

:0 esacﻩﻩ;ｋaerbﻩ :1 esａcﻩﻩﻩ;ｌdnｅ＜<“：下如果结法算ＵRL”＜〈tuocﻩ

;）（URL、tsetﻩﻩ

；)(raelCkｃｏｌB、tｓeｔﻩﻩ;ldne＜<”－－-—-—－-—-—--—-—－—－———“<

ﻩ break；

：2 esacﻩ

cｏut<〈”FIFO 算法结果如下:“<＜endl；

tesｔ、FIFO();ﻩ；）（raelCｋcoｌＢ、ｔsetﻩ

ﻩ cｏuｔ<〈”-——-－－－－－-—－—－－---－—－-”＜〈eｎdl;

ﻩ

ｂreak；

caｓe 3:

；ｌdnｅ〈＜”：下如果结法算 lａmiｔｐＯ”<

test、Optimal（）;

ﻩ

；)（rａeｌCkｃolB、tｓetﻩﻩ；ldｎe＜<＂－-－-—－－--－-——-－————－－－＂〈〈tuocﻩﻩ;ｋaeｒbﻩ

defaulｔ：

ﻩ

；ldｎe〈＜”号能功确正入输请“＜＜tuoｃﻩ

;ｋaerbﻩﻩ }ﻩﻩ } ｝

6、实验结果

7、实验心得 加深了对操作系统得认识,了解了操作系统中各种资源分配算法得实现，特别就是对虚拟存储，页面置换有了深入得了解，并能够用高级语言进行模拟演示。在这短短得两周时间里，通过浏览、阅读有关得资料，学到了很多东西,同时也发现仅仅书本得知识就是远远不够得,需要把知识运用到实践中去,能力才能得到提高。

5.顺序查找算法实验报告 篇五

一、实验目的

本实验主要对操作系统中请求分页式内存管理及其应用的一些关键算法进行模拟。学生通过设计与实现Clock算法，能够加强对相应理论的理解，并对了解操作系统内部的基本处理原理与过程也有很多益处。

二、实验要求

基本要求：描述Clock算法的基本原理、必要的数据结构、算法执行流程图、编码实现。

1）初始化：输入作业可占用的总页框数，初始化置空。

2）输入请求序列：输入一个作业页号访问请求序列，依次占用相应页框，直至全部占用； 3）Clock算法：当页框全部占用后，对于后续新的页号访问请求，执行Clock算法，淘汰1个页面后装入新的页号。

4）显示当前分配淘汰序列：显示淘汰的页号序列。

描述Clock算法的基本原理、必要的数据结构、算法执行流程图、编码实现。

三、实验内容

1)基本原理

时钟页面置换算法是把所有的页面都保存在一个类似钟面的环形链表中，一个表针指向最老的页面，如图所示。

当发生缺页中断时，算法首先检查表针指向的页面，如果它的R位是0就淘汰该页面，并把新的页面插入这个位置，然后把表针前移一个位置；如果R位是1就清除R位并把表针前移一个位置，重复这个过程直到找到了一个R位为0的页面为止。2)算法流程设计

主函数流程: STEP1:输入分配的页框数，页面访问次数和要访问的页面号序列 STEP2:内存页面初始化。内存中页面的数据结构为单循环链表，含有页号值yehao和访问位值a。开始时页号均为-1，访问位为0.STEP3：测试数据。具体算法是依要访问的页面号，调用find()函数查找是否已经存在于内存中。若存在，则修改其访问位为1.若不存在，触发缺页中断，调用tihuan()函数。最后，打印当前内存状态。如此循环直至测试串都访问完毕。3)主要函数实现

a)Makenode(double)函数：用于初始化一个节点。

b)Find（double）函数：依据输入的页号，查询内存中是否已存在此页面。若存在返回值1，不存在返回值0.c)Tihuan（double）函数：在发生缺页中断时，时钟指针查找访问位为0的页面进行替换，指针扫过的页面访问位置0，新加入的页面访问位置1。替换后指针下移。

d)Print_state()函数：打印当前内存中存在的页面的状态以及当前时钟指针所指向的页面位置。

4)测试数据

输入：

输入分配的页框数 3 输入页面访问次数 15 输入要访问的页面号序列 3 4 2 6 4 3 7 4 3 6 3 4 8 4 6 输出（仅最后一项）：

5)结果分析

以下是clock算法对应输入页面号序列3 4 2 6 4 3 7 4 3 6 3 4 8 4 6的分析表

四、实验总结

1.加深对clock算法的理解。通过与其他算法的比较，我也了解了他们的异同之处。Clock算法其实是一种改进的第二次机会算法，它通过设置访问位，找到最早最不常访问的页面，即标号为0的页面。之所以叫clock算法，依我理解是将内存中的排列顺序附上时间的概念，clock指针扫过的页面要将他们1置0就是基于这个思想，因为他们都是没被访问的，且在时钟上的排列按照访问时间顺序。这样就保证了每次替换的都是最早进来的且不最常访问的页面。

2.在时钟内存结构的代码实现上，我使用了自建的单循环链表，对其进行顺序地遍历即可实现时钟指针的移动。另外通过全局变量node *r（时钟）node *start（开始页面项）node *r_prev（时钟指针的前驱）的设置，方便了有关算法的实现。

3.此算法较为简单，还有一种改进版的clock算法，增加了一个修改位，表示页框是否被修改过。这样的设计更加符合现在操作系统的调度原则。

参考文献

6.顺序查找算法实验报告 篇六

题 目 利用银行家算法避免死锁

一、实验目的：

1、加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

2、要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。

二、实验内容：

用银行家算法实现资源分配：

设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统，例如，{A,B,C}的资源数量分别为10，5，7。进程可动态地申请资源和释放资源，系统按进程的申请动态地分配资源，要求程序具有显示和打印各进程的某一个时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。

三、问题分析与设计：

1、算法思路：

先对用户提出的请求进行合法性检查，即检查请求是否大于需要的，是否大于可利用的。若请求合法，则进行预分配，对分配后的状态调用安全性算法进行检查。若安全，则分配；若不安全，则拒绝申请，恢复到原来的状态，拒绝申请。

2、银行家算法步骤：

（1）如果Requesti＜or =Need,则转向步骤(2)；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。

（2）如果Request＜or=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。

（3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值：

Available=Available-Request[i];

Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

3、安全性算法步骤：（1）设置两个向量

①工作向量Work。它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation;②布尔向量Finish。它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]=true。

（2）从进程集合中找到一个能满足下述条件的进程：

①Finish[i]=false ②Need

（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行： Work=Work+Allocation;Finish[i]=true;转向步骤（2）。

（4）如果所有进程的Finish[i]=true,则表示系统处于安全状态；否则，系统处于不安全状态。

4、流程图： 系统主要过程流程图

银行家算法流程图

安全性算法流程图

5、主要数据结构

假设有M个进程N类资源，则有如下数据结构：

int max[M*N] M个进程对N类资源的最大需求量 int available[N] 系统可用资源数

int allocated[M*N] M个进程已经得到N类资源的资源量 int need[M*N] M个进程还需要N类资源的资源量

int worked[] 系统提供给进程继续运行所需的各类资源数目

四、源代码

import java.awt.*;import javax.swing.*;import java.util.*;import java.awt.event.*;import javax.swing.border.*;

public class OsBanker extends JFrame { // 界面设计

JLabel labelInfo;JLabel labelInfo1;int resourceNum, processNum;int count = 0;JButton buttonRequest, buttonSetInit, button, button1, buttonsearch,button2;JTextField tf1, tf2;JTextField[] textAvailable;JTextField[][] textAllocation;JTextField[][] textNeed;JTextField textProcessName;JTextField[] textRequest;int available[];int max[][];int need[][];int allocated[][];int SafeSequence[];int request[];boolean Finish[];int worked[];boolean flag = false;JFrame f1;JFrame f2;JFrame f3;JTextArea jt;

void display(){

Border border = BorderFactory.createLoweredBevelBorder();

Border borderTitled = BorderFactory.createTitledBorder(border, “按钮区”);

textAvailable = new JTextField[5];

textAllocation = new JTextField[6][5];

textNeed = new JTextField[6][5];

textProcessName = new JTextField(“");

textProcessName.setEnabled(false);

textRequest = new JTextField[5];

tf1 = new JTextField(20);

tf2 = new JTextField(20);labelInfo = new JLabel(”请先输入资源个数和进程个数（1~6），后单击确定“);JPanel contentPane;contentPane =(JPanel)this.getContentPane();contentPane.setLayout(null);contentPane.setBackground(Color.pink);labelInfo.setBounds(50, 10, 300, 40);labelInfo.setOpaque(true);labelInfo.setForeground(Color.red);labelInfo.setBackground(Color.pink);contentPane.add(labelInfo, null);JLabel b1 = new JLabel(”资源个数:“);b1.setForeground(Color.blue);JLabel b2 = new JLabel(”进程个数:“);b2.setForeground(Color.blue);b1.setBounds(50, 80, 80, 30);contentPane.add(b1, null);tf1.setBounds(180, 80, 170, 30);contentPane.add(tf1, null);b2.setBounds(50, 150, 80, 30);contentPane.add(b2, null);tf2.setBounds(180, 150, 170, 30);contentPane.add(tf2, null);button1 = new JButton(”确定“);button = new JButton(”重置“);button1.setBounds(80, 200, 80, 30);contentPane.add(button1, null);button.setBounds(220, 200, 80, 30);contentPane.add(button, null);this.setSize(400, 300);this.setResizable(false);this.setTitle(”银行家算法(SXJ)“);this.setLocationRelativeTo(null);this.setDefaultCloseOperation(EXIT_ON_CLOSE);this.setVisible(true);f1 = new JFrame();labelInfo1 = new JLabel(”请先输入最大需求和分配矩阵，然后单击初始化“);JPanel contentPane1;contentPane1 =(JPanel)f1.getContentPane();contentPane1.setLayout(null);contentPane1.setBackground(Color.pink);labelInfo1.setOpaque(true);labelInfo1.setBounds(75, 10, 400, 40);

labelInfo1.setBackground(Color.pink);

labelInfo1.setForeground(Color.blue);

contentPane1.add(labelInfo1, null);

JLabel labelAvailableLabel = new JLabel(”AllResource:“);

JLabel labelNeedLabel = new JLabel(”MaxNeed:“);

JLabel labelAllocationLabel = new JLabel(”allocated:“);

JLabel labelRequestLabel = new JLabel(”request process:“);

labelNeedLabel.setBounds(75, 90, 100, 20);

// x,y,width,height

contentPane1.add(labelNeedLabel, null);

labelAllocationLabel.setBounds(75, 240, 100, 20);

contentPane1.add(labelAllocationLabel, null);

labelAvailableLabel.setBounds(75, 70, 100, 20);

contentPane1.add(labelAvailableLabel, null);

labelRequestLabel.setBounds(75, 400, 100, 20);

contentPane1.add(labelRequestLabel, null);

JLabel[] labelProcessLabel1 = { new JLabel(”进程1“), new JLabel(”进程2“)，new JLabel(”进程3“), new JLabel(”进程4“), new JLabel(”进程5“)，new JLabel(”进程6“)};

JLabel[] labelProcessLabel2 = { new JLabel(”进程1“), new JLabel(”进程2“)，new JLabel(”进程3“), new JLabel(”进程4“), new JLabel(”进程5“)，new JLabel(”进程6“)};

JPanel pPanel1 = new JPanel(), pPanel2 = new JPanel(), pPanel3 = new JPanel(), pPanel4 = new JPanel();

pPanel1.setLayout(null);

pPanel2.setLayout(null);

/*

* pPanel4.setLayout(null);pPanel4.setBounds(440,120,90,270);

* pPanel4.setBorder(borderTitled);

*/

buttonSetInit = new JButton(”初始化“);

buttonsearch = new JButton(”检测安全性“);

button2 = new JButton(”重置“);

buttonRequest = new JButton(”请求资源“);

buttonSetInit.setBounds(420, 140, 100, 30);

contentPane1.add(buttonSetInit, null);

buttonsearch.setBounds(420, 240, 100, 30);

contentPane1.add(buttonsearch, null);

button2.setBounds(420, 340, 100, 30);

contentPane1.add(button2, null);

buttonRequest.setBounds(420, 425, 100, 30);

contentPane1.add(buttonRequest, null);

for(int pi = 0;pi < 6;pi++){

labelProcessLabel1[pi].setBounds(0, 0 + pi * 20, 60, 20);labelProcessLabel2[pi].setBounds(0, 0 + pi * 20, 60, 20);} pPanel1.setBounds(75, 120, 60, 120);pPanel2.setBounds(75, 270, 60, 120);for(int pi = 0;pi < 6;pi++){ pPanel1.add(labelProcessLabel1[pi], null);pPanel2.add(labelProcessLabel2[pi], null);} contentPane1.add(pPanel1);contentPane1.add(pPanel2);contentPane1.add(pPanel4);for(int si = 0;si < 5;si++)for(int pi = 0;pi < 6;pi++){

textNeed[pi][si] = new JTextField();

textNeed[pi][si]

.setBounds(150 + si * 50, 120 + pi * 20, 50, 20);

textNeed[pi][si].setEditable(false);

textAllocation[pi][si] = new JTextField();

textAllocation[pi][si].setBounds(150 + si * 50, 270 + pi * 20，50, 20);

textAllocation[pi][si].setEditable(false);} for(int si = 0;si < 5;si++){ textAvailable[si] = new JTextField();textAvailable[si].setEditable(false);textAvailable[si].setBounds(150 + si * 50, 70, 50, 20);textRequest[si] = new JTextField();textRequest[si].setEditable(false);textRequest[si].setBounds(150 + si * 50, 430, 50, 20);contentPane1.add(textAvailable[si], null);contentPane1.add(textRequest[si], null);} for(int pi = 0;pi < 6;pi++)for(int si = 0;si < 5;si++){

contentPane1.add(textNeed[pi][si], null);

contentPane1.add(textAllocation[pi][si], null);} textProcessName.setBounds(80, 430, 50, 20);contentPane1.add(textProcessName, null);f1.setSize(550, 500);

f1.setResizable(false);

f1.setTitle(”银行家算法(SXJ)“);

f1.setLocationRelativeTo(null);

f1.setDefaultCloseOperation(EXIT_ON_CLOSE);

// f1.setVisible(true);

f1.setVisible(false);

f2 = new JFrame(”安全序列显示框“);

jt = new JTextArea(75, 40);

jt.setBackground(Color.pink);

jt.setForeground(Color.blue);

JScrollPane scrollPane = new JScrollPane(jt);// 加滚动条

scrollPane.setBorder(BorderFactory.createLoweredBevelBorder());// 边界

(f2.getContentPane()).add(scrollPane);

f2.setSize(450, 400);

f2.setResizable(false);

f2.setDefaultCloseOperation(EXIT_ON_CLOSE);

f2.setVisible(false);

buttonSetInit.setEnabled(false);

buttonRequest.setEnabled(false);

buttonsearch.setEnabled(false);

button1.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){

// labelInfo.setText(”请先初始化allocated和Maxneed，后单击初始化按钮“);

f1.setVisible(true);

buttonSetInit.setEnabled(true);

resourceNum = Integer.parseInt(tf1.getText());

processNum = Integer.parseInt(tf2.getText());

for(int i = 0;i < processNum;i++){

for(int j = 0;j < resourceNum;j++){

textNeed[i][j].setEditable(true);

textAllocation[i][j].setEditable(true);

textAvailable[j].setEditable(true);

}

}

}

});

buttonSetInit.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){

Init();

buttonsearch.setEnabled(true);

}

});

buttonsearch.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){ count = 0;SafeSequence = new int[processNum];worked = new int[resourceNum];Finish = new boolean[processNum];copyVector(worked, available);Safety(0);jt.append(”安全序列数量：“ + count);if(flag){

labelInfo1.setText(”当前系统状态：安全“);

f2.setVisible(true);

buttonRequest.setEnabled(true);

textProcessName.setEnabled(true);

for(int i = 0;i < resourceNum;i++){

textRequest[i].setEditable(true);

} } else {

labelInfo1.setText(”当前系统状态：不安全“);} buttonSetInit.setEnabled(false);} });buttonRequest.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

count = 0;

for(int i = 0;i < processNum;i++){

Finish[i] = false;

}

jt.setText(”“);

flag = false;RequestResource();} });button2.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

/*

* tf1.setText(”“);tf2.setText(”“);

*/

f2.setVisible(false);

jt.setText(”“);

for(int i = 0;i < processNum;i++){

}

for(int j = 0;j < resourceNum;j++){

textNeed[i][j].setText(”“);

textAllocation[i][j].setText(”“);

textAvailable[j].setText(”“);

textRequest[j].setText(”“);

// textNeed[i][j].setEditable(false);

// textAllocation[i][j].setEditable(false);

// textAvailable[j].setEditable(false);

textRequest[j].setEditable(false);

textProcessName.setText(”“);

Finish[i] = false;

}

}

flag = false;

buttonsearch.setEnabled(false);

// labelInfo.setText(”请先输入资源个数和进程个数，后单击确定“);} });button.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

tf1.setText(”“);

tf2.setText(”“);

f2.setVisible(false);

jt.setText(”“);flag = false;} });void copyVector(int[] v1, int[] v2){ for(int i = 0;i < v1.length;i++)

v1[i] = v2[i];} void Add(int[] v1, int[] v2){ for(int i = 0;i < v1.length;i++)

v1[i] += v2[i];} void Sub(int[] v1, int[] v2){ for(int i = 0;i < v1.length;i++)

} v1[i]-= v2[i];boolean Smaller(int[] v1, int[] v2){ boolean value = true;for(int i = 0;i < v1.length;i++)

if(v1[i] > v2[i]){

value = false;

break;

} return value;} public static void main(String[] args){ OsBanker ob = new OsBanker();ob.display();// System.out.println(” “+count);} void Init()// 初始化操作矩阵 { available = new int[resourceNum];for(int i = 0;i < resourceNum;i++){

available[i] = Integer.parseInt(textAvailable[i].getText());} max = new int[processNum][resourceNum];allocated = new int[processNum][resourceNum];need = new int[processNum][resourceNum];for(int i = 0;i < processNum;i++){

for(int j = 0;j < resourceNum;j++){

max[i][j] = Integer.parseInt(textNeed[i][j].getText());

allocated[i][j] = Integer.parseInt(textAllocation[i][j]

.getText());

} } for(int i = 0;i < resourceNum;i++)

for(int j = 0;j < processNum;j++)

need[j][i] = max[j][i]1);

request = new int[resourceNum];

for(int i = 0;i < resourceNum;i++){

request[i] = Integer.parseInt(textRequest[i].getText());

}

if(!Smaller(request, need[processname])){

labelInfo.setText(”资源请求不符该进程的需求量.“);

} else if(!Smaller(request, available)){

labelInfo1.setText(”可用资源不足以满足请求,进程需要等待.“);

} else {

Sub(available, request);

Add(allocated[processname], request);

Sub(need[processname], request);

copyVector(worked, available);

Safety(0);

if(flag){

labelInfo1.setText(”可立即分配给该进程!“);

} else {

labelInfo1.setText(”分配后导致系统处于不安全状态!,不可立即分配");

Add(available, request);

Sub(allocated[processname], request);

Add(need[processname], request);

}

}

// } } }

五、实验结果：

初始界面：

初始化：

检测安全性：

请求资源：

（1）进程2（1，0，2）

（2）进程5（3，3，0）

（3）进程1（0，2，0）

六、遇到的问题及不足之处：

1、程序编写的时候规定最大资源数和最大进程数均<=6。

2、程序直接初始化了6个进程框，既浪费了内存空间，又对可视化界面的美观造成影响。

3、未对输入异常进行处理：比如在请求资源的第一个方框中只能填入进程的数字编号，当填入的为非整数时，程序会抛出异常。

7.顺序查找算法实验报告 篇七

JAVA实验报告

一、JAVA编程模拟密码攻击MimaGongji 1.模拟密码攻击MimaGongji功能需求分析

编程模拟密码攻击的过程，实现下述功能：

（1）键盘输入12位密码，包括字母和数字；

（2）采用穷举法进行攻击，直到破解密码为止；

（3）屏幕输出试验的次数，并输出获得的密码。

2.MimaGongji基本设计思路

1）基于对MimaGongji功能需求的分析，MimaGongji这个类作为主类，实现主要功能，包括密码的流输入，密码的穷举法破解和破解后密码的输出。2）Java.io.*这个包主要实现数据的流输入和流输出。

3）public static void main(String[] args)这个方法是主要的方法，实现密码的键盘输入，采用穷举法进行攻击，并屏幕输出试验的次数和获得的密码。4）.length（）这个方法主要是计算一个字符串的长度

3.实验步骤

1）Java程序代码（*.java）和详细的行注释 //文件名称为“MimaGongji.java” import java.io.*;//加入java的流输入和流输出包 class MimaGongji //定义主类 {

public static void main(String[] args)//引入主要方法 {

String s=“";try{ BufferedReader

mima=

new

BufferedReader(new InputStreamReader(System.in));//定义密码的流输入

JAVA实验报告

//统计试验的次数

}

System.out.print(po);

} //输出破解之后的密码

} System.out.println();//换行 System.out.println(”试验次数:“+g);//输出提示“试验的次数”

} }//类申明的结束

2)程序的运行（包括运行的过程、界面和结果图）

首先编写如上所示的源程序，保存文件名称为“MimaGongji.java”，然后编译源程序，编译完成后，生成一个字节码文件MimaGongji.class，执行这个程序，得到如下图所示的窗口：

JAVA实验报告

getContentPane().add(pb,BorderLayout.SOUTH);//把面板添加到窗口上

t1=new JTextField(50);//创建文本框

t2=new JTextField(50);//创建文本框

t3=new JTextField(50);//创建文本框 t4=new JTextField(5);//创建文本框 t5=new JTextField(5);//创建文本框 t6=new JTextField(5);//创建文本框

t2.setEditable(false);//定义文本框的不可书写

t4.setEditable(false);//定义文本框的不可书写

t5.setEditable(false);//定义文本框的不可书写

t6.setEditable(false);//定义文本框的不可书写

p.add(l3,BorderLayout.NORTH);//把标签添加到面板上 p.add(t3,BorderLayout.CENTER);//把文本框添加到面板上 p.add(l1,BorderLayout.NORTH);//把标签添加到面板上 p.add(t1,BorderLayout.CENTER);//把文本框添加到面板上 p.add(l2,BorderLayout.NORTH);//把标签添加到面板上 p.add(t2,BorderLayout.CENTER);//把文本框添加到面板上 p.add(l4,BorderLayout.NORTH);//把标签添加到面板上 p.add(t4,BorderLayout.CENTER);//把文本框添加到面板上 p.add(l5,BorderLayout.NORTH);//把标签添加到面板上 p.add(t5,BorderLayout.CENTER);//把文本框添加到面板上 p.add(l6,BorderLayout.NORTH);//把标签添加到面板上 p.add(t6,BorderLayout.CENTER);//把文本框添加到面板上 b0=new JButton(”生成父母基因“);//创建父母基因生成按钮 pb.add(b0);//添加到面板上

b1=new JButton(”100次交叉、变异“);//创建交叉、变异按钮 pb.add(b1);//添加到面板上 b2=new JButton(”200次交叉、变异“);pb.add(b2);b3=new JButton(”500次交叉、变异");

JAVA实验报告

Object s=e.getSource();if(s==b0)//监听器实现功能 {

t3.setText(s1);//t3文本框输出s1

} t1.setText(s2);t4.setText(String.valueOf(H1));t5.setText(String.valueOf(H2));

if(s==b1)time(100);//监听器实现功能

} if(s==b2)time(200);if(s==b3)time(500);

public void time(int r)//定义方法，实现函数的调用

{

int x,y,z,d1=0,d2=0,w,k,H3=0;

c=new int[23];//定义一个数组

for(int j=1;j<=r;j++)//基因的交叉 {

x=1+(int)(Math.random()*23);//生成一个随机父亲基因位

y=1+(int)(Math.random()*23);//生成一个随机母亲基因位

z=f[x-1];f[x-1]=m[y-1];m[y-1]=z;//两个基因位的基因调换 }

for(int j=0;j<23;j++)//分别计算父母基因总和

{

d1+=f[j];

JAVA实验报告

2)程序的运行（包括运行的过程、界面和结果图）

首先编写如上所示的源程序，保存文件名称为“YichuanSuanfa.java”，然后编译源程序，编译完成后，生成一个字节码文件YichuanSuanfa.class，执行这个程序，得到如下图所示的窗口：

随机生成父母基因，得到如下图示：

JAVA实验报告

500次交叉、变异之后，得到如下图示：

4.实验心得

.java文件名要与主类名相同，JAVA对字

1.编写调试程序要注意程序编写的规则，母的大小写特别敏感，输入时要特捏注意大小写字母的定义，千万别犯主类名与.java文件名不同的错误。

2.在做图形界面时，注意设置图形界面的大小以及文本框、标签和按钮的位置。创建文本框的时候，可以设置文本框的可写性，以及文本框的颜色等等。在随机生成父母基因的时候，注意生成的随机数是什么范围，我们实验要求的范围是什么。监听器的响应，在文本框中输出的是一个基因整体还是一个数，都需要注意，因为这两种输出的方法不同。

3.为了简化程序，我们应该学会调用函数的方法。一开始做程序的时候，我没有注意到这一点，导致我的程序代码非常繁杂，而且容易出错。在同学的建议下，我把100次、200次、500次交叉、变异的实现使用调用函数的方法，这样我的程序代码变得简明多了。因此，在做程序的时候应该考虑到程序代码的简明扼要，不但美观，还能保证

JAVA实验报告

正确性的要求。