内存分配算法--最先适应、最佳适应、最坏适应

要求模拟分区存储器中动态分区法，实现分区分配的三种算法：最先适应法，最佳适应法和最坏适应法。运行时可任选一种算法。系统应能显示内存分配的状态和参数变化情况。

#include
#include
#define Free 0 //空闲状态
#define Used 1 //已用状态
#define OK 1    //完成
#define ERROR 0 //出错
#define MAX_length 32767 //最大内存空间为32767KB
typedef int Status;   //typedef将标识符Status定义成一个数据型标识符
int n = 0;
typedef struct freearea { //定义一个结构体freearea并对这个空闲分区进行说明
    int ID;       //分区号
    long size;    //分区大小
    long address; //分区地址
    int state;    //当前状态
} ElemType;

typedef struct DuLNode { //double linked list    // 线性表的双向链表存储结构
    ElemType data;
    struct DuLNode *prior; //前趋指针
    struct DuLNode *next; //后继指针
} DuLNode *DulinkList;

DulinkList free_list;  //空闲链表
DulinkList alloc_list; //已分配链表

Status alloc（int）;//内存分配
void free_memory（int ID int method）; //内存回收

Status first_fit（int ID int size）; //首次适应算法
Status best_fit（int ID int size）; //最佳适应算法
Status worst_fit（int ID int size）; //最坏适应算法

void   first_fit_insert（DuLNode *insert）; //首次适应插入排序
void   best_fit_insert（DuLNode *insert）;  //最佳适应插入排序
void   worst_fit_insert（DuLNode *insert）; //最坏适应插入排序

DuLNode *independent_node（DuLNode *node）; //断开节点node与相邻节点的联系，使其孤立
//将节点node分割，返回分配的节点信息，node为剩余内存信息
//node为双指针形式，因为可能需要对node的值进行修改
DuLNode *slice_node（DuLNode **node int ID int size）; 

void show（）;//查看分配
Status Initblock（）;//开创空间表

Status Initblock（）//开创带头节点的内存空间链表，头节点不用
{
    alloc_list = （DulinkList）malloc（sizeof（DuLNode））;
    free_list = （DulinkList）malloc（sizeof（DuLNode））;
    //头节点不用
    alloc_list->prior = alloc_list->next = NULL;
    free_list->prior = free_list->next = NULL;
    //空闲列表初始为整个内存大小，放到node节点中
    DuLNode *node = （DuLNode*）malloc（sizeof（DuLNode））;
    node->data.address = 0;
    node->data.size = MAX_length;
    node->data.ID = 0;
    node->data.state = Free;
    //将node节点放到空闲链表中
    node->prior = free_list;
    node->next = NULL;
    free_list->next = node;

    return OK;
}
//将所插入节点按首址从小到大顺序插入到空闲链表中
void   first_fit_insert（DuLNode *insert） //首次适应插入排序
{
    DuLNode *p = free_list->next;

    //空闲链表为空，则将节点放到头节点后
    if （p == NULL） {
        free_list->next = insert;
        insert->prior = free_list;
        return;
    }

    //按首址从小到大的顺序插入节点
    while （p） {
        //找到插入位置: p之前
        if （insert->data.address <= p->data.address） {
            insert->next = p;
            insert->prior = p->prior;
            p->prior->next = insert;
            p->prior = insert;
            break;
        }

        //插入位置为链表尾
        if （p->next == NULL） {
            p->next = insert;
            insert->prior = p;
            break;  //还是提前退出循环的好，不然会再次进入循环
        }

        p = p->next; //搜索下一个节点
    }
}
//最佳适应插入排序：
//将所插入节点按空间从小到大插入链表
void   best_fit_insert（DuLNode *insert）
{
    DuLNode *p = free_list->next;

    //空闲链表为空，则插入到头节点后
    if （p == NULL） {
        free_list->next = insert;
        insert->prior = free_list;
        return;
    }

    //按空间从小到大插入节点
    while （p） {
        //在p前插入
        if （insert->data.size <= p->data.s

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     目录           0  2010-07-16 22:29  内存分配算法\
     文件      408339  2010-07-16 06:55  内存分配算法\2010操作系统课程设计.doc
     文件       14495  2010-07-16 22:29  内存分配算法\memalloc.cpp
     文件        3425  2010-07-16 15:25  内存分配算法\memalloc.dsp
     文件         541  2010-07-16 15:25  内存分配算法\memalloc.dsw