Qing/CPP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
landaiqing 2023-05-12 00:34:15 +08:00
parent 8b5d2311a4
commit c93b23a8cd
16 changed files with 2242 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
Test.cpp Normal file
View File

@ -0,0 +1,140 @@
//#include<stdio.h>
//
//void paixu(int n, int a[]) { //n为数组的元素个数
// for (int i = 0; i < n - 1; i++) {
// //TODO
// for (int j = i + 1; j < n; j++) {
// //TODO
// if (a[i] > a[j]) {
// int t = a[i];
// a[i] = a[j];
// a[j] = t;
// }
// }
//
// }
// for (int i = 0; i < n; i++) {
// //TODO
// printf("%d", a[i]);
// }
//}
//int main() {
// int a[5] = {8, 6, 5, 4, 1};
// paixu(5, a);
//}
//#include<stdio.h>
//int main() {
// int min, div, m, n, i = 2;
// printf("请输入两个数:\n");
// scanf("%d %d", &m, &n);
// if (m > n)
// min = n;
// else
// min = m;
// for (i; i <= min; i++) {
// if (m % i == 0 && n % i == 0) {
// div = i;
// }
// }
// printf("最大公约数为%d\n", div);
// return 0;
//}
//
//#include <stdio.h>
//
//int main() {
// int n1, n2, i, gcd;
//
// printf("输入两个正整数");
// scanf("%d %d", &n1, &n2);
//
// for (i = 1; i <= n1 && i <= n2; ++i) {
// // 判断 i 是否为最大公约数
// if (n1 % i == 0 && n2 % i == 0)
// gcd = i;
// }
//
// printf("%d 和 %d 的最大公约数是 %d", n1, n2, gcd);
//
// return 0;
//}
//#include <stdio.h>
//int main()
//{
// int a[11]={1,2,3,4,5,7,8,9,10,11};
// int i,t,m;
// printf("输入一个数:\n");
// scanf("%d",&m);
// for(i=0;i<11;i++)
// {
// if(m<a[i])
// {
// t=m;m=a[i];a[i]=t;
// }
// else if(m>a[9])
// a[10]=m;
// }
// printf("排序后:\n");
// for(i=0;i<11;i++)
// printf("%d ",a[i]);
// return 0;
//}
//#include<stdio.h>
//#include<math.h>
//
//int main() {
// double r, s ;
// printf("半径:");
// scanf("%lf", &r);
// s = (3 * 3.1415926 * r * r) / 4;
// printf("s=%lf", s);
//}
//#include <stdio.h>
//#include <math.h>
//main() {
// int n, i, k;
// for (n = 100; n > 0; n--) {
// k = sqrt(n);
// for (i = 2; i <= k; i++)
// if (n % i == 0)
// break;
// if (i > k) {
// printf("%d\n", n);
// break;
// }
// }
//}
#include <stdio.h>
int gcd(int m, int n) {
int div, i, min;
if (m < n) {
min = m;
} else {
min = n;
}
for (i = 2; i <= min; i++) {
if (m % i == 0 && n % i == 0) {
div = i;
}
}
return div;
}
int main() {
int m, n;
printf("请输入两个整数：\n");
scanf("%d %d", &m, &n);
int result = gcd(m, n);
printf("%d和%d的最大公约数是%d\n", m, n, result);
return 0;
}

430
计算机组成原理实验代码/Best_Bad_Fit.cpp Normal file
View File

@ -0,0 +1,430 @@
#include<stdio.h>
#include<stdlib.h>
#define N 5
#include<iostream>
using namespace std;
enum STATE
{
F,W
};
struct subAreaNode
{
int addr; // 起始地址
int size; // 分区大小
int taskId; // 作业号
STATE state; // 分区状态
subAreaNode *pre; // 分区前向指针
subAreaNode *nxt; // 分区后向指针
}subHead;
struct PCB
{
char name[8]; //进程名
int arrive_time; //到达时间
int run_time; //运行时间
int finish_time; //完成时间
int zhouzhuan_time; //周转时间
float daiquan_time; //带权周转时间
};
float sumzhouzhuantime,sumdaiquanzhouzhuantime;
struct PCB pcb[N],temp;
void input(); //输入进程
void sort(); //对输入的进程按到达时间进行排序执行
void output(); //输出算法调度时间表
// 初始化空闲分区链
void intSubArea()
{
// 分配初始分区内存
subAreaNode *fir = (subAreaNode *)malloc(sizeof(subAreaNode));
// 给首个分区赋值
fir->addr = 0;
fir->size = 1000; // 内存初始大小
fir->state = F;
fir->taskId = -1;
fir->pre = &subHead;
fir->nxt = NULL;
// 初始化分区头部信息
subHead.pre = NULL;
subHead.nxt = fir;
}
// 最佳适应算法
int BestFit(int taskId, int size)
{
subAreaNode *tar = NULL;
int tarSize = 1000 + 1;
subAreaNode *p = subHead.nxt;
while (p != NULL)
{
// 寻找最佳空闲区间
if (p->state == F && p->size >= size && p->size < tarSize) {
tar = p;
tarSize = p->size;
}
p = p->nxt;
}
if (tar != NULL) {
// 找到要分配的空闲分区
if (tar->size - size <= 10)
{
// 整块分配
tar->state = W;
tar->taskId = taskId;
}
else
{
// 分配大小为size的区间
subAreaNode *node = (subAreaNode *)malloc(sizeof(subAreaNode));
node->addr = tar->addr + size;
node->size = tar->size - size;
node->state = F;
node->taskId = -1;
// 修改分区链节点指针
node->pre = tar;
node->nxt = tar->nxt;
if (tar->nxt != NULL)
{
tar->nxt->pre = node;
}
tar->nxt = node;
// 分配空闲区间
tar->size = size;
tar->state = W;
tar->taskId = taskId;
}
printf("内存分配成功！\n");
return 1;
}
else
{
printf("找不到合适的内存分区，分配失败...\n");
return 0;
}
}
void BadFit(int taskId,int size){ //最坏适应
//最佳块指针
struct subAreaNode *q = NULL;
subAreaNode *node = subHead.nxt;
//首先找到第一个满足条件的空闲块
while(node != NULL){
if(node->state == F && node->size >= size){
q = node;
break;
}
//如果下一个为空则说明没有空闲区可以分配
if(node->nxt == NULL){
printf("分配失败，没有足够的空间！\n");
break;
} else{
node = node->nxt;
}
}
//遍历寻找最佳的空闲块
while(node != NULL){
if(node->state == F && node->size >= size && node->size < q->size){ //空闲的空间
q = node;
}
node = node->nxt;
}
if(q->size < size){ //最佳空闲块的大小小于需求大小
//分配后剩余的空间
struct subAreaNode *p = (struct subAreaNode*)malloc(sizeof(struct subAreaNode));
p->addr = q->addr + size;
p->size = q->size - size;
p->state = F;
p->taskId = -1;
//分配的空间
q->taskId = taskId;
q->size = size;
q->state = W;
//改变节点的连接
p->nxt = q->nxt;
q->nxt = p;
}else if(q->size == size){ //最佳空闲块空间大小和需求相等
q->taskId = taskId;
q->size = size;
q->state = W;
}
}
int freeSubArea(int taskId) // 回收内存
{
int flag = 0;
subAreaNode *p = subHead.nxt, *pp;
while (p != NULL)
{
if (p->state == W && p->taskId == taskId)
{
flag = 1;
if ((p->pre != &subHead && p->pre->state == F)
&& (p->nxt != NULL && p->nxt->state == F))
{
// 情况1：合并上下两个分区
// 先合并上区间
pp = p;
p = p->pre;
p->size += pp->size;
p->nxt = pp->nxt;
pp->nxt->pre = p;
free(pp);
// 后合并下区间
pp = p->nxt;
p->size += pp->size;
p->nxt = pp->nxt;
if (pp->nxt != NULL)
{
pp->nxt->pre = p;
}
free(pp);
}
else if ((p->pre == &subHead || p->pre->state == W)
&& (p->nxt != NULL && p->nxt->state == F))
{
// 情况2：只合并下面的分区
pp = p->nxt;
p->size += pp->size;
p->state = F;
p->taskId = -1;
p->nxt = pp->nxt;
if (pp->nxt != NULL)
{
pp->nxt->pre = p;
}
free(pp);
}
else if ((p->pre != &subHead && p->pre->state == F)
&& (p->nxt == NULL || p->nxt->state == W))
{
// 情况3：只合并上面的分区
pp = p;
p = p->pre;
p->size += pp->size;
p->nxt = pp->nxt;
if (pp->nxt != NULL)
{
pp->nxt->pre = p;
}
free(pp);
}
else
{
// 情况4：上下分区均不用合并
p->state = F;
p->taskId = -1;
}
}
p = p->nxt;
}
if (flag == 1)
{
// 回收成功
printf("内存分区回收成功...\n");
return 1;
}
else
{
// 找不到目标作业，回收失败
printf("找不到目标作业，内存分区回收失败...\n");
return 0;
}
}
// 显示空闲分区链情况
void showSubArea()
{
printf("\n");
printf(" 当前的内存分配情况如下： \n");
printf(" W:工作状态 F:空闲状态 \n");
printf("___________________________________________\n");
printf("| 起始地址 | 空间大小 | 工作状态 | 作业号 |\n");
subAreaNode *p = subHead.nxt;
while (p != NULL)
{
printf("___________________________________________\n");
printf(" %3d k |", p->addr);
printf(" %3d k |", p->size);
printf(" %s |", p->state == F ? "F" : "W");
if (p->taskId > 0)
{
printf(" %2d ", p->taskId);
}
else
{
printf(" ");
}
printf("\n");
p = p->nxt;
}
printf("___________________________________________\n");
}
void sort() //按照到达时间对进程进行排序
{
for(int i=0;i<N-1;i++)
{
for(int j=i+1;j<N;j++)
{
if(pcb[i].arrive_time>pcb[j].arrive_time)
{
temp=pcb[i];
pcb[i]=pcb[j];
pcb[j]=temp;
}
}
}
}
void output(int j)
{
int i;
cout<<"进程运行信息如下(FCFS调度算法):"<<endl;
pcb[0].finish_time=pcb[0].arrive_time+pcb[0].run_time;
pcb[0].zhouzhuan_time=pcb[0].finish_time-pcb[0].arrive_time;
pcb[0].daiquan_time=(float)pcb[0].zhouzhuan_time/pcb[0].run_time;
for(i=1;i<j;i++)
{
if(pcb[i].arrive_time>pcb[i-1].finish_time)
{
pcb[i].finish_time=pcb[i].arrive_time+pcb[i].run_time;
pcb[i].zhouzhuan_time=pcb[i].run_time;
pcb[i].daiquan_time=(float)pcb[i].zhouzhuan_time/pcb[i].run_time;
}
else
{
pcb[i].finish_time=pcb[i-1].finish_time+pcb[i].run_time;
pcb[i].zhouzhuan_time=pcb[i].finish_time-pcb[i].arrive_time;
pcb[i].daiquan_time=(float)pcb[i].zhouzhuan_time/pcb[i].run_time;
}
}
for(i=0;i<j;i++)
{
sumzhouzhuantime+=pcb[i].zhouzhuan_time;
sumdaiquanzhouzhuantime+=pcb[i].daiquan_time;
}
printf("****************************************************************\n");
printf("进程名 到达时间 运行时间 完成时间 周转时间 带权周转时间 \n");
printf("****************************************************************\n");
for(i=0;i<j;i++)
{
printf(" %s %d %d %d %d %.2f\n",pcb[i].name,pcb[i].arrive_time,pcb[i].run_time,pcb[i].finish_time,pcb[i].zhouzhuan_time,pcb[i].daiquan_time);
}
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
cout<<"平均周转时间:"<<sumzhouzhuantime/N<<endl;
cout<<"平均带权周转时间:"<<sumdaiquanzhouzhuantime/N<<endl;
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
}
void showProess(int j){
printf("进程输入信息如下:\n");
printf("进程名 到达时间 服务时间\n");
for(int i=0;i<j;i++)
{
printf("%s \t",pcb[i].name);
printf("%d \t",pcb[i].arrive_time);
printf("%d \n",pcb[i].run_time);
}
}
int main()
{
int ope, taskId, size,select,count;
//oep 功能选择 taskId 进程号 size 进程大小 select 分配算法选择 count 计数
// 初始化空闲分区链
intSubArea();
printf(">>>>>>>>>>>>>>>>>>动态分区算法模拟之最佳/最坏适应算法<<<<<<<<<<<<<<<<<<\n") ;
printf(" ____________________________________\n");
printf(" | 1: 最佳适应算法 2: 最坏适应算法 |\n");
printf(" |___________________________________|\n");
printf("请选择分配算法:");
scanf("%d",&select);
// 模拟动态分区分配算法
for(int i=0;i<N;i++){
printf(" ________________________________________________________________\n");
printf(" | 1: 分配内存 2: 回收内存 3.分区情况 4.进程信息 0: 退出 |\n");
printf(" |_______________________________________________________________|\n");
printf("请选择执行的功能:");
scanf("%d", &ope);
if (ope == 0) break;
if (ope == 1) {
// 模拟分配内存
printf("请输入作业号： ");
scanf("%d", &taskId);
printf("请输入进程名:" );
scanf("%s",pcb[i].name);
printf("请输入到达时间:");
scanf("%d",&pcb[i].arrive_time);
printf("请输入要运行时间:");
scanf("%d",&pcb[i].run_time);
printf("请输入需要分配的内存大小(KB)： ");
scanf("%d", &size);
count+=1;
// showProess(count);
if (size <= 0)
{
printf("ERROR:分配内存大小必须为正值\n");
continue;
}
switch(select){ //分配算法选择
case 1:
BestFit(taskId,size);
break ;
case 2:
BadFit(taskId,size);
break ;
}
}
else if (ope == 2)
{
// 模拟回收内存
printf("请输入要回收的作业号： ");
scanf("%d", &taskId);
freeSubArea(taskId);
showSubArea();
}
else if(ope==3){
showSubArea(); // 显示空闲分区链情况
}
else if(ope==4){
showProess(count);
output(count);
}
else
{
printf("错误：请输入 0/1/2\n");
}
}
printf("分配算法模拟结束\n");
system("pause");
return 0;
}

15
计算机组成原理实验代码/F.cpp Normal file
View File

@ -0,0 +1,15 @@
//#include <stdio.h>
//#include <iostream>
//#include<iomanip>
//using namespace std;
//int main()
//{
//
// double F,C;
// cin>>F;
// C=(F-32)*5/9;
// cout <<setiosflags(ios::fixed)<<setprecision(2) << C;
// return 0;
//}

91
计算机组成原理实验代码/FCFS.cpp Normal file
View File

@ -0,0 +1,91 @@
#include <stdio.h>
#define n 5
struct JCB
{
int name; //进程名
int atime; //进程到达时间
int runtime; //进程运行时间
int ftime; //进程完成时间
int total; //周转时间
float welght; //带权周转时间（周转系数）
int arun; //进程到达运行
}f[n];
//开始执行时间，各作业的完成时间，周转时间和带权周转时间（周转系数）。
int main()
{
int amount;
int i,j,l,k,h;
struct JCB f[n];
printf("请输入进程个数(2-24):\n");
scanf("%d",&amount);
for(i=0;i<amount;i++)
{
printf("请输入进程名，进程到达时间（0-30），进程运行时间（1-8）:\n");
scanf("%d",&f[i].name);
scanf("%d",&f[i].atime);
scanf("%d",&f[i].runtime);
}
printf("进程名\t进程到达时间\t进程运行时间\n");
for(i=0;i<amount;i++)
{
printf("%d\t%d\t\t%d\t\n",f[i].name,f[i].atime,f[i].runtime);
}
printf("------先来先服务（FCFS）调度算法------\n");
for(i=0;i<amount-1;i++) //按进程到达时间的先后排序
{ //如果两个进程同时到达，按在屏幕先输入的先运行
for(j=i+1;j<amount;j++)
{
if(f[j].atime < f[i].atime)
{
l =f[j].atime;
h =f[j].runtime;
k =f[j].name;
f[j].atime =f[i].atime;
f[j].runtime =f[i].runtime;
f[j].name =f[i].name;
f[i].atime =l;
f[i].runtime =h;
f[i].name =k;
}
}
}
printf("按进程到达时间的先后排序\n\n");
printf("进程名\t进程到达时间\t进程运行时间\n");
for(i=0;i<amount;i++)
{
printf("%d\t%d\t\t%d\t\n",f[i].name,f[i].atime,f[i].runtime);
}
printf("进程名 进程到达 开始运行 进程运行 进程结束 周转时间 周转系数\n");
f[0].arun=0;
for(i=0;i<amount;i++)
{
if(f[i].arun<f[i].atime)
{
f[i].arun =f[i].atime;
}
f[i].ftime=f[i].arun+f[i].runtime;
f[i].total=f[i].ftime-f[i].atime;
f[i].welght=(float)f[i].total/(float)f[i].runtime;
printf("%d\t%d\t %d\t %d\t %d\t\t%d\t%f\n",f[i].name,f[i].atime,f[i].arun,f[i].runtime,f[i].ftime,f[i].total,f[i].welght);
f[i+1].arun=f[i].arun+f[i].ftime;
}
printf("进程名 进程到达 开始运行 进程运行 进程结束 周转时间 周转系数\n");
for(i=0;i<amount;i++)
{
printf("%d\t%d\t %d\t %d\t %d\t\t%d\t%f\n",f[i].name,f[i].atime,f[i].arun,f[i].runtime,f[i].ftime,f[i].total,f[i].welght);
}
}

111
计算机组成原理实验代码/FCFS_2.cpp Normal file
View File

@ -0,0 +1,111 @@
#include<iostream>
using namespace std;
#define N 3
struct PCB
{
char name[8];
int arrive_time;
int run_time;
int finish_time;
int zhouzhuan_time;
float daiquan_time;
};
float sumzhouzhuantime,sumdaiquanzhouzhuantime;
struct PCB pcb[N],temp;
void input(); //输入进程
void sort(); //对输入的进程按到达时间进行排序执行
void output(); //输出算法调度时间表
int main()
{
input();
sort( );
output();
}
void input()
{
int i;
cout<<"--------------------------------------"<<endl;
cout<<" FCFS调度算法 "<<endl;
cout<<"--------------------------------------"<<endl;
cout<<" 输入五个进程信息:"<<endl;
for ( i=0;i<N;i++)
{
printf("请输入进程名:\n" );
scanf("%s",pcb[i].name);
printf("请输入到达时间:");
scanf("%d",&pcb[i].arrive_time);
printf("请输入要运行时间:");
scanf("%d",&pcb[i].run_time);
}
cout<<"各进程:"<<endl;
for( i=0;i<N;i++)
{ printf("%s ",pcb[i].name);
printf("%d ",pcb[i].arrive_time);
printf("%d \n",pcb[i].run_time);
}
}
void sort()//按照到达时间对进程进行排序
{
for(int i=0;i<N-1;i++)
{
for(int j=i+1;j<N;j++)
{
if(pcb[i].arrive_time>pcb[j].arrive_time)
{
temp=pcb[i];
pcb[i]=pcb[j];
pcb[j]=temp;
}
}
}
}
void output()
{
int i;
cout<<"FCFS调度算法:"<<endl;
pcb[0].finish_time=pcb[0].arrive_time+pcb[0].run_time;
pcb[0].zhouzhuan_time=pcb[0].finish_time-pcb[0].arrive_time;
pcb[0].daiquan_time=(float)pcb[0].zhouzhuan_time/pcb[0].run_time;
for(i=1;i<N;i++)
{
if(pcb[i].arrive_time>pcb[i-1].finish_time)
{
pcb[i].finish_time=pcb[i].arrive_time+pcb[i].run_time;
pcb[i].zhouzhuan_time=pcb[i].run_time;
pcb[i].daiquan_time=(float)pcb[i].zhouzhuan_time/pcb[i].run_time;
}
else
{
pcb[i].finish_time=pcb[i-1].finish_time+pcb[i].run_time;
pcb[i].zhouzhuan_time=pcb[i].finish_time-pcb[i].arrive_time;
pcb[i].daiquan_time=(float)pcb[i].zhouzhuan_time/pcb[i].run_time;
}
}
for(i=0;i<N;i++)
{
sumzhouzhuantime+=pcb[i].zhouzhuan_time;
sumdaiquanzhouzhuantime+=pcb[i].daiquan_time;
}
printf("----------------------------------------------------------------\n");
printf("进程名 到达时间 运行时间 完成时间 周转时间 带权周转时间 \n");
printf("----------------------------------------------------------------\n");
for(i=0;i<N;i++)
{
printf(" %s %d %d %d %d %.2f\n",pcb[i].name,pcb[i].arrive_time,pcb[i].run_time,pcb[i].finish_time,pcb[i].zhouzhuan_time,pcb[i].daiquan_time);
}
cout<<"平均周转时间:"<<sumzhouzhuantime/N<<endl;
cout<<"平均带权周转时间:"<<sumdaiquanzhouzhuantime/N<<endl;
printf("----------------------------------------------------------------\n");
}

331
计算机组成原理实验代码/FenPei.cpp Normal file
View File

@ -0,0 +1,331 @@
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
enum STATE
{
Free,
Busy
};
struct subAreaNode
{
int addr; // 起始地址
int size; // 分区大小
int taskId; // 作业号
STATE state; // 分区状态
subAreaNode *pre; // 分区前向指针
subAreaNode *nxt; // 分区后向指针
}subHead;
// 初始化空闲分区链
void intSubArea()
{
// 分配初始分区内存
subAreaNode *fir = (subAreaNode *)malloc(sizeof(subAreaNode));
// 给首个分区赋值
fir->addr = 0;
fir->size = 1000; // 内存初始大小
fir->state = Free;
fir->taskId = -1;
fir->pre = &subHead;
fir->nxt = NULL;
// 初始化分区头部信息
subHead.pre = NULL;
subHead.nxt = fir;
}
// 首次适应算法
int firstFit(int taskId, int size)
{
subAreaNode *p = subHead.nxt;
while (p != NULL)
{
if (p->state == Free && p->size >= size)
{
// 找到要分配的空闲分区
if (p->size - size <= 10)
{
// 整块分配
p->state = Busy;
p->taskId = taskId;
}
else {
// 分配大小为size的区间
subAreaNode *node = (subAreaNode *)malloc(sizeof(subAreaNode));
node->addr = p->addr + size;
node->size = p->size - size;
node->state = Free;
node->taskId = -1;
// 修改分区链节点指针
node->pre = p;
node->nxt = p->nxt;
if (p->nxt != NULL)
{
p->nxt->pre = node;
}
p->nxt = node;
// 分配空闲区间
p->size = size;
p->state = Busy;
p->taskId = taskId;
}
printf("内存分配成功！\n");
return 1;
}
p = p->nxt;
}
printf("找不到合适的内存分区，分配失败...\n");
return 0;
}
// 最佳适应算法
int bestFit(int taskId, int size)
{
subAreaNode *tar = NULL;
int tarSize = 1000 + 1;
subAreaNode *p = subHead.nxt;
while (p != NULL)
{
// 寻找最佳空闲区间
if (p->state == Free && p->size >= size && p->size < tarSize) {
tar = p;
tarSize = p->size;
}
p = p->nxt;
}
if (tar != NULL) {
// 找到要分配的空闲分区
if (tar->size - size <= 10)
{
// 整块分配
tar->state = Busy;
tar->taskId = taskId;
}
else
{
// 分配大小为size的区间
subAreaNode *node = (subAreaNode *)malloc(sizeof(subAreaNode));
node->addr = tar->addr + size;
node->size = tar->size - size;
node->state = Free;
node->taskId = -1;
// 修改分区链节点指针
node->pre = tar;
node->nxt = tar->nxt;
if (tar->nxt != NULL)
{
tar->nxt->pre = node;
}
tar->nxt = node;
// 分配空闲区间
tar->size = size;
tar->state = Busy;
tar->taskId = taskId;
}
printf("内存分配成功！\n");
return 1;
}
else
{
printf("找不到合适的内存分区，分配失败...\n");
return 0;
}
}
int freeSubArea(int taskId) // 回收内存
{
int flag = 0;
subAreaNode *p = subHead.nxt, *pp;
while (p != NULL)
{
if (p->state == Busy && p->taskId == taskId)
{
flag = 1;
if ((p->pre != &subHead && p->pre->state == Free)
&& (p->nxt != NULL && p->nxt->state == Free))
{
// 情况1：合并上下两个分区
// 先合并上区间
pp = p;
p = p->pre;
p->size += pp->size;
p->nxt = pp->nxt;
pp->nxt->pre = p;
free(pp);
// 后合并下区间
pp = p->nxt;
p->size += pp->size;
p->nxt = pp->nxt;
if (pp->nxt != NULL)
{
pp->nxt->pre = p;
}
free(pp);
}
else if ((p->pre == &subHead || p->pre->state == Busy)
&& (p->nxt != NULL && p->nxt->state == Free))
{
// 情况2：只合并下面的分区
pp = p->nxt;
p->size += pp->size;
p->state = Free;
p->taskId = -1;
p->nxt = pp->nxt;
if (pp->nxt != NULL)
{
pp->nxt->pre = p;
}
free(pp);
}
else if ((p->pre != &subHead && p->pre->state == Free)
&& (p->nxt == NULL || p->nxt->state == Busy))
{
// 情况3：只合并上面的分区
pp = p;
p = p->pre;
p->size += pp->size;
p->nxt = pp->nxt;
if (pp->nxt != NULL)
{
pp->nxt->pre = p;
}
free(pp);
}
else
{
// 情况4：上下分区均不用合并
p->state = Free;
p->taskId = -1;
}
}
p = p->nxt;
}
if (flag == 1)
{
// 回收成功
printf("内存分区回收成功...\n");
return 1;
}
else
{
// 找不到目标作业，回收失败
printf("找不到目标作业，内存分区回收失败...\n");
return 0;
}
}
// 显示空闲分区链情况
void showSubArea()
{
printf("*********************************************\n");
printf("** 当前的内存分配情况如下： **\n");
printf("*********************************************\n");
printf("** 起始地址 | 空间大小 | 工作状态 | 作业号 **\n");
subAreaNode *p = subHead.nxt;
while (p != NULL)
{
printf("**-----------------------------------------**\n");
printf("**");
printf(" %3d k |", p->addr);
printf(" %3d k |", p->size);
printf(" %s |", p->state == Free ? "Free" : "Busy");
if (p->taskId > 0)
{
printf(" %2d ", p->taskId);
}
else
{
printf(" ");
}
printf("**\n");
p = p->nxt;
}
printf("*********************************************\n");
}
int main()
{
int option, ope, taskId, size;
// 初始化空闲分区链
intSubArea();
// 选择分配算法
while (1)
{
printf("\n\n");
printf("\t****************请选择要模拟的分配算法******************\n");
printf("\n\n");
printf("\t \t 0 首次适应算法 \n");
printf("\n\n");
printf("\t \t 1 最佳适应算法 \n");
printf("\n\n");
printf("\t\t\t\t你的选择是:");
scanf("%d", &option);
if (option == 0)
{
printf("你选择了首次适应算法，下面进行算法的模拟\n");
break;
}
else if (option == 1)
{
printf("你选择了最佳适应算法，下面进行算法的模拟\n");
break;
}
else
{
printf("错误：请输入 0/1\n\n");
}
}
// 模拟动态分区分配算法
while (1)
{
printf("\n");
printf("*********************************************\n");
printf("** 1: 分配内存 2: 回收内存 0: 退出 **\n");
printf("*********************************************\n");
scanf("%d", &ope);
if (ope == 0) break;
if (ope == 1) {
// 模拟分配内存
printf("请输入作业号： ");
scanf("%d", &taskId);
printf("请输入需要分配的内存大小(KB)： ");
scanf("%d", &size);
if (size <= 0)
{
printf("错误：分配内存大小必须为正值\n");
continue;
}
// 调用分配算法
if (option == 0)
{
firstFit(taskId, size);
}
else
{
bestFit(taskId, size);
}
// 显示空闲分区链情况
showSubArea();
}
else if (ope == 2)
{
// 模拟回收内存
printf("请输入要回收的作业号： ");
scanf("%d", &taskId);
freeSubArea(taskId);
// 显示空闲分区链情况
showSubArea();
}
else
{
printf("错误：请输入 0/1/2\n");
}
}
printf("分配算法模拟结束\n");
system("pause");
return 0;
}

69
计算机组成原理实验代码/Fibonacci.cpp Normal file
View File

@ -0,0 +1,69 @@
/*------------------------------------------------
【程序设计】
--------------------------------------------------
/* 编写函数fun，它的功能是：求Fibonacci数列中大于s的最小的一个数，结果由函数返回。其中Fibonacci数列F(n)的定义为：
F(0)=0，F(1)=1
F(n)=F(n-1)+F(n-2)
例如：当s=1000时，函数值为：1597。
注意：部分源程序存在文件prog.c中。
请勿改动主函数main和其他函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
*********Begin**********和********** End **********不可删除
*/
#include <conio.h>
#include <math.h>
#include <stdio.h>
#include<windows.h>
int fun(int s)
{
/********** Begin **********/
int f1,f2,f;
f1=0;
f2=1;
do
{
f=f1+f2;
f1=f2;
f2=f;
}
while(f2<=s);
return f2;
/********** End ***********/
}
void NONO ( )
{/* 本函数用于打开文件，输入数据，调用函数，输出数据，关闭文件。 */
FILE *fp, *wf ;
int i, n, s ;
fp = fopen("bc06.in","r") ;
if(fp == NULL) {
printf("数据文件bc06.in不存在!") ;
}
wf = fopen("bc06.out","w") ;
for(i = 0 ; i < 10 ; i++) {
fscanf(fp, "%d", &n) ;
s = fun(n) ;
fprintf(wf, "%d\n", s) ;
}
fclose(fp) ;
fclose(wf) ;
}
main() /*主函数*/
{ int n;
system("cls");
n=1000;
printf("n=%d,f=%d\n",n,fun(n));
NONO();
}

131
计算机组成原理实验代码/First_Fit_1.cpp Normal file
View File

@ -0,0 +1,131 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <vector>
#include <iostream>
using namespace std;
struct FF {
char name[10];
float address;//起始地址
float AFFival_time;//没用
float Service_hours;//没用
float Process_size;//进程大小
float size;//在内存中一块一块的值
float max_size;//内存最大值
float state;//0为空闲 1为不空闲，别问我为什么不用bool ，因为抄袭只能拿60
};
void print_Memory(FF *p,int N);//内存空间打印函数
void recovery(FF *p,int N);//回收函数，紧凑功能
void input(FF *p, int N);//输入函数
void run(FF *p,int N);//交互式界面
void detelex(FF *p,int N);//结束进程函数
void input(FF *p, int N) {
int i;
int x=0;
printf("输入系统内存大小");
scanf("%f",&p[0].max_size);
printf("\n");
for(i = 0; i <= N - 1; i++) {
printf("输入第%d个进程的名字,到达时间,服务时间,进程大小(例如：1 2 1 5)：\n", i+1);
scanf("%s %f %f %f", p[i].name, &p[i].AFFival_time, &p[i].Service_hours,&p[i].Process_size);
}
}
void print(FF *p,int N){
for(int i=0;i<=N;i++){
printf(p[i].name, &p[i].AFFival_time, &p[i].Service_hours,&p[i].Process_size);
}
}
void distribution(FF *p,int N) {
int i;
p[0].size=p[0].max_size;
for (i=0; i<N; i++) {
p[i+1].size=p[i].Process_size;
if(p[0].size>=p[i].Process_size) {
p[0].size=p[0].size-p[i].Process_size;
p[i+1].state=1;
} else {
printf("第%d个进程进去后导致",i+1);
printf("马冲我谢谢你，内存不足\n");
p[i+1].size=p[0].size;
p[i+1].state=0;
print_Memory(p, N);
}
}
}
void recovery(FF *p,int N) {//想拿一百分还不赶快完成这个
int i;
for(i=1; i<N; i++) {
if(p[i].state==0&&p[i+1].state==0) {
p[i].size=p[i].size+p[i+1].size;
p[i+1].size=0;
}
}
printf("\n回收完毕\n");
}
void print_Memory(FF *p,int N) {
int i;
float q;
p[0].address=0;
printf("\n内存的使用状态\n");
for (i=1; i<=N; i++) {
printf("起始地址:\t");
q+=p[i].size;
p[i].address=q;
printf("%f\t",p[i-1].address);
printf("分区大小:\t");
printf("%f\t",p[i].size);
if(p[i].state==1) {
printf("\t正在工作\n");
} else {
printf("\t空闲\n");
}
}
printf("剩余内存");
printf("%f",p[0].size);
}
void run(FF *p,int N) {
int xx=0;
while(xx!=4) {
printf("\n释放内存请按1，回收内存请按2，查看内存请按3，退出请按4\n");
cin>>xx;
if(xx==1) {
detelex(p, N);
print(p,N);
} else if(xx==2) {
recovery(p, N);
} else if(xx==3) {
print_Memory(p, N);
}
}
}
void detelex(FF *p,int N) {
float yy;
printf("\n输入删除进程的起始地址\n");
scanf("%f",&yy);
for(int i =0;i<N;i++){
if(yy==p[i].address){
cout<<"已删除"<<"\n";
p[i+1].state=0;
}
};
}
void FF_MAIN() {
int N;
printf("请输入进程的数量:\n");
scanf("%d",&N);
FF *p = new FF[N];
input(p, N);
distribution(p,N);
run (p,N);
delete [] p;
}
int main() {
FF_MAIN();
return 0;
}

278
计算机组成原理实验代码/First_Fit_2.cpp Normal file
View File

@ -0,0 +1,278 @@
#include<stdio.h>
#include<stdlib.h>
enum STATE {
F, W
};
struct subAreaNode {
int addr; // 起始地址
int size; // 分区大小
int taskId; // 作业号
STATE state; // 分区状态
subAreaNode *pre; // 分区前向指针
subAreaNode *nxt; // 分区后向指针
} subHead;
// 初始化空闲分区链
void intSubArea() {
// 分配初始分区内存
subAreaNode *fir = (subAreaNode *)malloc(sizeof(subAreaNode));
// 给首个分区赋值
fir->addr = 0;
fir->size = 95; // 内存初始大小
fir->state = F;
fir->taskId = -1;
fir->pre = &subHead;
fir->nxt = NULL;
// 初始化分区头部信息
subHead.pre = NULL;
subHead.nxt = fir;
}
//// 首次适应算法
//int firstFit(int taskId, int size)
//{
//subAreaNode *p = subHead.nxt;
//while (p != NULL)
//{
//if (p->state == F && p->size >= size)
//{
//// 找到要分配的空闲分区
//if (p->size - size <= 10)
//{
//// 整块分配
//p->state = W;
//p->taskId = taskId;
//}
//else {
//// 分配大小为size的区间
//subAreaNode *node = (subAreaNode *)malloc(sizeof(subAreaNode));
//node->addr = p->addr + size;
//node->size = p->size - size;
//node->state = F;
//node->taskId = -1;
//// 修改分区链节点指针
//node->pre = p;
//node->nxt = p->nxt;
//if (p->nxt != NULL)
//{
//p->nxt->pre = node;
//}
//p->nxt = node;
//// 分配空闲区间
//p->size = size;
//p->state = W;
//p->taskId = taskId;
//}
//printf("内存分配成功！\n");
//return 1;
//}
//p = p->nxt;
//}
//printf("找不到合适的内存分区，分配失败...\n");
//return 0;
//}
//struct subAreaNode *node
void BestFit(int taskId, int size) { //最坏适应
//最佳块指针
struct subAreaNode *q = NULL;
subAreaNode *node = subHead.nxt;
//首先找到第一个满足条件的空闲块
while (node != NULL) {
if (node->state == F && node->size >= size) {
q = node;
break;
}
//如果下一个为空则说明没有空闲区可以分配
if (node->nxt == NULL) {
printf("分配失败，没有足够的空间！\n");
break;
} else {
node = node->nxt;
}
}
//遍历寻找最佳的空闲块
while (node != NULL) {
if (node->state == F && node->size >= size && node->size < q->size) { //空闲的空间
q = node;
}
node = node->nxt;
}
if (q->size > size) { //最佳空闲块的大小大于需求大小
//分配后剩余的空间
struct subAreaNode *p = (struct subAreaNode*)malloc(sizeof(struct subAreaNode));
p->addr = q->addr + size;
p->size = q->size - size;
p->state = F;
p->taskId = -1;
//分配的空间
q->taskId = taskId;
q->size = size;
q->state = W;
//改变节点的连接
p->nxt = q->nxt;
q->nxt = p;
} else if (q->size == size) { //最佳空闲块空间大小和需求相等
q->taskId = taskId;
q->size = size;
q->state = W;
}
}
int freeSubArea(int taskId) { // 回收内存
int flag = 0;
subAreaNode *p = subHead.nxt, *pp;
while (p != NULL) {
if (p->state == W && p->taskId == taskId) {
flag = 1;
if ((p->pre != &subHead && p->pre->state == F)
&& (p->nxt != NULL && p->nxt->state == F)) {
// 情况1：合并上下两个分区
// 先合并上区间
pp = p;
p = p->pre;
p->size += pp->size;
p->nxt = pp->nxt;
pp->nxt->pre = p;
free(pp);
// 后合并下区间
pp = p->nxt;
p->size += pp->size;
p->nxt = pp->nxt;
if (pp->nxt != NULL) {
pp->nxt->pre = p;
}
free(pp);
} else if ((p->pre == &subHead || p->pre->state == W)
&& (p->nxt != NULL && p->nxt->state == F)) {
// 情况2：只合并下面的分区
pp = p->nxt;
p->size += pp->size;
p->state = F;
p->taskId = -1;
p->nxt = pp->nxt;
if (pp->nxt != NULL) {
pp->nxt->pre = p;
}
free(pp);
} else if ((p->pre != &subHead && p->pre->state == F)
&& (p->nxt == NULL || p->nxt->state == W)) {
// 情况3：只合并上面的分区
pp = p;
p = p->pre;
p->size += pp->size;
p->nxt = pp->nxt;
if (pp->nxt != NULL) {
pp->nxt->pre = p;
}
free(pp);
} else {
// 情况4：上下分区均不用合并
p->state = F;
p->taskId = -1;
}
}
p = p->nxt;
}
if (flag == 1) {
// 回收成功
printf("内存分区回收成功...\n");
return 1;
} else {
// 找不到目标作业，回收失败
printf("找不到目标作业，内存分区回收失败...\n");
return 0;
}
}
// 显示空闲分区链情况
void showSubArea() {
printf("\n");
printf(" 当前的内存分配情况如下： \n");
printf(" W:工作状态 F:空闲状态 \n");
printf("___________________________________________\n");
printf("| 起始地址 | 空间大小 | 工作状态 | 作业号 |\n");
subAreaNode *p = subHead.nxt;
while (p != NULL) {
printf("___________________________________________\n");
printf(" %3d k |", p->addr);
printf(" %3d k |", p->size);
printf(" %s |", p->state == F ? "F" : "W");
if (p->taskId > 0) {
printf(" %2d ", p->taskId);
} else {
printf(" ");
}
printf("\n");
p = p->nxt;
}
printf("___________________________________________\n");
}
int main() {
int ope, taskId, size;
char name;
int ArriveTime;
int ServerTime;
// 初始化空闲分区链
intSubArea();
// 模拟动态分区分配算法
while (1) {
printf("默认FF(首次适应算法)\n");
printf("_________________________________________\n");
printf("| 1: 分配内存 2: 回收内存 0: 退出 |\n");
printf("|________________________________________|\n");
scanf("%d", &ope);
if (ope == 0) break;
if (ope == 1) {
// 模拟分配内存
printf("请输入作业号： ");
scanf("%d", &taskId);
printf("请输入作业名： ");
scanf("%s", &name);
printf("请输入到达时间： ");
scanf("%d", &ArriveTime);
printf("请输入服务时间： ");
scanf("%d", &ServerTime);
printf("请输入需要分配的内存大小(KB)： ");
scanf("%d", &size);
if (size <= 0) {
printf("错误：分配内存大小必须为正值\n");
continue;
}
// 调用分配算法
//firstFit(taskId, size);
BestFit(taskId, size);
// 显示空闲分区链情况
showSubArea();
} else if (ope == 2) {
// 模拟回收内存
printf("请输入要回收的作业号： ");
scanf("%d", &taskId);
freeSubArea(taskId);
// 显示空闲分区链情况
showSubArea();
} else {
printf("错误：请输入 0/1/2\n");
}
}
printf("分配算法模拟结束\n");
system("pause");
return 0;
}

108
计算机组成原理实验代码/OPT.cpp Normal file
View File

@ -0,0 +1,108 @@
#include <stdio.h>
#include <iostream>
using namespace std;
int number=0;
int Pyblock=0;
int opt(int a[])
{
int i, j, zero = 0, one = 0, two = 0, q = 0;
int b[Pyblock];
for (i = 0; i < Pyblock; i++)
{
b[i] =-1; //空为-1
}
for (i = 0; i < number; i++)
{
if (i < 3)
{
q++;
for (j = 0; j < Pyblock; j++)
{
if (b[j] == -1)
{
b[j] = a[i];
break;
}
}
}
else
{
if (b[0] != a[i])
{
if (b[1] != a[i])
{
if(b[2] != a[i]){
q++;
for (int t = i + 1; t < number; t++)
{
if (b[0] == a[t])
zero = 1;
else if (b[1] == a[t])
one = 1;
else if (b[2] == a[t])
two = 1;
if (zero == 1 && one == 1 && two == 0)
{
b[2] = a[i];
break;
}
else if (zero == 1 && one == 0 && two == 1)
{
b[1] = a[i];
break;
}
else if (zero == 0 && one == 1 && two == 1)
{
b[0] = a[i];
break;
}
}
}
}
}
}
for (int f = 0; f < Pyblock; f++)
{
printf("%d\t", b[f]);
}
printf("\n");
zero = 0;
one = 0;
two = 0;
}
return q;
}
int main()
{
int o;
while(1)
{
printf("请输入分配的物理块的个数:\n");
scanf("%d",&Pyblock);
printf("\n");
break;
}
while(1)
{
printf("请输入页面序列个数:\n");
scanf("%d",&number);
printf("\n");
break;
}
int a[number];
printf("请依次输入页面序列:\n");
for (int i = 0; i < number; i++)
{
cin>>a[i];
}
printf("opt页面置换算法：\n");
o = opt(a);
printf("缺页%d次，置换%d次, 缺页率:%.2f%% .\n\n\n", o, o - Pyblock,((double)o/number)*100);
return 0;
}
//4 3 2 1 4 3 5 4 3 2 1 5

124
计算机组成原理实验代码/OPT2.cpp Normal file
View File

@ -0,0 +1,124 @@
#include<stdio.h>
int block_num; //分配的物理块数
int page_num; //要访问的页面序列个数
int page[100]; //要访问的页面序列
int memory[10]; //物理块中的页号
int table[100][10]; //显示矩阵
int reg[10]; //寄存器--记录页面的访问时间
char Que[100]; //数组，记录是否缺页
int main()
{
int count=0; //记录缺页次数
int i,j,k;
while(1)
{
printf("请输入分配的物理块的个数(M<=10):\n");
scanf("%d",&block_num);
printf("\n");
break;
}
while(1)
{
printf("请输入要访问的页面序列个数(P<=100):\n");
scanf("%d",&page_num);
printf("\n");
break;
}
printf("请依次输入页面序列:\n");
for(i=0;i<page_num;i++)
{
scanf("%d",&page[i]);
Que[i] = 'N';
}
for(i=0;i<block_num;i++)
memory[i]=-1; //初始内存块中默认为空，用-1表示
//访问页面
for(i=0;i<page_num;i++)
{
if(i==0) //访问的第一个页面
{
memory[i]=page[i];
reg[i]=i;
for(j=0;j<block_num;j++)
table[i][j]=memory[j];
Que[i]='Y';
count++;
}
else
{ /*判断新页面号是否在物理块中*/
for(j=0,k=0;j<block_num;j++)
{
if(memory[j]!=page[i])
k++;
else
{ /*新页面在内存块中*/
reg[j]=i; //刷新该页面的访问时间
for(int n=0;n<block_num;n++)
table[i][n]=memory[n];
}
}
}
if(k==block_num) /*新页面不在物理块中，缺页*/
{
int q=0;
Que[i]='Y';
count++;
for(int j=0;j<block_num;j++)
{
if(memory[j]==-1) /*内存块未满*/
{
memory[j]=page[i];
reg[j]=i;
for(int n=0;n<block_num;n++)
table[i][n]=memory[n];
break;
}
else
q++;
}
if(q==block_num)/*内存块已满，需采用LRU置换算法选择换出页*/
{
int min=0; //记录换出页
for(int m=1;m<block_num;m++)
if(reg[m]<reg[min])
min=m;
memory[min]=page[i];
reg[min]=i; /*记录该页的访问时间（新到的页面进入之前min的位置，需将min位置的访问时间更改）*/
for(int n=0;n<block_num;n++)
table[i][n]=memory[n];
}
}
}
//输出运行过程及结果
printf("采用OPT页面置换算法结果如下: \n");
printf("\n");
printf("\n");
printf("页号:");
for(i=0;i<page_num;i++)
printf("%3d",page[i]);
printf("\n");
printf("-------------------------\n");
for(i=0;i<block_num;i++)
{
printf("%2d:",i);
for(j=0;j<page_num;j++)
printf("%3d",table[j][i]);
printf("\n");
}
printf("-------------------------\n");
printf("缺页:");
for(i=0;i<page_num;i++)
printf("%3c",Que[i]);
printf("\n");
printf("-------------------------\n");
printf("\t缺页次数:%d\n",count);
printf("\t缺页率:%d/%d\n",count,page_num);
printf("-------------------------\n");
}

88
计算机组成原理实验代码/OPT3.cpp Normal file
View File

@ -0,0 +1,88 @@
#include <stdio.h>
#define number 11
#define block 3
#include <iostream>
using namespace std;
int opt(int a[])
{
int i, j, zero = 0, one = 0, two = 0, q = 0;
int b[block];
for (i = 0; i < block; i++)
{
b[i] =-1; //空为-1
}
for (i = 0; i < number; i++)
{
if (i < 3)
{
// printf("缺页：%d\n", a[i]);
q++;
for (j = 0; j < block; j++)
{
if (b[j] == -1)
{
b[j] = a[i];
break;
}
}
}
else
{
if (b[0] != a[i] && b[1] != a[i] && b[2] != a[i])
{
// printf("缺页：%d\n", a[i]);
q++;
for (int t = i + 1; t < number; t++)
{
if (b[0] == a[t])
zero = 1;
else if (b[1] == a[t])
one = 1;
else if (b[2] == a[t])
two = 1;
if (zero == 1 && one == 1 && two == 0)
{
b[2] = a[i];
break;
}
else if (zero == 1 && one == 0 && two == 1)
{
b[1] = a[i];
break;
}
else if (zero == 0 && one == 1 && two == 1)
{
b[0] = a[i];
break;
}
}
}
// else
// printf("%d不缺页。\n", a[i]);
}
for (int f = 0; f < block; f++)
{
printf("%d\t", b[f]);
}
printf("\n");
zero = 0;
one = 0;
two = 0;
}
return q;
}
int main()
{
int i, o, l=0,f=0;
int a[number];
printf("请输入:\n");
for (i = 0; i < number; i++)
{
cin>>a[i];
}
printf("opt页面置换算法：\n");
o = opt(a);
printf("缺页%d次，置换%d次。\n\n\n", o, o - block);
return 0;
}

169
计算机组成原理实验代码/RR.cpp Normal file
View File

@ -0,0 +1,169 @@
#include <iostream>
#include <queue>
#include <iomanip>
using namespace std;
typedef struct
{
char name;
int ArrivalTime;
int ServiceTime;
int FinishedTime;
int WholeTime;
double WeightWholeTime;
}RR;
static queue<RR>RRqueue; //声明一个队列
static double AverageWT =0,AverageWWT=0;
static int q; //时间片
static int n; //进程个数
static RR RRarray[100]; //进程结构
void Input()
{
//用户输入模式
cout<<"________________________________________________________"<<endl;
cout<<"请输入进程数：";
cin>>n;
cout<<"请输入时间片： ";
cin>>q;
cout<<"请输入进程名:"<<endl;
for (int i=0;i<n;i++)
{
cin>>RRarray[i].name;
}
cout<<"请输入各进程的到达时间:"<<endl;
for (int i=0;i<n;i++)
{
cin>>RRarray[i].ArrivalTime;
}
cout<<"请输入各进程的服务时间:"<<endl;
for (int i=0;i<n;i++)
{
cin>>RRarray[i].ServiceTime;
}
}
void RRAlgorithm()
{
char processMoment[100]; //存储每个时间片p对应的进程名称
RRqueue.push(RRarray[0]);
int processMomentPoint = 0;
int CurrentTime=0;
int tempTime;
int i=1; //指向还未处理的进程的下标
int finalProcessNumber = 0; //执行RR算法后，进程的个数
int processTime[50];
//CurrentTime的初始化
if (RRarray[0].ServiceTime>=q)
{
CurrentTime = q;
}
else
{
CurrentTime = RRarray[0].ServiceTime;
}
while(!RRqueue.empty())
{
for (int j=i;j<n;j++) //使得满足进程的到达时间小于当前时间的进程都进入队列
{
if (RRarray[j].name!=NULL && CurrentTime >= RRarray[j].ArrivalTime)
{
RRqueue.push(RRarray[j]);
i++;
}
}
if (RRqueue.front().ServiceTime<q)
{
tempTime = RRqueue.front().ServiceTime;
}
else
{
tempTime = q;
}
RRqueue.front().ServiceTime -= q; //进程每执行一次，就将其服务时间 -q
//将队首进程的名称放入数组中
processMoment[processMomentPoint] = RRqueue.front().name;
processMomentPoint++;
processTime[finalProcessNumber] = tempTime;
finalProcessNumber++;
if (RRqueue.front().ServiceTime <= 0) //把执行完的进程退出队列
{
//RRqueue.front().FinishedTime = CurrentTime;
RRqueue.pop(); //如果进程的服务时间小于等于，即该进程已经服务完了，将其退栈
}
else
{
//将队首移到队尾
RRqueue.push(RRqueue.front());
RRqueue.pop();
}
CurrentTime += tempTime;
}
for (int i=0;i<n;i++)
{
RRarray[i].WholeTime = RRarray[i].FinishedTime - RRarray[i].ArrivalTime;
RRarray[i].WeightWholeTime = (double)RRarray[i].WholeTime/RRarray[i].ServiceTime;
}
double x=0,y=0;
for (int i=0;i<n;i++)
{
x += RRarray[i].WholeTime;
y += RRarray[i].WeightWholeTime;
}
AverageWT = x/n;
AverageWWT = y/n;
}
void display()
{
cout<<"________________________________________________________"<<endl;
cout<<"RR调度算法执行后：进程相关信息如下："<<endl;
cout<<setw(10)<<"进程名（ID）"<<" ";
cout<<setw(10)<<"到达时间"<<" ";
cout<<setw(10)<<"服务时间"<<" ";
cout<<setw(10)<<"完成时间"<<" ";
cout<<setw(10)<<"周转时间"<<" ";
cout<<setw(10)<<"带权周转时间"<<endl;
for (int i = 0;i<n;i++)
{
cout<<setw(10)<<RRarray[i].name<<" ";
cout<<setw(10)<<RRarray[i].ArrivalTime<<" ";
cout<<setw(10)<<RRarray[i].ServiceTime<<" ";
cout<<setw(10)<<RRarray[i].FinishedTime<<" ";
cout<<setw(10)<<RRarray[i].WholeTime<<" ";
cout<<setw(10)<<RRarray[i].WeightWholeTime<<" "<<endl;;
}
cout<<"所有进程的平均周转时间 = "<<AverageWT<<endl;
cout<<"所有进程的平均带权周转时间 = "<<AverageWWT<<endl;
cout<<"________________________________________________________"<<endl;
}
int main()
{
Input();
RRAlgorithm();
display();
system("pause");
return 0;
}

97
计算机组成原理实验代码/RR_V2.0.cpp Normal file
View File

@ -0,0 +1,97 @@
#include<iostream>
using namespace std;
const int N=10;
double daoda[N];//存储到达时间的数组
double fuwu[N]; //存储服务时间的数组
double fuwu_[N];//服务时间的副本
double wancheng[N]={0};//存储完成时间的数组 ,完成时间先都赋值为0
double zhouzhuan[N];//存储周转时间的数组
double daiquanz[N];//存储带权周转时间的数组
string name[N];//每个进程的名字
int main()
{
//RR 时间片轮转算法
cout<<"请输入进程数："<<endl;
int n;//作业数
cin>>n;
cout<<"请输入"<<n<<"个进程的名字、到达时间和运行时间："<<endl;
for(int i=0;i<n;i++)
{
cin>>name[i];//进程的名字 比如A B C 之类的
cin>>daoda[i]>>fuwu[i];//初始条件 存入到达时间和运行时间
fuwu_[i]=fuwu[i];//备份
}
double q;
cout<<"请输入时间片q:"<<endl;
cin>>q;
for(int i=0;i<n;i++)//选择排序法 根据到达时间从小到大进行排序
{
for(int j=0;j<n;j++)
{
if(daoda[i]<daoda[j])
{
swap(daoda[i],daoda[j]);//这下面这几步是为了同一个进程的这些时间对应的保持一致
swap(fuwu[i],fuwu[j]);//当到达时间交换了，对应的其他时间也应该交换
swap(fuwu_[i],fuwu_[j]);
swap(zhouzhuan[i],zhouzhuan[j]);
swap(daiquanz[i],daiquanz[i]);
swap(name[i],name[j]);//进程的名字也要跟着作业排序的变化而变化
}
}
}
//成时间
double addfuwu=0;//累计服务时间，初始值设为0
int count=n;//为了不改变进程总数n的值，令count=n
int count1=0;//在某一轮轮转中完成的进程
while(count!=0)//当进程数不为0的时候
{
count=count-count1;//还剩下没有完成的进程数目
for(int i=0;i<n;i++)
{
if(fuwu[i]<=q)//如果还剩下的服务时间小于时间片
{
if(wancheng[i]!=0)//这里是防止在进行新一轮的轮转时，会重复把已经完成的进程算进去
{
addfuwu=addfuwu+0;//算进去累计时间加0
}
else
{
addfuwu=addfuwu+fuwu[i];//累计时间就等于之前的累计时间+最后这一轮的真正服务服务时间（反正小于q）
wancheng[i]=addfuwu;//则完成时间=目前累计服务时间
count1++;//计算这一次轮转结束的进程数目
}
}
else
{
fuwu[i]=fuwu[i]-q;//剩余的服务时间就是服务时间-时间片q
addfuwu=addfuwu+q;//累计服务时间=之前服务时间+时间片q(这一轮这个进程的服务时间)
}
}
}
// ----------------------
//计算周转时间和带权周转时间
for(int i=0;i<n;i++)
{
zhouzhuan[i]=wancheng[i]-daoda[i];//周转时间=完成时间-到达时间
daiquanz[i]=zhouzhuan[i]/fuwu_[i];//带权周转时间=周转时间/服务时间
}
cout<<"RR调度算法执行后,进程相关信息如下："<<endl;
cout<<"进程"<<" "<<"到达时间"<<" "<<"服务时间"<<" "<<"完成时间"<<" "<<"周转时间"<<" "<<"带权周转时间"<<endl;
for(int i=0;i<n;i++)
{
cout<<name[i]<<" \t";
cout<<daoda[i]<<" \t"<<fuwu_[i]<<" \t";
cout<<wancheng[i]<<" \t";
cout<<zhouzhuan[i]<<"\t"<<daiquanz[i]<<"\t"<<endl;
}
double sum1=0;
double sum2=0;
for(int i=0;i<n;i++)
{
sum1+=zhouzhuan[i];//计算周转时间的和
sum2+=daiquanz[i]; //计算带权周转时间的和
}
cout<<"平均周转时间："<<sum1/n<<endl;//平均周转时间=周转时间/进程数量
cout<<"平均带权周转时间："<<sum2/n<<endl;//平均带权周转时间=带权周转时间/进程数量
return 0;
}

0
计算机组成原理实验代码/TestData.txt Normal file
View File

60
计算机组成原理实验代码/raylib_test.cpp Normal file
View File

@ -0,0 +1,60 @@
#include <raylib.h>
#include <math.h>
int main(void) {
// 初始化
const int screenWidth = 640;
const int screenHeight = 480;
//启用反锯齿
SetConfigFlags(FLAG_MSAA_4X_HINT);
//初始化窗口
InitWindow(screenWidth, screenHeight, "Sample");
// 初始化摄像机
Camera3D camera = { 0 };
camera.position = (Vector3) {
40.0f, 20.0f, 0.0f
}; //相机所在位置{x,y,z}
camera.target = (Vector3) {
0.0f, 0.0f, 0.0f
}; //相机朝向位置{x,y,z}
camera.up = (Vector3) {
0.0f, 1.0f, 0.0f
}; //相机正上方朝向矢量
camera.fovy = 70.0f; //相机视野宽度
camera.projection = CAMERA_PERSPECTIVE; //采用透视投影
//设置动画帧率（刷新率，fps）为30帧/秒
SetTargetFPS(30);
//--------------------------------------------------------------------------------------
int angle = 0; //多边形旋转角度
// 主游戏循环
while (!WindowShouldClose()) { //关闭窗口或者按ESC键时返回true
double time = GetTime();
// 每次循环更新一帧
// 摄像机围绕y轴转动
double cameraTime = time * 0.3;
camera.position.x = (float)cos(cameraTime) * 40.0f;
camera.position.z = (float)sin(cameraTime) * 40.0f;
BeginDrawing();
ClearBackground(WHITE);
//以摄像机视角绘制3d内容
BeginMode3D(camera);
DrawCube(Vector3{0, 0, 0}, 10, 10, 10, VIOLET);
DrawCubeWires(Vector3{0, 0, 0}, 10, 10, 10, BLACK);
EndMode3D();
EndDrawing();
}
//关闭窗口
CloseWindow();
return 0;
}