操作系统，最先适应分配算法代码

以下代码如有疑问，请联系博主，最佳适应算法与最差适应算法只需添加简单的排序即可完成（本代码中未添加）

#include <windows.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <io.h>
#include <string.h>

#define MAX_THREAD 3

typedef struct freearea {                   //表示空闲区域的数据结构
    struct freearea *next;                  //指向下一个结点的指针
    int start_address;                     //空闲区起始地址
    int size;                              //空闲区大小
} FREEAREA;

typedef struct require_memory {            //记录线程申请内存的数据结构
    struct require_memory *next;           //指向下一个结点的指针
    char thread_name[10];                //线程名
    int size;                             //申请内存大小（以KB为单位）
    int duration;                         //在内存的驻留时间（以秒为单位）
} REQUIRE_MEMORY;

typedef struct thread_residence_memory {        //描述线程驻留区的数据结构
    struct thread_residence_memory *next;       //指向下一个结点的指针
    char thread_name[10];                     //线程名
    int start_address;                          //驻留区起始地址
    int size;                                   //驻留区大小
} THREAD_RESIDENCE_MEMORY;

FREEAREA init_free_area_table[5]= {
    {NULL,10,10},
    {NULL,40,30},
    {NULL,80,5},
    {NULL,145,15},
    {NULL,180,20}
}; //测试数据：初始空闲区表

REQUIRE_MEMORY init_thread_require_memory_table[3]= {
    {NULL,"thread_1",20,0},
    {NULL,"thread_2",10,0},
    {NULL,"thread_3",5,0}
}; //测试数据：初始内存申请表

THREAD_RESIDENCE_MEMORY init_thread_residence_memory_table[5]= {
    {NULL,"a",0,10},
    {NULL,"b",20,20},
    {NULL,"c",70,10},
    {NULL,"d",85,60},
    {NULL,"e",160,20}
};//测试数据：初始线程驻留区表

FREEAREA *p_free_area_list=NULL;                    //空闲区链首
REQUIRE_MEMORY *p_thread_require_memory_queue=NULL;      //内存申请队列队首
THREAD_RESIDENCE_MEMORY *p_thread_residence_memory_list=NULL; //线程驻留链首
THREAD_RESIDENCE_MEMORY *tail_thread_residence_memory_list=NULL;
//线程驻留区链尾
CRITICAL_SECTION CS_THREAD_MEMORY_LIST;   //保护线程驻留区链表的临界区
CRITICAL_SECTION CS_SCREEN;                  //保护屏幕的临界区
CRITICAL_SECTION CS_FREEAREA_LIST;          //保护空闲区链表的临界区
HANDLE h_thread[MAX_THREAD];                  //线程句柄数组

void print_space(int num);                                   //输出若干个空格
void display_thread_residence_memory_list();                 //显示线程驻留区表
//最先适应分配法的函数
FREEAREA *FF_initialize_freearea_list(FREEAREA *init_table,int num); //初始化空闲区链表
void FF_delete_freearea_list();                                 //删除空闲区链表
REQUIRE_MEMORY *FF_initialize_require_memory_list(REQUIRE_MEMORY *init_table,int num); //初始化内存申请链表
void FF_delete_require_memory_list();                           //删除内存申请链表
THREAD_RESIDENCE_MEMORY  *FF_initialize_thread_residence_memory_list
(THREAD_RESIDENCE_MEMORY *init_table,int num);           //初始化线程驻留区链表
void FF_delete_thread_residence_memory_list();                  //删除线程驻留区链表
void FF_thread(void *data);                                     //线程函数
int FF_require_memory(int size);                                //内存申请函数
void FF_release_memory(int start_address,int size);               //内存释放函数
void FF();                                           //最先适应分配算法的初始化函数
void print_space(int num) {                          //显示若干个空格
    int i;
    for(i=0; i<num; i++) {
        printf(" ");
    }
}

void display_thread_residence_memory_list() {         //显示驻留线程链表
    THREAD_RESIDENCE_MEMORY *p;
    char buffer[20];
    p=p_thread_residence_memory_list;
    printf("|-------------------|--------------------|------------------|\n");
    printf("| thread_name | start_address(kB) | size(KB) |\n");
    printf("|-------------------|--------------------|------------------|\n");
    while(p!=NULL) {
        printf("| %s",p->thread_name);
        print_space(18-strlen(p->thread_name));
        printf("| %d",p->start_address);
        itoa( p->start_address, buffer, 10 );
        print_space(19-strlen(buffer));
        printf("| %d",p->size);
        itoa(p->size, buffer, 10 );
        print_space(17-strlen(buffer));
        printf("|\n");
        p=p->next;
    };


    printf("|-------------------|--------------------|------------------|\n\n");
}

//最先适应分配法：初始化空闲区链表
FREEAREA *FF_initialize_freearea_list(FREEAREA *init_table,int num) {
    FREEAREA *temp;
    FREEAREA *head=NULL;
    FREEAREA *tail=NULL;
    int i;
    for(i=0; i<num; i++) {
        temp=(FREEAREA *)malloc(sizeof(FREEAREA));
        temp->start_address=init_table[i].start_address;
        temp->size=init_table[i].size;
        temp->next=NULL;
        if(head==NULL)
            head=tail=temp;
        else {
            tail->next=temp;
            tail=tail->next;
        }
    };
    return head;
}

//最先适应分配法：删除空闲区链表
void FF_delete_freearea_list() {
    FREEAREA *temp;
    temp=p_free_area_list;
    while(temp!=NULL) {
        temp=p_free_area_list->next;
        free(p_free_area_list);
        p_free_area_list=temp;
    }
    p_free_area_list=NULL;
}


//最先适应分配法：初始化内存申请链表
REQUIRE_MEMORY *FF_initialize_require_memory_list(REQUIRE_MEMORY *init_table,int num) {
    REQUIRE_MEMORY *temp;
    REQUIRE_MEMORY *head=NULL;
    REQUIRE_MEMORY *tail=NULL;
    int i;
    for(i=0; i<num; i++) {
        temp=(REQUIRE_MEMORY *)malloc(sizeof(REQUIRE_MEMORY));
        strcpy(temp->thread_name,init_table[i].thread_name);
        temp->size=init_table[i].size;
        temp->duration=init_table[i].duration;
        temp->next=NULL;
        if(head==NULL)
            head=tail=temp;
        else {
            tail->next=temp;
            tail=tail->next;
        }
    };
    return head;
}

//最先适应分配法：删除内存申请链表
void FF_delete_require_memory_list() {
    REQUIRE_MEMORY *temp;
    temp=p_thread_require_memory_queue;
    while(temp!=NULL) {
        temp=p_thread_require_memory_queue->next;
        free(p_thread_require_memory_queue);
        p_thread_require_memory_queue=temp;
    }
    p_thread_require_memory_queue=NULL;
}

//最先适应分配法：初始化线程驻留区链表
THREAD_RESIDENCE_MEMORY *FF_initialize_thread_residence_memory_list(THREAD_RESIDENCE_MEMORY *init_table,int num) {
    THREAD_RESIDENCE_MEMORY *temp;
    THREAD_RESIDENCE_MEMORY *head=NULL;
    THREAD_RESIDENCE_MEMORY *tail=NULL;
    int i;
    for(i=0; i<num; i++) {
        temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY));
        strcpy(temp->thread_name,init_table[i].thread_name);
        temp->start_address=init_table[i].start_address;
        temp->size=init_table[i].size;
        temp->next=NULL;
        if(head==NULL)
            head=tail=temp;
        else {
            tail->next=temp;
            tail=tail->next;
        }
    };
    tail_thread_residence_memory_list=tail;
    return head;
}

//最先适应分配法：删除线程驻留区链表
void FF_delete_thread_residence_memory_list() {
    THREAD_RESIDENCE_MEMORY *temp=p_thread_residence_memory_list;

    temp=p_thread_residence_memory_list;
    while(temp!=NULL) {
        temp=p_thread_residence_memory_list->next;
        free(p_thread_residence_memory_list);
        p_thread_residence_memory_list=temp;
    }
    p_thread_residence_memory_list=NULL;
}

//线程：申请内存，驻留一段时间，释放内存
void FF_thread(void *data) {
    int start_address=-1;
    THREAD_RESIDENCE_MEMORY *temp;
    EnterCriticalSection(&CS_SCREEN);
    printf("create thread:%s\n",((REQUIRE_MEMORY *)(data))->thread_name);
    LeaveCriticalSection(&CS_SCREEN);


    while(1) {                                                       //申请内存
        start_address=FF_require_memory(((REQUIRE_MEMORY *)(data))->size);
        if(start_address>=0)
            break;
        else
            Sleep(1000);
    }
    temp=(THREAD_RESIDENCE_MEMORY *)malloc(sizeof(THREAD_RESIDENCE_MEMORY));
    strcpy(temp->thread_name,((REQUIRE_MEMORY *)(data))->thread_name);
    temp->start_address=start_address;
    temp->size=((REQUIRE_MEMORY *)(data))->size;
    temp->next=NULL;
    EnterCriticalSection(&CS_THREAD_MEMORY_LIST);
    //加入线程驻留区链表
    tail_thread_residence_memory_list->next=temp;
    tail_thread_residence_memory_list=tail_thread_residence_memory_list->next;
    LeaveCriticalSection(&CS_THREAD_MEMORY_LIST);
    //显示线程驻留区链表
    EnterCriticalSection(&CS_SCREEN);
    printf("after %s %s\n",((REQUIRE_MEMORY *)(data))->thread_name,"get memory:");
    display_thread_residence_memory_list();
    LeaveCriticalSection(&CS_SCREEN);

    Sleep(((REQUIRE_MEMORY *)(data))->duration);
    //释放内存

    FF_release_memory(start_address,((REQUIRE_MEMORY *)(data))->size);

}


//最先适应分配法：内存申请函数
int FF_require_memory(int size) {
    int start_address = -1;
    FREEAREA* p;
    FREEAREA* p_next;
    EnterCriticalSection(&CS_FREEAREA_LIST);
    p = p_next = p_free_area_list;
    while (p_next != NULL) {
        if (size == p_next->size) {
            start_address = p_next->start_address;
            if (p_next == p_free_area_list)
                p_free_area_list = p_next->next;
            else
                p->next = p_next->next;
            free(p_next);
            break;
        } else if (size < p_next->size) {
            start_address = p_next->start_address;
            p_next->start_address += size;
            p_next->size -= size;
            break;
        } else {
            p = p_next;
            p_next = p_next->next;
        }
    }
    LeaveCriticalSection(&CS_FREEAREA_LIST);
    return start_address;

}

//最先适应分配法：内存释放函数
void FF_release_memory(int start_address,int size) {
    EnterCriticalSection(&CS_FREEAREA_LIST);
    FREEAREA *temp, *p, *pp;
    p=p_free_area_list;
    temp = new FREEAREA;
    temp->start_address=start_address;
    temp->size=size;
    temp->next=NULL;
    int flag=0;
    while(1) {
        if(p->next!=NULL&&start_address+size<=p->next->start_address&&start_address>=p->start_address+p->size) {
            temp->next=p->next;
            p->next=temp;
            flag=1;
        }
        if(flag==1||p->next==NULL) break;
        p=p->next;
    }
    if(start_address>=p->start_address+p->size) {
        if(flag==0)
            p->next=temp;
    } else {
        if(flag==0) {
            pp=p_free_area_list;
            temp->next=pp;
            pp->next=p_free_area_list->next;
            p_free_area_list=temp;
        }

    }
    FREEAREA *ppp;
    ppp=p_free_area_list;
    while(1) {
        if(ppp->next!=NULL) {
            if(ppp->start_address+ppp->size==ppp->next->start_address) {
                ppp->size+= ppp->next->size;
                if(ppp->next->next!=NULL)
                    ppp->next=ppp->next->next;
                else {
                    ppp->next=NULL;
                }
                continue;
            }
        }
        if(ppp->next!=NULL) ppp=ppp->next;
        else break;
    }
    EnterCriticalSection(&CS_SCREEN);
    THREAD_RESIDENCE_MEMORY *q;
    q = p_thread_residence_memory_list;
    if (q->start_address == start_address) {
        p_thread_residence_memory_list = p_thread_residence_memory_list->next;
    } else {
        while (q->next != NULL) {
            if (q->next->start_address == start_address) {
                if (q->next == tail_thread_residence_memory_list) {
                    tail_thread_residence_memory_list = q;
                }
                q->next = q->next->next;
                break;
            }
            q = q->next;
        }
    }
    LeaveCriticalSection(&CS_SCREEN);
    LeaveCriticalSection(&CS_FREEAREA_LIST);
}
//最先适应分配算法的初始化程序
void FF( ) {
    int i=0;
    REQUIRE_MEMORY *p;
    HANDLE h_thread[MAX_THREAD];
    InitializeCriticalSection(&CS_THREAD_MEMORY_LIST);
    InitializeCriticalSection(&CS_FREEAREA_LIST);
    InitializeCriticalSection(&CS_SCREEN);
    printf("最先适应分配算法\n");
    p_free_area_list=FF_initialize_freearea_list(init_free_area_table,5);
    p_thread_require_memory_queue=FF_initialize_require_memory_list(init_thread_require_memory_table,3);
    p_thread_residence_memory_list=FF_initialize_thread_residence_memory_list(init_thread_residence_memory_table,5);
    p=p_thread_require_memory_queue;
    while(p!=NULL) {
        h_thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(FF_thread),p,0,NULL);
        i++;
        p=p->next;
    };
    WaitForMultipleObjects(MAX_THREAD,h_thread,TRUE,-1);       //等待所有线程结束
    EnterCriticalSection(&CS_SCREEN);
    printf("after all threads have finished:\n");
    display_thread_residence_memory_list();                    //显示驻留线程链表
    LeaveCriticalSection(&CS_SCREEN);
    //删除各种链表、
    FF_delete_freearea_list();
    FF_delete_require_memory_list();
    FF_delete_thread_residence_memory_list();
    getch();
    printf("\n");
}
int main() {
//  freopen("1.txt","w+",stdout);
    FF( );

}