数据结构2

最新推荐文章于 2025-12-14 11:20:37 发布
原创 最新推荐文章于 2025-12-14 11:20:37 发布 · 203 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 

#include <stdio.h> 
#include <stdlib.h>
#include <time.h>
#include <math.h>

int main()
{
    FILE *fp;
	FILE *fp1;
	FILE *fp2;
	
	srand(time(NULL));//先种种子 
    int request[100];
	
	char input[100];
	int i,j,s=0;
	int M = 0;		//记录文件中页表个数
    int n = 0;		//页框数
	int count;		//缺页个数
	float rate;		//缺页率
	
	
	/*生成100个1-10的随机数，并将其写入到data.txt中*/
	fp = fopen("page.txt","w");
	
	/*如果文件不存在*/
    if(fp == NULL)
        return -1;
	
	fp2 = fopen("result.txt", "a+");
	
	for(i = 0; i < 100; i++) //产生100个10以内的随机数 
	{
		j = rand() % 10 ;
		fprintf(fp,"%d ", j);
		fprintf(fp2,"%d ", j);
	}
	fclose(fp);
	
	/*文件指针读取文件*/
    fp1 = fopen("page.txt","r");
	
	/*如果文件不存在*/
    if(fp1 == NULL)
        return -1;
	
	/*读取文件中请求序列*/
    while(fscanf(fp1,"%d",&request[M]) != EOF)
        M++;
	
	printf("\n");
	printf("================================================================================\n");
	printf("%d\n", M);
	for(i = 0; i < M; i++){
		printf("%d ", request[i]);
	}
	
	printf("\n");
	printf("================================================================================\n");
	
	printf("Please input the number of page frame:");
	scanf("%d", &n);
	printf("\n");
	printf("%d\n", n);
	
	printf("================================================================================\n");
	fprintf(fp2, "\n===================================================================================\n");
	
	fprintf(fp2, "The number of page is %d\n", M);
	
	fprintf(fp2, "The number of page frame is %d\n", n);
	
    count = fifo(request, M, n);
    printf("FIFO: %d \n", count);
	fprintf(fp2, "FIFO: %d \n", count);
	rate = (float)count/M;
	printf("the rate of missing pages is: %.2f\n", rate);
	fprintf(fp2, "the rate of missing pages is: %.2f\n", rate);
	printf("==================================================================================\n");
	
    count = lru(request, M, n);
    printf("LRU: %d \n", count);
	fprintf(fp2, "LRU: %d \n", count);
	rate = (float)count/M;
	printf("the rate of missing pages is: %.2f\n", rate);
	fprintf(fp2, "the rate of missing pages is: %.2f\n", rate);
	printf("==================================================================================\n");
	
    count = clo(request, M, n);
    printf("CLOCK: %d \n", count);
	fprintf(fp2, "CLOCK: %d \n", count);
	rate = (float)count/M;
	printf("the rate of missing pages is: %.2f\n", rate);
	fprintf(fp2, "the rate of missing pages is: %.2f\n", rate);
	printf("===================================================================================\n");
	fprintf(fp2, "===================================================================================\n");
	
			//关闭文件指针
	fclose(fp1);
	fclose(fp2);
	return 0;
}

/*给数组赋值*/ 
void setarray(int arr[], int num, int val) 
{  
	int i;
	
	for (i = 0; i < num; i++)   
		arr[i] = val; 
}

/*声明一个二维数组用来存储内存中页面变化情况*/
void initarr(int **arr, int rnum, int cnum)
{
    int r, c;
    for(r = 0; r < rnum; r++)
    {
        for(c = 0; c < cnum; c++)
            arr[r][c] = -1;
    }
}

/*查找内存 mem 中是否存在页面 page*/ 
int findexist(int mem[], int mnum, int page) 
{  
	int i;
	
	for (i = 0; i < mnum; i++){
		if (mem[i] == page)
			return i;  
	}
	
	return -1; 
}

/*查找内存 mem 中是否存空的位置*/ 
int findempty(int mem[], int mnum) 
{  
	int i; 
	
	for (i = 0; i < mnum; i++){   
		if (mem[i] == -1)
			return i;  
	} 
	
	return -1; 
} 

/*打印内存中页面的变化*/
void print(int **a, int rnum, int mnum){
	
	int i = 0;
	int k = 0;
	int j;
	
    while(i < mnum)
    {
		for(j = 10 * k; j < rnum; j++)
		{	
				if(j != 10 * (k+1))
				   printf("%d\t", a[i][j]);
			   
				if(j % 10 == 0 && j != 10 * k && i == mnum-1)
				{   
					i=-1;
					k++;
					printf("\n");
					break;
				}
				
				if(j%10==0&&j!=k*10&&i!=mnum-1)
					break;
		}
		
				printf("\n");
				i++;
        
    }
}

/*先进先出页面置换算法*/ 
int fifo(int req[], int rnum, int mnum) 
{  
	int count;  
	int i, j;  
	int pos;     

	
	/*
	分配内存空间
	实验中常用的mnum=3
	初始化为-1
	*/
	/*分配内存空间*/
    int *mem = (int *)malloc(sizeof(int ) * mnum);
    setarray(mem, mnum, -1);
	
    /*time记录内存中每个页面进入的时间*/
    int *time = (int *)malloc(sizeof(int) * mnum);
    setarray(time, mnum, rnum);
	
    /*a记录内存中存放的页面*/
    int **a;
    a = (int **)malloc(sizeof(int *) * mnum);
    a[0] = (int *)malloc(sizeof(int) * rnum * mnum);
    for(i = 1; i < mnum; i++)
        a[i] = a[0] + i * rnum;
    initarr(a, mnum, rnum);

	/*缺页次数初始时为 0*/  
	count = 0; 
 
	for (i = 0; i < rnum; i++){   
	
		/*发现页面请求是否存在内存中*/   
		pos = findexist(mem, mnum, req[i]); 
	
		/*如果内存中存在页面请求*/   
		if (pos != -1){
			
			for(j = 0; j < mnum; j++){
				a[j][i+1] = a[j][i];
			}
			/*	
				a[0][i+1] = a[0][i];
				a[1][i+1] = a[1][i];
				a[2][i+1] = a[2][i];	*/
			
			continue;
		}
		
		/*如果内存中不存在缺页次数加一*/   
		count++; 
		
		/*内存中是否存在空位置可以存放新页面*/   
		pos = findempty(mem, mnum); 
		
		/*存在空位置，直接存入新页面，不做置换*/   
		if (pos != -1){
			mem[pos] = req[i];
			time[pos] = i;
			
			a[pos][i] = req[i];
			for(j = 0; j < mnum; j++){
				a[j][i+1] = a[j][i];
			}
            /*	a[0][i+1] = a[0][i];
				a[1][i+1] = a[1][i];
				a[2][i+1] = a[2][i];	*/

			continue;
		}
	
		/*不存在空位置，寻找要置换的页面，fifo*/
		pos = 0;
		
		for (j = 1; j < mnum; j++){
			if (time[j] < time[pos]){
				pos = j;
				}
		}
		
		mem[pos] = req[i];
		time[pos] = i;
		a[pos][i] = req[i];
        if(i < rnum-1)	//防止数组越界
        {
			for(j = 0; j < mnum; j++){
				a[j][i+1] = a[j][i];
			}
			/*	a[0][i+1] = a[0][i];
				a[1][i+1] = a[1][i];
				a[2][i+1] = a[2][i];	*/
        }
	} 
	
	for(j = 1; j < mnum; j++){
		a[j][0] = -1;
	}
	
	/*打印内存中页面的变化*/
	print(a, rnum, mnum);

	free(time);		//释放内存空间
	free(mem);
	free(a);
	
	return count;	//返回缺页次数
	
}

/*最近最久未使用页面置换算法*/
int lru(int req[], int rnum, int mnum){
	
	int count;
	int i, j;
	int pos;
	
	/*分配内存空间*/
    int *mem = (int *)malloc(sizeof(int ) * mnum);
    setarray(mem, mnum, -1);
	
    /*time记录内存中每个页面进入的时间*/
    int *time = (int *)malloc(sizeof(int) * mnum);
    setarray(time, mnum, rnum);
	
    /*a记录内存中存放的页面*/
    int **a;
    a = (int **)malloc(sizeof(int *) * mnum);
    a[0] = (int *)malloc(sizeof(int) * rnum * mnum);
    for(i = 1; i < mnum; i++)
        a[i] = a[0] + i * rnum;
	
    initarr(a, mnum, rnum);
	
    /*缺页率初始时为 0*/
	count = 0; 
	
	for (i = 0; i < rnum; i++){
		
		/*发现页面请求是否存在内存中*/
		pos = findexist(mem, mnum, req[i]); 
		
		/*如果内存中存在页面请求，此处与 fifo 有些许区别*/
		if (pos != -1){
			time[pos] = i;	//此处 lru 记录的是最后一次的访问时间，而 fifo 中记录的是最 先进入的时间
			for(j = 0; j < mnum; j++){
				a[j][i+1] = a[j][i];
			}
			/*	a[0][i+1] = a[0][i];
				a[1][i+1] = a[1][i];
				a[2][i+1] = a[2][i];	*/

			continue;
		}
			
		/*如果内存中不存在缺页次数加一*/
		count++; 
		
		/*内存中是否存在空位置可以存放新页面*/
		pos = findempty(mem, mnum); 
		
		/*存在空位置，直接存入新页面，不做置换*/
		if (pos != -1){
			mem[pos] = req[i];
			time[pos] = i;
			a[pos][i] = req[i];
			for(j = 0; j < mnum; j++){
				a[j][i+1] = a[j][i];
			}
            /*	a[0][i+1] = a[0][i];
				a[1][i+1] = a[1][i];
				a[2][i+1] = a[2][i];	*/

			continue;
		}

		/*不存在空位置，寻找要置换的页面，lru*/
		pos = 0;
		for (j = 1; j < mnum; j++){
			if (time[j] < time[pos]){
				pos = j;
			}
		} 
		
		mem[pos] = req[i];
		time[pos] = i;
		a[pos][i] = req[i];
        if(i < rnum-1)	//防止数组越界
        {
			for(j = 0; j < mnum; j++){
				a[j][i+1] = a[j][i];
			}
			/*	a[0][i+1] = a[0][i];
				a[1][i+1] = a[1][i];
				a[2][i+1] = a[2][i];	*/
        }
	} 
	
	for(j = 1; j < mnum; j++){
		a[j][0] = -1;
	}
	/*	a[1][0] = -1;
		a[2][0] = -1;	*/
	
	/*打印内存中页面的变化*/
	print(a, rnum, mnum);

	free(time);		//释放内存空间
	free(mem);
	free(a);
	
	return count;	//返回缺页次数
	
}

/*时钟算法*/
int clo(int req[], int rnum, int mnum)
{
    int count;
    int i, j, p;
    int pos;
    int flag;
	
    /*分配内存空间*/
    int *mem = (int *)malloc(sizeof(int) * mnum);
    setarray(mem, mnum, -1);
	
    /*state记录内存中每个页面进入时的标记位*/
    int *state = (int *)malloc(sizeof(int) * mnum);
    setarray(state, mnum, 0);
	
    /*a记录内存中存放的页面*/
    int **a;
    a = (int **)malloc(sizeof(int *) * mnum);
    a[0] = (int *)malloc(sizeof(int) * rnum * mnum);
    for(i = 1;i < mnum; i++)
        a[i] = a[0] + i * rnum;

    initarr(a, mnum, rnum);
	
    /*缺页初始时为0*/
    count = 0;
	flag = 0;
    for(i = 0; i < rnum; i++)
    {
        /*发现页面请求是否存在内存中*/
        pos = findexist(mem, mnum, req[i]);
		
        /*如果内存中存在页面请求*/
        if (pos != -1)
        {
		   state[pos] = 1;
		   for(j = 0; j < mnum; j++)
		   {
			  a[j][i+1] = a[j][i];
		   }	
			continue;
	    }
		else
		{ 
           /*如果内存中不存在缺页次数加一*/
            count++;
           /*内存中是否存在空位置可以存放新页面*/
           pos = findempty(mem, mnum);
		   
           /*存在空位置，直接存入新页面，不做置换*/
           if (pos != -1)
           {
               mem[pos] = req[i];
               state[pos] = 1;
			   flag = (flag+1) % mnum;
			   a[pos][i] = req[i];
			   for(j = 0; j < mnum; j++)
			   {
				  a[j][i+1] = a[j][i];
			   }
			   continue;
	    
           }
		   else
		   {
          /*不存在空位置，寻找要置换的页面*/
               pos = 0;
	           while(1)
               {
	              if(state[flag] == 0)
	              {	
                     pos = flag;
		             break;
	              }
	              else
	              { 
	                 state[flag] = 0;
	              }
	             flag++;
	             flag = flag % mnum;
		       }
		         
			   mem[pos] = req[i];
               state[pos] = 1;
			   flag++;
	           flag = flag % mnum;
               a[pos][i] = req[i];
			   
			   if(i < rnum-1)	//防止数组越界
               {
			      for(j = 0; j < mnum; j++)
				  {
				    a[j][i+1] = a[j][i];
			      }
               }
			   
		    }
	    }
		
    }
	
	for(j = 1; j < mnum; j++)
	{
		a[j][0] = -1;
	}

	print(a, rnum, mnum);
  
    free(state);
    free(mem);
    free(a);
	
    return count;
}

LS_346
关注
精选资源
数据结构(第4版)习题及实验参考答案-数据结构复习资料完整版(c语言版).docx
12-14
"数据结构(第4版)习题及实验参考答案-数据结构复习资料完整版(c语言版)" 本文档是关于数据结构的习题及实验参考答案，涵盖了数据结构的基础知识、逻辑结构、物理结构、算法、时间复杂度等方面。 数据结构基础 ...
数据结构和算法PDF文档
06-02
1000多页的算法题解，包含数据结构，排序，查找，递归，回溯算法，二叉树，动态规划，贪心算法，双指针，滑动窗口，前缀和等。
c語言操作文件
studyandhappy的专栏
09-28 556
<br />如果在程序中需要傳遞一些信息，可以有很多方法進行處理。其中以文件的方式傳遞信息也是一種常見的方法。<br />在 C中對文件的操作：<br />下面以讀取d盤下某個文件的內容為例,<br />int num;<br />char str[100];  //定義存取文件的字符數組<br />FILE *fp=fopen("D://page.txt","r"); //以自瀆的方式打開文件<br />while(!feof(fp))<br />{<br />  fscanf(fp,"%s",&str)
【C语言】第十三章-文件操作
记录
05-23 688
1.为什么使用文件 我们在运行程序后，运行结果通常不会保留，当下次再运行时，内存中的数据则已被销毁。而使用文件，我们就可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。 2.文件 2.1程序文件 包括源程序文件（后缀为.c）,目标文件（windows环境后缀为.obj）,可执行程序（windows环境后缀为.exe） 2.2数据文件 文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，或者输出内容的文件。 本章主要讲数据文件，...
文件操作以及相关函数
m0_64028711的博客
07-20 842
在了解文件的保存及访问之前，我们需要对文件有一个基本的认识。文件一般分为两部分1程序文件包括源程序文件(.c后缀)，目标文件（.obj后缀)，可执行程序(.exe后缀)等2数据文件不一定是程序，可能是程序运行时读写的数据等。而每一个文件都有对应的文件名，文件名包含3部分文件路径+文件名主干+文件后缀。如c了解基础后就能够了解怎样才能打开和关闭文件了。...
C语言 fopen和fread函数解析
alexhu2010q的博客
02-13 5484
fopen()函数可以用来打开文件，写法如下，第一个参数是文件名路径，第二个参数的是打开文件的方式： FILE *fp1； fp1 = fopen("file a","r");//r代表read,表示只读 FILE *fp2； fp2 = fopen("c:\\hzk16","rb");//读取c盘的hzk16文件，r代表read,b代表binary，表示只读二进制文件 一共有六种符号： r: ......
文件的基本操作
iwm_NeXT的专栏
04-20 1710
文件的打开(fopen函数) FILE *fp; fp=fopen(文件名,使用文件的方式) 文件使用方式                 　　 含义 "r"(只读)     　　　为输入打开一个文本文件 "w"(只写)   　　     为输出打开一个文本文件 "a"(追加)    　　　 向文本文件尾增加数据 "rb"      　　　　　为输入打开一个二进制文件 "wb"
数据结构
m5127的博客
11-29 2356
什么是数据结构数据的逻辑结构以及存储结构及操作(数据的运算)1.1 数据数据：不再是单纯的数字，而是类似集合的概念数据元素：是数据的基本单位，由若干个数据项组成数据项：数据的最小单位，描述数据元素有用信息数据元素又叫为节点例如：计算机处理的对象(数据)已不再是单纯的数值：图书管理中的数据，如下表所列:12。
数据结构数据结构的实现PDF
07-11
2.熟练掌握常用的数据结构如顺序表、链表、栈、队列、广义表、树结构、图网结构等，学会各种数据结构上的基本运算。 3.初步掌握算法的时间性能与空间性能的分析技巧，得到复杂程序设计的初步训练。 4.学会分析研究...
Python数据结构与算法分析（第2版）1
08-03
【Python数据结构与算法分析（第2版）】是一本专为Python程序员设计的书籍，旨在帮助读者深入了解数据结构和算法在Python环境中的应用。作者布拉德利·米勒和戴维·拉努姆以其丰富的实战经验，清晰地阐述了如何高效...
精选资源
数据结构试题库及答案.docx
05-10
数据结构试题库及答案.docx 本资源摘要信息将围绕数据结构试题库及答案的相关知识点进行详细解释。 数据结构概论 数据结构是研究非数值计算的程序设计问题中计算机的数据元素以及它们之间的关系和运算等的学科。...
文件操作攻略
夏日漱石的博客
03-07 1186
文件操作
【C/C++】freopen 函数和 fopen 函数|标准输入输入写入文件|屏幕输出写入文件
热门推荐
我的笔记本
01-28 2万+
freopen 和 fopen 都是C的标准库函数被包含于C标准库头文件中。fopen就是我们最熟悉的打开一个文件用于写入or读取freopen 是打开一个文件，用于接收输入输出流的数据。
fopen的工作原理
为君歌一曲
01-03 2974
FILE *fp;fp=fopen("filename.txt","w");首先检测filename.txt是否存在，如果不存在则在磁盘创建该文件，然后在内存开辟区域（应该是缓冲区）准备写该文件调用fclose时，将内存中的内容写入到磁盘中去 测试（filename.txt不存在）：#include #include int main(){
力扣hot100：搜索二维矩阵
最新发布
一本大学生java学习技术分享与交流
12-14 166
二分查找返回的是目标值最先出现的位置或者是在有序数组中的插入位置，如果是在有序数组中的插入位置则可能为在数组最后一个位置加一个数，这是如果进行matrix[i][weizi]==target的判断的话会导致数组越界，必须先处理越界问题，最终判断条件应为weizi<matrix[i].length&&matrix[i][weizi]==target。本题的本质是一个查找算法，为了提高性能可以使用二分查找，这个二维矩阵可以看出许多个数组，只需要对每个数组都进行一次二分查找就可以实现查找整个二维矩阵。
Louvain 算法
FionaDong的博客
12-12 188
Louvain 是一种经典的图社区发现算法（Community Detection），由 Blondel 等人在 2008 年提出。核心目标：通过最大化 Modularity（模块度）来自动划分图中的社区（cluster）。它最大的特点是：✔ 速度非常快✔ 能处理百万级节点的大图✔ 结果相对稳定。
Conan-embedding整理
kexin197的博客
12-11 918
本文提出了一种改进的文本嵌入模型Conan-embedding，其核心创新在于动态难负样本挖掘和跨GPU平衡损失。该方法在训练过程中实时挖掘难负样本，使模型能动态适应复杂数据分布；采用多阶段训练策略，包括预训练阶段的通识学习和微调阶段的专项训练；通过跨GPU平衡损失解决训练振荡问题，提升模型稳定性。实验表明，该方法能有效提升文本嵌入质量，尤其在检索任务中表现突出。研究还探讨了不同任务（检索与STS）在训练策略上的差异，为后续研究提供了重要参考。
【每天学习一点算法 2025/12/10】反转链表
Colorful9的博客
12-10 886
本文介绍了反转链表的三种实现方法：1）使用栈结构存储节点后弹栈重建；2）迭代法通过遍历直接修改节点指向；3）递归法在回归过程中逐步反转节点。重点解析了递归实现的原理，通过递推找到尾节点后，在回归过程中逐个反转节点指向并断开原链接。三种方法各有特点，栈实现直观但需额外空间，迭代法高效，递归法则展示了递归的独特处理方式。
数据结构基础概念解析
2. **数据元素**：数据元素是数据的基本单位，是构成数据结构的基本组件，也可以称为节点或记录。每个数据元素通常包含一个或多个数据项。 3. **数据对象**：数据对象是具有相同性质的数据元素的集合，它定义了一类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值