程序在向操作系统申请内存空间的时候，操作系统会扫描空闲块链表并从中取出一块足够大的分配，与之对应的算法有 首次适应 和 最佳适应，顾名思义，首次适应就是把首次遇到的足够大的空闲块分配给应用程序，最佳适应就是扫描完空闲块链表把大小与申请空间最匹配的空闲块分配给应用程序。

    mem.h        程序用到的头文件

    main.c       主函数

    fit.c        具体的实现函数

这里使用make来编译使用，若是读者还没接触过make的，

请移步参考我写的这篇文章：http://netcake.blog.51cto.com/8663272/1560563

================================================

mem.h

------------------------------------------------

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

//模拟空闲块链表的节点，其中k代表空闲空间大小
typedef struct po{
    int k;
    struct po *next;
}points;

void initalize(void);//初始化空闲块链表，给节点中代表空闲空间大小k赋值

void print(void);    //打印空闲块链表

void fassign(void);  //first_fit，首次适应算法

void bassign(void);  //best_fit,最佳适应算法

================================================

================================================

main.c

------------------------------------------------

/*
    内存分配适应算法主函数
    
        while（打印提示用户的输入信息）
             等待用户输入
            用户合法，执行相应操作
*/
#include "mem.h"

main()
{
    char c;
    initalize();

    printf("p表示打印空闲空间块，m表示要申请一块空闲空间,q表示退出，请输入：");
    while(c = getchar())    
        if(c == ‘\n‘)
            continue;
        else
        {
            switch(c)
            {
                case ‘p‘:
                    print();
                    break;
                case ‘b‘:
                    bassign();
                    break;
                case ‘f‘:
                    fassign();
                    break;
                case ‘q‘:
                    exit(0);
                default:
                    printf("请正确输入！\n");
            }
            printf("p表示打印空闲空间块大小，b表示最佳适应法，f表示首次适应法,q表示退出，请输入：");
        }
}

================================================

fit.c

------------------------------------------------

#include "mem.h"

static points * header;//空闲块链表头节点的全局变量,使用static限定只能在本文件使用
#define MAXSIZE    140

//初始化空闲块链表
void initalize(void)
{
    points *f, *b;
    int i = 6;
        
    header = (points *)malloc(sizeof(points *));
    header->k = 6;//头节点记录空闲块的块数，头节点并不属于要分配的内存的一部分
    header->next = NULL;
    b = header;

    while(--i)
    {
        f = (points *)malloc(sizeof(points *));
        f->k = rand()%(MAXSIZE-i*10);
        f->next = NULL;
        
        b->next = f;
        b = f;
        f = f->next;
    }
    f = (points *)malloc(sizeof(points *));
    f->k = MAXSIZE;
    f->next = NULL;
    b->next = f;
}
//打印空闲链表
void print(void)
{
    points *p;
    for(p=header->next; p != NULL; p=p->next)
        printf("%d ", p->k);
    printf("\n");

}
void getsize(int *size)
{
    char a[3], c, *p;
    int i, k;

    getchar();//读取在菜单选择时候的回车符

    while(1)
    {
        printf("请输入要申请的空间的大小，范围(0-120]:");
        //每次对a初始化是为了避免再输入超3个字符错误之后，输入少于3个字符的情况
        for(i=0;i<3;i++)
            a[i]=‘f‘;
        p = a;
        for(i=0;(c=getchar())!=‘\n‘ && i<3;i++)
            *p++ = c;
        k = i;
        for(i=0; i<k; i++)
            if(a[i] <‘0‘ || a[i]>‘9‘)
            {
                printf("非法输入!\n");
                break;
            }
        if(i == k)
        {
            *size = atoi(a);
            if(*size<=0 || *size>MAXSIZE)
            {
                printf("非法输入!\n");
                continue;
            }
            else
                break;
        }
    }
}
void bassign(void)
{
    int size, far=MAXSIZE, n;
    points *ptr, *p;
    getsize(&size);
    for(p=header->next; p!=NULL; p=p->next)
        if((n=p->k-size) >= 0 && n < far)
        {    
            far = n;
            ptr = p;
        }
    printf("最佳适应法分配的空间块大小是 %d\n", ptr->k);
}
void fassign(void)
{
    int size;
    points *p;

    getsize(&size);
    for(p=header->next; p!=NULL; p=p->next)
        if((p->k-size) >= 0 )
            break;
    printf("首次适应法分配的空间块大小是 %d\n", p->k);
}

/*

使用scanf函数并不不能正确处理遇到输入为字符串的情况，这里提供这个一开始

为了简单而暂时使用的处理用户输入的函数

void getsize(int *size)
{
    char *p;
    while(1)
    {
        printf("请输入要申请的空间的大小，范围(0-120]:");
        scanf("%d", size);
        if(*size<=0 || *size>120)
            printf("输入非法！\n");
        else
            break;
    }
}
 
 */

================================================

内存分配算法 之 首次适应-最佳适应