计算机操作系统内存分配实验源代码

#include<stdio.h>#include<iostream>usingnamespace std;#define MEM_SIZE 200staticchar mem[MEM_SIZE];#define MINBLK 16struct block {struct block * next;size_t length;char data[0];};staticstruct block * free_list = NULL;//free_list为空void malloc_init(void){free_list = (struct block *)mem;free_list->next = NULL;//next指向空free_list->length = MEM_SIZE - sizeof(struct block);//data段的长度}//字节对齐void * malloc(size_t size){size = (size + 7) & ~7;struct block * prev = (struct block *) &free_list;//block首段struct block * cur = free_list;//cur 指向空闲的块while (cur != NULL) {if (cur->length >= size) //判断cur指向的块是否满足所要求的大小break;prev = cur;cur = cur->next;}if (cur == NULL)return NULL;//cur->length(data段的长度)-size后的大小可不可以放下blockif ((cur->length - size) >= MINBLK) {struct block * temp = (struct block *)(cur->data + size);//temp指向新block的头temp->next = cur->next;//新block指向下一个空白temp->length = cur->length - size - sizeof(struct block);prev->next = temp;cur->length = size;}else {prev->next = cur->next;}return cur->data;}void free(void * ptr){if (ptr == NULL)return;struct block * temp = (struct block *)((char *)ptr - sizeof(struct block));char * tempn = (char *)ptr + temp->length; // 和temp物理上相邻的下一个block的地址struct block * prev = (struct block *) &free_list;struct block * cur = free_list;char * curn; // 和cur物理上相邻的下一个block的地址// 考虑多种情况，完成free函数// ... ...if (free_list > temp)//空块地址大于要释放的块的地址，直接将释放的块放入空白块头部（第一种情况）{if (((char*)temp + sizeof(block)+temp->length) == (char*)free_list) {temp->length += sizeof(block)+free_list->length;free_list = temp;}else {temp->next = free_list;free_list = temp;}ptr = NULL;return;}//若不一定插入头部，寻找插入块while (cur != NULL && (char*)cur < (char*)temp){prev = cur;cur = cur->next;}//temp与前段free_list相邻if (((char *)prev + sizeof(struct block) + prev->length) == (char*)temp){prev->length =prev->length + sizeof(struct block) + temp->length;temp = prev;ptr = NULL;}else{prev->next = temp;ptr = NULL;}//free_list在比temp地址大的地方且两者相邻if ((char *)tempn == (char *)cur || cur == NULL){temp->next = cur->next;temp->length = sizeof(struct block) + cur->length + temp->length;ptr = NULL;}else{temp->next = cur;ptr = NULL;}}void malloc_state(void){printf("free blocks:\n");struct block * ptr;for (ptr = free_list; ptr != NULL; ptr = ptr->next) {int i;printf("%p:", ptr);//printf("%d", ptr->length);for (int i = 0; i < ptr->length; i++) {printf("=");}printf(" ");}printf("\n");}void malloc_test(void){//定义abcdef为分配状态char* a = (char*)malloc(sizeof(char));malloc_state();char* b = (char*)malloc(sizeof(char));malloc_state();char* c = (char*)malloc(sizeof(char));malloc_state();char* d = (char*)malloc(sizeof(char));malloc_state();char* e = (char*)malloc(sizeof(char));malloc_state();char* f = (char*)malloc(sizeof(char));//按照adbfec的顺序进行释放会将所有的情况包含进去malloc_state();free(a);malloc_state();free(d);malloc_state();free(b);malloc_state();free(f);malloc_state();free(e);malloc_state();free(c);malloc_state();}int main(int argc, constchar *argv[]) {malloc_init();malloc_test();system("pause");return 0;}。

第1篇一、实验目的1. 理解操作系统内存分配的基本原理和常用算法。

2. 掌握动态分区分配方式中的数据结构和分配算法。

3. 通过编写程序，实现内存分配和回收功能。

二、实验环境1. 操作系统：Linux2. 编程语言：C语言3. 开发工具：GCC编译器三、实验原理1. 内存分配的基本原理操作系统内存分配是指操作系统根据程序运行需要，将物理内存分配给程序使用的过程。

内存分配算法主要包括以下几种：（1）首次适应算法（First Fit）：从内存空间首部开始查找，找到第一个满足条件的空闲区域进行分配。

（2）最佳适应算法（Best Fit）：在所有满足条件的空闲区域中，选择最小的空闲区域进行分配。

（3）最坏适应算法（Worst Fit）：在所有满足条件的空闲区域中，选择最大的空闲区域进行分配。

2. 动态分区分配方式动态分区分配方式是指操作系统在程序运行过程中，根据需要动态地分配和回收内存空间。

动态分区分配方式包括以下几种：（1）固定分区分配：将内存划分为若干个固定大小的分区，程序运行时按需分配分区。

（2）可变分区分配：根据程序大小动态分配分区，分区大小可变。

（3）分页分配：将内存划分为若干个固定大小的页，程序运行时按需分配页。

四、实验内容1. 实现首次适应算法（1）创建空闲分区链表，记录空闲分区信息，包括分区起始地址、分区大小等。

（2）编写分配函数，实现首次适应算法，根据程序大小查找空闲分区，分配内存。

（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。

2. 实现最佳适应算法（1）创建空闲分区链表，记录空闲分区信息。

（2）编写分配函数，实现最佳适应算法，根据程序大小查找最佳空闲分区，分配内存。

（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。

3. 实验结果分析（1）通过实验，验证首次适应算法和最佳适应算法的正确性。

（2）对比两种算法在内存分配效率、外部碎片等方面的差异。

五、实验步骤1. 创建一个动态内存分配模拟程序，包括空闲分区链表、分配函数和回收函数。

WinCE5.0中VirtualAlloc内存分配的试验代码⼀、引WINCE HELP中对VirtualAlloc的说明⾥，对第⼀个参数pAddress描述⾥写到“If the memory is being reserved, the specified address is rounded down to the next 64-KB boundary. If the memory is reserved and is being committed, the address is rounded down to the next page boundary. ” 如果不是上⾯提到这篇⽂章，我根本就不会注意到这句，因为TCPMP⾥的⽤法是：p = VirtualAlloc(NULL,n,MEM_COMMIT,PAGE_READWRITE);这第⼀个参数根本就忽略过去了。

下⾯的代码试验是基于这篇⽂章的。

其中我最担⼼的⼀点，就是⽂章是针对的，⽽⽬前我⽤的版本是5.0，⽂中所提到的⼀些限制，是否已经有所改进了呢。

⼆、测试64KB对齐的直接分配⽅式写个测试代码验证⼀下#include "stdafx.h"#include "Winbase.h"#include "stdlib.h"int WINAPI WinMain( HINSTANCE hInstance,HINSTANCE hPrevInstance,LPTSTR lpCmdLine,int nCmdShow){// TODO: Place code here.int i = 0;void* pMem = NULL;SYSTEM_INFO SystemInfo;GetSystemInfo(&SystemInfo);printf("SystemInfo.dwPageSize = %d \n", SystemInfo.dwPageSize);printf("SystemInfo.lpMinimumApplicationAddress = 0x%x \n", (int)SystemInfo.lpMinimumApplicationAddress);printf("SystemInfo.lpMaximumApplicationAddress = 0x%x \n", (int)SystemInfo.lpMaximumApplicationAddress);GlobalMemoryStatus(&MemStatus);printf("MemStatus.dwTotalPhys = %d \n", MemStatus.dwTotalPhys);printf("MemStatus. dwAvailPhys = %d \n", MemStatus.dwAvailPhys);printf("MemStatus.dwTotalVirtual = %d \n", MemStatus.dwTotalVirtual);printf("MemStatus.dwAvailVirtual = %d \n", MemStatus.dwAvailVirtual);while(1){pMem = VirtualAlloc (0, 512, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);if(!pMem){printf("alloc %d times, failed, end",i+1);break;}else{printf("0x%X ",(int)pMem);}i++;}GlobalMemoryStatus(&MemStatus);printf("MemStatus.dwTotalPhys = %d \n", MemStatus.dwTotalPhys);printf("MemStatus. dwAvailPhys = %d \n", MemStatus.dwAvailPhys);printf("MemStatus.dwTotalVirtual = %d \n", MemStatus.dwTotalVirtual);printf("MemStatus.dwAvailVirtual = %d \n", MemStatus.dwAvailVirtual);return 1;}运⾏结果：SystemInfo.dwPageSize = 4096SystemInfo.lpMinimumApplicationAddress = 0x10000SystemInfo.lpMaximumApplicationAddress = 0x7fffffffMemStatus.dwTotalPhys = 55,656,448MemStatus.dwAvailPhys = 40,923,136MemStatus.dwTotalVirtual = 33,554,4320x60000 0x70000 0x80000 0x900000xA0000 0xB0000 0xC0000 0xD0000......0x1E40000 0x1E50000 0x1E60000 0x1E700000x1E80000 0x1E90000 0x1EA0000 0x1EB0000alloc 487 times to failed, ENDMemStatus.dwTotalPhys = 55,656,448MemStatus.dwAvailPhys = 38,903,808MemStatus.dwTotalVirtual = 33,554,432MemStatus.dwAvailVirtual = 0很好，和⾼级内存管理⼀⽂描述的情况⼀样, 不过还是有些意外的发现. 我们再来仔细看⼀下(1) 所谓的next 64-KB boundary，换算成16进制也就是0x10000, 上⾯测试代码所得到的结果，的确是每次分配按0x10000递增的(2) 的确在分配不⾜512次后，内存就⽤光了，分配失败停⽌了。

内存分配实验代码-回复内存分配实验代码：探索动态内存分配的原理与过程引言在计算机程序设计中，内存分配是至关重要的一环。

动态内存分配是指在程序运行时根据需要分配和释放内存空间。

它可以帮助开发人员灵活地管理资源，提高程序的效率和性能。

本文将以实验代码为主题，一步一步解释内存分配的原理与过程，并介绍常用的动态内存分配函数。

读者可以通过这篇文章理解内存分配的机制，并在实际开发过程中更好地进行内存管理。

1. 实验代码介绍实验代码是一个简单的C语言程序，用于模拟内存分配的过程。

以下是代码的核心部分：#include <stdio.h>#include <stdlib.h>int main() {int *ptr;int size;printf("请输入需要分配的内存大小：");scanf("d", &size);ptr = (int*)malloc(size * sizeof(int)); 动态内存分配if (ptr == NULL) {printf("内存分配失败！\n");return 1;}printf("成功分配了d个int型变量的内存\n", size);printf("内存地址：0xp\n", ptr);free(ptr); 释放内存printf("释放了d个int型变量的内存\n", size);return 0;}以上代码通过调用`malloc`函数动态分配了一个指定大小的内存空间，并通过`free`函数释放了分配的内存。

通过运行这段代码，我们可以观察内存分配的过程和结果，了解内存分配的实现细节。

2. 动态内存分配原理动态内存分配是通过在程序运行时从操作系统获取一块连续的内存空间。

C语言中，我们可以通过调用`malloc`函数来进行动态内存分配。

内存分配算法实验代码好的，下面是一个简单的内存分配算法的示例代码，使用了最先适配（First Fit）算法来分配内存：```pythonclass MemoryAllocator:def __init__(self, memory_size):self.memory_size = memory_sizeself.memory_map = [0] * memory_sizedef allocate_memory(self, size):if size > self.memory_size:return -1for i in range(0, self.memory_size - size + 1):if self.memory_map[i] == 0:self.memory_map[i:i + size] = [1] * sizereturn ireturn -1def free_memory(self, address, size):if address < 0 or address + size > self.memory_size:return -1self.memory_map[address:address + size] = [0] * size# 示例用法memory_allocator = MemoryAllocator(1024)address = memory_allocator.allocate_memory(128)print("分配的内存地址：", address)memory_allocator.free_memory(address, 128)```在上述示例中，我们定义了一个 `MemoryAllocator` 类，它使用最先适配算法来管理内存分配。

类中的 `allocate_memory` 方法用于分配指定大小的内存，它会遍历内存映射数组，找到第一个连续的空闲区域，并将其分配给请求的内存。

#include<stdio.h>#include<stdlib.h>#define NUM 128typedef struct{ int zm_no;int cd_no;int jl_no;}disk;void disp(int m[]){int i;printf("位?示º?图ª?：êo\n");for(i=0;i<NUM;i++){if(i%8==0)printf("\n");printf("%d\t",m[i]);}printf("\n");}void creat(int m[]){ int j=0,zh,wh;int keyong=0;while(j<NUM){ if(m[j]==0){ keyong=1;m[j]=1;disk a;a.zm_no=j/8;a.cd_no=(j%8)/4;a.jl_no=(j%8)%4;zh=a.zm_no;wh=a.cd_no*4+a.jl_no;printf("柱¨´面?号?\t磁ä?道̨¤号?\t物?理¤¨ª记?录?号?\n");printf("%d\t%d\t%d\n",a.zm_no,a.cd_no,a.jl_no);printf("字Á?号?\t位?号?\n");printf("%d\t%d\n",zh,wh);break;}else j++;}if(keyong==0){ printf("无T可¨¦用®?磁ä?盘¨¬块¨¦！ê?\n");printf("\n");}}void del(int m[]){ disk b;int zm_no,cd_no,jl_no,j;printf("输º?入¨?待äy回?收º?磁ä?盘¨¬块¨¦的Ì?柱¨´面?号?，ê?磁ä?道̨¤号?，ê?物?理¤¨ª记?录?号?：êo");scanf("%d%d%d",&b.zm_no,&b.cd_no,&b.jl_no);j=8*b.zm_no+4*b.cd_no+b.jl_no;if(m[j]==0)printf("已°?是º?空?闲D状Á¡ä态¬?，ê?不?必À?回?收º?！ê?\n");else{ m[j]=0;disp(m);}}int main(){int i;int input=1;int m[NUM]={ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1};while(input!=0){ printf("1.当Ì¡À前¡ã磁ä?盘¨¬状Á¡ä态¬? 2.申¦¨º请?磁ä?盘¨¬块¨¦ 3.回?收º?磁ä?盘¨¬块¨¦ 0.退ª?出?\n");scanf("%d",&input);switch(input){ case 1: disp(m);break;case 2: creat(m);break;case 3: del(m);break;default:break;}}system("pause");return 0;}。

#include<stdio.h>#include<stdlib.h>#define FF 0#define BF 1typedef struct JCB//作业结构体{int ads;int size;int id;struct JCB *next;}JCB,*JCBStr;typedef struct{JCBStr front;JCBStr end;}Link;Link Ready,Free;//已分配和未分配队列int Type;//内存分配操作int Size;//内存总大小int Fit;//内存分配方法int adress;//临时地址void build(JCBStr &q)//创建空链节{q = (JCBStr) malloc(sizeof(JCB));q->next = NULL;}void create(JCBStr &q,int id)//创建一个JCB {build(q);q->id = id;q->size = Size;q->ads = adress;}void Init()//队列初始化{build(Ready.front);Ready.end = Ready.front;build(Free.front);Free.end = Free.front;JCBStr q;create(q,0);Free.front->next = q;Free.end = q;q->ads = 0;}void lookFree(JCBStr &q)//查看空闲队列{JCBStr s,t;s = Free.front;t = Free.front->next;while(t){if(t->size>=Size){adress = t->ads;break;}s = t;t = t->next;}q = t;if(t && Fit == BF){s->next = t->next;if(t == Free.end)Free.end = s;}}void lookReady(JCBStr &q,int id)//查看并取出链节{JCBStr s;s = Ready.front;q = Ready.front->next;while(q){if(q->id == id)break;s = q;q = q->next;}if(!q) return;q->id = 0;s->next = q->next;if(q == Ready.end)Ready.end = s;}void insertReadyLink(JCBStr &q)//插入分配队列{Ready.end->next = q;Ready.end = q;}void InsertFreeBF(JCBStr &q)//根据内存空间排序插入{JCBStr s,t;t = Free.front;s = Free.front->next;while(s){if(s->size <= q->size){t = s;s = s->next;}else{break;}}t->next = q;q->next = s;if(t == Free.end)Free.end = q;}void InsertFreeFF(JCBStr &q)//根据内存地址排序插入{JCBStr s,t;t = Free.front;s = Free.front->next;while(s){if(s->ads < q->ads){t = s;s = s->next;}else{break;}}t->next = q;q->next = s;if(t == Free.end)Free.end = q;}void hebinFF(JCBStr &q,JCBStr &node,int type)//快速回收查找方法{JCBStr s,t;s = Free.front;t = s->next;switch(type){case 0:while(t){if(t->ads + t->size < q->ads){s = t;t = t->next;}else if(t->ads+t->size == q->ads){node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}else{node = NULL;break;}}break;case 1:while(t){if(q->ads+q->size < t->ads){s = t;t = t->next;}else if(q->ads+q->size == t->ads){node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}else{node = NULL;break;}}break;}}void hebinBF(JCBStr &q,JCBStr &node,int type)//最优回收{JCBStr s,t;node = NULL;s = Free.front;t = s->next;switch(type){case 0:while(t){if(t->ads+t->size != q->ads){s = t;t = t->next;}else{node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}}break;case 1:while(t){if(q->ads+q->size != t->ads){s = t;t = t->next;}else{node = t;s->next = t->next;if(t == Free.end)Free.end = s;break;}}break;}}void hebin(JCBStr &node,JCBStr &node1,int type)//回收合并方法{if(node1!=NULL){switch(type){case 0:node->ads -= node1->size;node->size +=node1->size;free(node1);break;case 1:node->size += node1->size;free(node1);break;}}}int buildLink(int id,int type,int fit) //内存分配回收{JCBStr node,node1;switch(type){case 1://内存分配lookFree(node);//查看满足空间的内存，不取出if(!node) return 0;switch(fit){case FF:create(node1,id);//创建Ready节点insertReadyLink(node1);//放入队列node->ads += Size;//空闲节点地址增加node->size -=Size;//节点空间减少break;case BF:create(node1,id);//创建Ready节点insertReadyLink(node1);//放入队列node->ads += Size;//空闲节点地址增加node->size -=Size;//节点空间减少InsertFreeBF(node);//按空间大小排序插入队列break;}break;case 2://内存回收lookReady(node,id);if(!node) return 0;switch(fit){case FF://合并hebinFF(node,node1,0);hebin(node,node1,0);hebinFF(node,node1,1);hebin(node,node1,1);//直接插入InsertFreeFF(node);break;case BF://合并hebinBF(node,node1,0);hebin(node,node1,0);hebinBF(node,node1,1);hebin(node,node1,1);//排序插入空闲队列InsertFreeBF(node);break;}break;}return 1;}//输出void print(Link Q){JCBStr p;p=Q.front->next;if(p==NULL)printf("# 队列为空!#\n");//队列为空else{printf("# 分区号起始大小#\n");while(p!=NULL) //否则显示队列中所有元素{printf(" %d %d %d \n",p->id,p->ads,p->size);p=p->next;}}}int main(){int id,flag;printf("##########################################\n");printf("# 请输入总内存大小#\n");printf("##########################################\n");scanf("%d",&Size);Init();//printf("########################################\n");printf("#选择内存分配策略，0 ：首次适应算法（first fit）;1 :最佳适应算法（best fit）#\n");//printf("########################################\n");scanf("%d",&Fit);//printf("########################################\n");printf("#选择内存操作，1 :分配内存，2 :内存回收,0 退出程序！#\n");//printf("# #\n");while(scanf("%d",&Type),Type!=0){switch(Type){case 1:printf("请输入内存分配编号和所需内存大小！\n");scanf("%d%d",&id,&Size);flag = buildLink(id,Type,Fit);if(flag == 0)printf("内存空间不足！\n");else{printf("回收成功！已分配内存为：\n");print(Ready);printf("剩余内存为：\n");print(Free);}break;case 2:printf("请输入内存回收编号！\n");scanf("%d",&id);flag = buildLink(id,Type,Fit);if(flag == 0)printf("此编号不存在！\n");else{printf("回收成功！已分配内存为：\n");print(Ready);printf("剩余内存为：\n");print(Free);}break;}//printf("########################################\n");printf("#选择内存操作，1 :分配内存，2 :内存回收,0 退出程序！#\n");// printf("#0 退出程序！#\n");//printf("########################################\n");}return 0;}。

西安邮电大学（计算机学院）课内实验报告实验名称：内存管理专业名称：软件工程班级：学生姓名：学号（8位）：指导教师：实验日期：实验五：进程1.实验目的通过深入理解区管理的三种算法，定义相应的数据结构，编写具体代码。

充分模拟三种算法的实现过程，并通过对比，分析三种算法的优劣。

（1）掌握内存分配FF，BF，WF策略及实现的思路；（2）掌握内存回收过程及实现思路；（3）参考给出的代码思路，实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。

2.实验要求：1）掌握内存分配FF，BF，WF策略及实现的思路；2）掌握内存回收过程及实现思路；3）参考本程序思路，实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。

3.实验过程：创建进程：删除其中几个进程：(默认以ff首次适应算法方式排列)Bf最佳适应算法排列方式：wf最差匹配算法排列方式：4.实验心得：这次实验实验时间比较长，而且实验指导书中对内存的管理讲的很详细，老师上课的时候也有讲的很详细，但是代码比较长，刚开始的时候也是不太懂，但是后面经过和同学一起商讨，明白几种算法的含义：①首次适应算法。

在采用空闲分区链作为数据结构时，该算法要求空闲分区链表以地址递增的次序链接。

在进行内存分配时，从链首开始顺序查找，直至找到一个能满足进程大小要求的空闲分区为止。

然后，再按照进程请求内存的大小，从该分区中划出一块内存空间分配给请求进程，余下的空闲分区仍留在空闲链中。

②循环首次适应算法。

该算法是由首次适应算法演变而形成的，在为进程分配内存空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直至找到第一个能满足要求的空闲分区，并从中划出一块与请求的大小相等的内存空间分配给进程。

③最佳适应算法将空闲分区链表按分区大小由小到大排序，在链表中查找第一个满足要求的分区。

④最差匹配算法将空闲分区链表按分区大小由大到小排序，在链表中找到第一个满足要求的空闲分区。

实验六：主存空间的分配与回收(题目及实例代码(基于java))实验目的：编程模拟主存空间的分配与回收，采用最先适应算法分配分区实验要求：基于现有程序，补全分配与回收部分程序实例代码：import java.util.LinkedList;import java.util.Scanner;public class DArea {public static LinkedList<Area> array1 = new LinkedList();public static void main(String args[]){array1.add(new Area(40,16));array1.add(new Area(78,24));array1.add(new Area(150,50));outArea();int addr=0;int arealong=0;System.out.println("请选择\n1:申请分区\n2:释放分区\n0:退出");Scanner in=new Scanner(System.in);int t=in.nextInt();while(t!=0){if(t==1){System.out.println("请输入申请分区长度");arealong=in.nextInt();int size=array1.size();int i=0;if(size==0)System.out.println("没有空间");else{for(i=0;i<size;i++){if(array1.get(i).areaLong>arealong){array1.get(i).addr=array1.get(i).addr+arealong;array1.get(i).areaLong=array1.get(i).areaLong-areal ong;System.out.println("申请空间分配成功");break;}elseif(array1.get(i).areaLong==arealong){array1.remove(i);System.out.println("申请空间分配成功");break;}}if(i==size)System.out.println("没有满足要求的分区");}}else if(t==2){System.out.println("请输入释放分区起始地址及长度");addr=in.nextInt();arealong=in.nextInt();int size=array1.size();int i=0;if(size==0)array1.add(new Area(addr, arealong));else{for(i=0;i<size;i++){if(array1.get(i).addr>addr)break;}if(i==0){if((addr+arealong)<array1.get(i).addr)array1.addFirst(newArea(addr,arealong));elseif((addr+arealong)==array1.get(i).addr){array1.get(i).addr=addr;array1.get(i).areaLong=arealong+array1.get(i).areaL ong;}else{System.out.println("释放空间数据有误");}}else if(i>=size){if((array1.get(i-1).addr+array1.get(i-1).areaLong)< addr)array1.add(newArea(addr,arealong));elseif((array1.get(i-1).addr+array1.get(i-1).areaLong)==a ddr){array1.get(i-1).areaLong=arealong+array1.get(i-1).a reaLong;}else{System.out.println("释放空间数据有误");}}else{if((array1.get(i-1).addr+array1.get(i-1).areaLong)= =addr&&(addr+arealong)==array1.get(i).addr){array1.get(i-1).areaLong=arealong+array1.get(i-1).a reaLong+array1.get(i).areaLong;array1.remove(i);}elseif((array1.get(i-1).addr+array1.get(i-1).areaLong)==a ddr){array1.get(i-1).areaLong=arealong+array1.get(i-1).a reaLong;}elseif((addr+arealong)==array1.get(i).addr){array1.get(i).addr=addr;array1.get(i).areaLong=arealong+array1.get(i).areaL ong;}elseif((array1.get(i-1).addr+array1.get(i-1).areaLong)>ad dr&&(addr+arealong)<array1.get(i).addr){array1.add(i,newArea(addr,arealong));}else{System.out.println("释放空间数据有误");}}}}outArea();System.out.println("请选择\n1:申请分区\n2:释放分区\n0:退出");t=in.nextInt();}}public static void outArea(){if(array1.size()==0)System.out.println("内存空间已全部分配");else{System.out.println("内存空间可用情况：");System.out.println("起始地址\t分区长度");for(int i=0;i<array1.size();i++){System.out.println(array1.get(i).addr+"\t"+array1.g et(i).areaLong);}}}}class Area {int addr;int areaLong;public Area(int addr, int areaLong) {this.addr = addr;this.areaLong = areaLong;}public int getAddr() {return addr;}public void setAddr(int addr) {this.addr = addr;}public int getAreaLong() {return areaLong;}public void setAreaLong(int areaLong) { this.areaLong = areaLong;}}实例运行：内存空间可用情况：起始地址分区长度40 1678 24150 50请选择1:申请分区2:释放分区0:退出1请输入申请分区长度30申请空间分配成功内存空间可用情况：起始地址分区长度40 1678 24180 20请选择1:申请分区2:释放分区0:退出2请输入释放分区起始地址及长度2020内存空间可用情况：起始地址分区长度20 3678 24180 20请选择1:申请分区2:释放分区0:退出。