进程调度算法（c语言）_可任选一种程序设计语言实现。 选择一到两种进程调度算法,例如:先来先服务、短进

对一个非抢占式多道批处理系统采用以下算法的任意两种，实现进程调度,并计算进程的开始执行时间,周转时间,带权周转时间,平均周转时间,平均带权周转时间
1.先来先服务算法 2.短进程优先算法 *3.高响应比优先算法

一、设计思想
每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算

1、先来先到算法：优先运行先到达的进程，后达到的进程后运行，类似数据结构中的队列，先进先出，对于先来先服务算法，我们只需要队进程进行排序即可；
2、短进程优先算法：若进程的到达时间有先后，则还是先运行先到达的进程，若当前有进程正在运行，则到达的进程置为就绪状态，等待进程运行完毕，释放资源后，比较处于就绪状态的进程，服务时间短的优先运行，等待下一个进程运行完毕后，继续比较就绪进程的服务时间，仍取服务时间短的。

数据结构：

先来先服务排序部分算法：

短进程优先部分算法：

将所有的进程信息存入数组里，本程序通过随机赋值赋予进程到达时间、服务时间等，然后通过计算计算出周转时间、带权周转时间、平均周转时间以及平均带权周转时间

程序源代码如下：

`#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h> 

//进程控制块(PCB)
struct PCB
{
	char name;
	float arrivetime;
	float servetime;
	float finishtime;
	float roundtime;
	float daiquantime;
};

struct PCB a[100];
struct PCB b[100];
char *jczt[] = { "运行", "就绪" };//*表示没有字符串的大小限制

//打印统计信息
void tjxx(int n)
{
	float averoundtime = 0.0f;		
	float avedaiquantime = 0.0f;	
	printf("按任意键查看统计信息");
	getchar(); getchar();
	printf("\n\n进程名称\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间");
	for (int j = 0; j < n; j++)
	{
		printf("\n   %c\t\t%4.f\t\t%4.f\t\t%4.f\t\t%4.f\t\t  %.2f\n", a[j].name, a[j].arrivetime, a[j].servetime, a[j].finishtime, a[j].roundtime, a[j].daiquantime);
		averoundtime += a[j].roundtime;
		avedaiquantime += a[j].daiquantime;
	}

	printf("\n平均周转时间:%.2f", averoundtime / n);
	printf("\n\n平均带权周转时间:%.2f\n", avedaiquantime / n);
}


void xlxfw(int n)
{
	int time = 0;				//定义当前时刻
	int processnum = 0;				//定义当前进程指向
	struct PCB t;				//定义一个空的结构体节点
	int processztsy = 0;				//定义进程状态索引

	while (1)
	{
		printf("当前时刻：%2d\n", time);

		//排序
		for (int i = 1; i < n; i++)
		{
			for (int j = 0; j < n - i; j++)
			{
				if (a[j].arrivetime > a[j + 1].arrivetime)//先到先运行
				{
					t = a[j];
					a[j] = a[j + 1];
					a[j + 1] = t;
				}
				if (a[j].arrivetime == a[j + 1].arrivetime)//进程同时到
				{
					if (a[j].servetime > a[j + 1].servetime)//比较服务时间,将运行时间短的放在优先级高的位置
					{
						t = a[j];
						a[j] = a[j + 1];
						a[j + 1] = t;
					}
				}
			}
		}

	
		for (int k = 0; k< n; k++)
		{
		
			if (time == a[k].arrivetime && a[k].arrivetime != 0)
			{
				
				if (k >= 1 && time >= a[k - 1].finishtime || k == 0)
				{
					processztsy = 0;
				}
				else
				{
					processztsy = 1;
				}
				printf("\t\t进程 %c 到达\t进程状态\n", a[k].name);
				printf("\n\t\t\t\t  %s\n\n\n", jczt[processztsy]);
			

			
				if (processnum >= 1)
				{
					a[k].finishtime = a[k - 1].finishtime + a[k].servetime;
					a[k].roundtime = a[k].finishtime - a[k].arrivetime;
					a[k].daiquantime = a[k].roundtime / a[k].servetime;
				}
				if (processnum == 0)
				{
					a[k].finishtime = a[k].arrivetime + a[k].servetime;
					a[k].roundtime = a[k].finishtime - a[k].arrivetime;
					a[k].daiquantime = a[k].roundtime / a[k].servetime;
					printf("\t\t\t进程  %c  开始\n\n\n\n", a[processnum].name);
					processnum++;
				}
			}
			
			if (time == a[k].finishtime && a[k].finishtime != 0)
			{
				printf("\t\t\t进程  %c  完成\n\n\n\n", a[k].name);
			}
		
			if ((k >= 1 && time >= a[k].arrivetime && time == a[k - 1].finishtime && a[k].arrivetime != 0))
			{
				printf("\t\t\t进程  %c  开始\n\n\n\n", a[k].name);
			}
		}

	
		if (time > a[n - 1].finishtime && a[n - 1].finishtime != 0)
		{
			printf("\t\t\t所有进程已进程已加载完毕！ \n\n\n\n");
			break;
		}
		time++;
		Sleep(1000);
	}
	tjxx(n);
}




void djcyx(int n)
{
	struct PCB t;
	int time = 0;//定义当前时刻
	int jcnum = 0;
	int jcztsy = 0;
	bool ztgb = false;

	//排序
	for (int i = 1; i < n; i++)
	{
		for (int j = 0; j < n - i; j++)
		{
			if (a[j].arrivetime > a[j + 1].arrivetime)//先到达的优先级高
			{
				t = a[j];
				a[j] = a[j + 1];
				a[j + 1] = t;
			}
		}
	}

	while (1)
	{
		printf("当前时刻：%d\n", time);


		//遍历数组，注意同时达到的进程，所以采用for循环遍历
		for (int k = 0; k< n; k++)
		{
			//是否有进程的到达时间等于当前时刻
			if (time == a[k].arrivetime && a[k].arrivetime != 0)
			{
				//判断到达进程因该处于什么状态
				if (k >= 1 && time >= a[k - 1].finishtime || k == 0)
				{
					jcztsy = 0;
				}
				else
				{
					jcztsy = 1;
				}
				printf("\t\t进程 %c 到达\t进程状态\n\n\n\n", a[k].name);
			}
		}

		if (jcnum == 0)
		{
			//遍历数组
			for (int i = jcnum; i < n; i++)
			{
				//把当前到达的进程筛选出来
				if (time >= a[i].arrivetime)
				{
					//从挑选出来的进程中选取服务时间最短的一个
					if (a[i].servetime < a[jcnum].servetime)
					{
						t = a[jcnum];
						a[jcnum] = a[i];
						a[i] = t;
					}
					ztgb = true;
				}
			}
			if (ztgb == true)
			{
				printf("\t\t\t进程  %c  开始\n\n\n\n", a[jcnum].name);
				a[jcnum].finishtime = a[jcnum].arrivetime + a[jcnum].servetime;
				a[jcnum].roundtime = a[jcnum].finishtime - a[jcnum].arrivetime;
				a[jcnum].daiquantime = a[jcnum].roundtime / a[jcnum].servetime;
				ztgb = false;
				jcnum++;
			}
		}

		if (time == a[jcnum - 1].finishtime && a[jcnum - 1].finishtime != 0)
		{
			printf("\t\t\t进程  %c  完成\n\n\n\n", a[jcnum - 1].name);

			//遍历数组
			for (int i = jcnum; i < n; i++)
			{
				//把当前到达的进程筛选出来
				if (time >= a[i].arrivetime)
				{
					//从挑选出来的进程中选取服务时间最短的一个
					if (a[i].servetime < a[jcnum].servetime)
					{
						t = a[jcnum];
						a[jcnum] = a[i];
						a[i] = t;
					}
					ztgb = true;
				}
			}
			if (ztgb == true || jcnum == n - 1)
			{
				printf("\t\t\t进程  %c  开始\n\n\n\n", a[jcnum].name);
				a[jcnum].finishtime = a[jcnum - 1].finishtime + a[jcnum].servetime;
				a[jcnum].roundtime = a[jcnum].finishtime - a[jcnum].arrivetime;
				a[jcnum].daiquantime = a[jcnum].roundtime / a[jcnum].servetime;
				ztgb = false;
				jcnum++;
			}
		}
		if (time > a[n - 1].finishtime && a[n - 1].finishtime != 0)
		{
			printf("\t\t\t所有进程已加载完毕！ \n\n\n\n");
			break;
		}
		time++;
		Sleep(1000);
	}
	tjxx(n);
}


//信息录入
int info()
{
	int n = 0;
	srand(time(NULL)); //初始化随机函数     	
	printf("\n\t\t请输入需要的进程数：");
	scanf("%d", &n);
	printf("\n");
	for (int i = 0; i < n; i++)
	{
		printf("\t\t进程 %d\t名称:", i + 1);
		scanf("%s", &a[i].name);
		a[i].arrivetime = (float)(rand() % 5 + 1);//随机获取进程运行到达时间
		a[i].servetime = (float)(rand() % 5 + 1);//随机获取进程运行服务时间
	}
	system("cls");
	return n;
}

void main()
{
	int b = 1, k;
	while (b)
	{
		system("cls");
		printf("\n\n\t\t进程调度算法\n\n");
		printf("\t\t 程序清单\n");
		printf("\t\t1.... 先来先服务算法        \n");
		printf("\t\t2.... 短进程优先算法        \n");
		printf("\t\t3.... 退出程序          \n\n\n");
		printf("\t\t请选择：");
		scanf("%d", &k);
		switch (k)
		{
		case 1:	 xlxfw(info());    	break;
		case 2:  djcyx(info());     break;
		case 3:  b = 0;               break;
		default:printf("\n\t\t请输入正确的选择!\n");
		}
		if (b != 0)
		{
			printf("\n"); system("pause");
		}
	}
	printf("\n\t\t谢谢使用！\n\n\t\t");
}`
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299