11123546

#include<iostream>
#include<time.h>
#include <stdlib.h>

using namespace std;
#define times 30000

typedef struct queue_elem{
    int pagenum;
    int count;
    struct queue_elem* infront;
    struct queue_elem* behind;
}queue_elem;

typedef struct queue{
    queue_elem* head;
    queue_elem* tail;
    int frame_count;
}queue; 

typedef struct stack_elem{
    int pagenum;
    struct stack_elem* uplevel;
    struct stack_elem* lowerlevel;
}stack_elem;

typedef struct stack{
    stack_elem* buttom;
    stack_elem* top;
    int frame_count;
}stack;

double FIFO(int framenum);
double LRU(int framenum);
bool Search_FIFO(int framenum,queue* q,int pagenum);
bool Search_LRU(int framenum,stack s,int pagenum);
int ToPage(int order);
queue_elem* findmin(queue q);
double LFU(int framenum);
bool Search_LFU(queue* q,int framenum,int pagenum);

int main(){
    printf("内存页数\tFIFO命中率\tLRU命中率\tLFU命中率\n");
    for(int i=4;i<=40;i++){
        printf("%d\t\t%.2llf%\t\t%.2llf%\t\t%.2llf%\n",i,FIFO(i)*100,LRU(i)*100,LFU(i)*100);
    }
}

int ToPage(int neworder){
    return neworder/10;
}

bool Search_FIFO(queue* q,int pagenum,int framenum){//传入队列指针，新的页码编号,总页码
    queue_elem* temp=q->head;
    int cnt=0;
    while(temp!=NULL){
        if(temp->pagenum==pagenum){
            return 1;
        }
        temp=temp->behind;
    }
    queue_elem* newpage = (queue_elem*)malloc(sizeof(queue_elem));
    newpage->pagenum=pagenum;
    newpage->behind=NULL;
    newpage->infront=NULL;
    if(q->frame_count<framenum){//队列未满，加入队尾
        if(q->head==NULL){
            q->head=newpage;
            q->tail=newpage;
            return 0;
        }
        q->frame_count++;
        q->tail->behind=newpage;
        newpage->infront=q->tail;
        q->tail=newpage;
    }
    else if(q->frame_count==framenum){//队列已满
        q->head=q->head->behind;//队头出队
        free(q->head->infront);
        q->head->infront=NULL;
        q->tail->behind=newpage;
        newpage->infront=q->tail;
        q->tail=newpage;
    }
    return 0;
}

double FIFO(int framenum){
    int newpage,neworder;
    double shoot=0;
    //初始化队列
    queue* q=(queue*)malloc(sizeof(queue));
    q->frame_count=0;
    q->head=NULL;
    q->tail=NULL;
    for(int i=1;i<times;i++){
        int neworder = rand()%400;
        int newpage = ToPage(neworder);
        if(Search_FIFO(q,newpage,framenum)){
            shoot++;
        }
    }
    return shoot/times;
}


bool Search_LRU(int framenum,stack* s,int pagenum){
    stack_elem* temp;
    if((*s).top) temp=(*s).top;
    else temp = NULL;
    int flag=0;
//    cout<<"当前查找的元素:"<<pagenum<<endl;
//    Print_Stack(*s);
    while(temp!=NULL){
        if(temp->pagenum==pagenum){//命中，将当前页面置换道到顶部
        	if(s->top==temp){
				flag=1;
				break;
			}
        	else if(s->buttom==temp){
        		if(s->buttom->uplevel!=NULL) {
					s->buttom=s->buttom->uplevel;
					s->buttom->lowerlevel=NULL;
					temp->uplevel=NULL;
					s->top->uplevel=temp;
					temp->lowerlevel=s->top;
					s->top=temp; 
					flag=1;
					break;
				}	
			} 
            temp->lowerlevel->uplevel=temp->uplevel;
            temp->uplevel->lowerlevel=temp->lowerlevel;
            (*s).top->uplevel=temp;
            temp->lowerlevel=(*s).top;
            temp->uplevel=NULL;
            (*s).top=temp;
            flag=1;
            break;
        }
        temp=temp->lowerlevel;
    }
  
    if(flag==1){
        return 1;
        
    }
    else{//flag==0未命中，栈底出栈，栈顶入栈
        //先要判断栈是否已满
        //已满
        if((*s).frame_count==framenum){
            //将原来栈底元素出栈
            (*s).buttom=(*s).buttom->uplevel;
            free((*s).buttom->lowerlevel);
            (*s).buttom->lowerlevel=NULL;
            //将新元素加入栈顶
            stack_elem* new_page = (stack_elem*)malloc(sizeof(stack_elem));
            new_page->pagenum=pagenum;
            (*s).top->uplevel=new_page;
            new_page->lowerlevel=(*s).top;
            new_page->uplevel=NULL;
            (*s).top=new_page;
        }
        else if((*s).frame_count<framenum){
            stack_elem* new_page = (stack_elem*)malloc(sizeof(stack_elem));
            new_page->pagenum=pagenum;
            if((*s).top==NULL){  //当栈为空的情况
                new_page->uplevel=NULL;
                new_page->lowerlevel=NULL;
                (*s).top=new_page;
                (*s).buttom=new_page;
                (*s).frame_count++;
            }
            else{//当栈未空的情况
                new_page->uplevel=NULL;
                (*s).top->uplevel=new_page;
                new_page->lowerlevel=(*s).top;
                (*s).top=new_page;
                (*s).frame_count++;
            }
        }
        return 0;
    }
}


double LRU(int framenum){
    stack* s;
    //初始化栈
    s=(stack*)malloc(sizeof(stack));
    s->buttom=NULL;
    s->top=NULL;
    s->frame_count=0;

    double shoot=0;//命中次数初始化
    for(int i=1;i<times;i++){
        int neworder=rand()%400;
        int newpage=ToPage(neworder);
        if(Search_LRU(framenum,s,newpage)){
        	//cout<<"本次命中"<<endl; 
            shoot++;
        }
    }
    //cout<<"shoot="<<shoot<<endl;
    return shoot/times;
}

queue_elem* findmin(queue q){
    queue_elem* temp= q.head;
    queue_elem* min_temp;
    int min=10000000;
    while(temp){
        if(temp->count<min){
            min_temp=temp;
            min=temp->count;
        }
        temp=temp->behind;
    }
    return min_temp;

}



bool Search_LFU(queue* q,int framenum,int pagenum){
//	cout<<"flag1"<<endl;
//	cout<<"内存页面数："<<q->frame_count<<endl;
    queue_elem* temp = q->head;
    while(temp){
        if(temp->pagenum==pagenum){
            temp->count++;
            return 1;
        }
        temp=temp->behind;
    }
    if(q->frame_count<framenum)
    {
        queue_elem *newpage = (queue_elem*)malloc(sizeof(queue_elem));
        newpage->behind=NULL;
        newpage->infront=NULL;
        newpage->count=1;
        newpage->pagenum=pagenum;
        if(q->head==NULL){
            q->head=newpage;
            q->tail=newpage;
            q->frame_count++;
        }
		else{
			q->tail->behind = newpage;
        	newpage->infront=q->tail;
        	q->tail=newpage;
        	q->frame_count++;
		}
        
        return 0;
    }
    else if(q->frame_count==framenum){
        //初始化新节点
            queue_elem* newpage = (queue_elem*)malloc(sizeof(queue_elem));
            newpage->behind=NULL;
            newpage->infront=NULL;
            newpage->count=1;
            newpage->pagenum=pagenum;
            queue_elem* des_min = findmin(*q);
        if(des_min->infront&&des_min->behind){
            des_min->infront->behind=des_min->behind;
            des_min->behind->infront=des_min->infront;
            free(des_min);
            //插入队尾
            q->tail->behind=newpage;
            newpage->infront=q->tail;
            q->tail=newpage;
        }
        else if(des_min->infront&&!(des_min->behind)){//直接插入在队尾
            queue_elem *temp=q->tail;//用来等下free空间
            q->tail->infront->behind=newpage;
            newpage->infront=q->tail->infront;
            q->tail=newpage;
            free(temp);
        }
        else if(!(des_min->infront)&&des_min->behind){//直接插入队头
            queue_elem *temp = q->head;
            q->head->behind->infront=newpage;
            newpage->behind=q->head->behind;
            q->head = newpage;
            free(temp);
        }
        else if(!(des_min->infront)&&!(des_min->behind)){
            q->head=newpage;
            q->tail=newpage;
        }
        return 0;
    }
}

double LFU(int framenum){
    double shoot=0;
    queue* q = (queue*)malloc(sizeof(queue));
    q->frame_count=0;
    q->head=NULL;
    q->tail=NULL;
    for(int i=1;i<times;i++){
        int neworder = rand()%400;
        int newpage = ToPage(neworder);
        if(Search_LFU(q,framenum,newpage)) shoot++;
    }
    return shoot/times;
}