⑴ 如何用c语言实现动态分区分配算法的模拟
#define_CRT_SECURE_NO_WARNINGS1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#defineN10000
intn1;//空闲分区的个数
intn2;//作业区的个数
structkongxian
{
intstart;//起址
intend;//结束
intlength;//长度
}kongxian[N];
structzuoye
{
intstart;//起址
intend;//结束
intlength;//长度
}zuoye[N];
intcmp1(constvoid*a,constvoid*b)
{
return(*(structkongxian*)a).start-(*(structkongxian*)b).start;
}
intcmp2(constvoid*a,constvoid*b)
{
return(*(structzuoye*)a).start-(*(structzuoye*)b).start;
}
voidinit()
{
n1=1;//初始时只有一个空闲区
n2=0;//初始没有作业
kongxian[0].start=0;
kongxian[0].end=511;
kongxian[0].length=512;
}
voidprint1()//打印空闲分区
{
inti;
for(i=0;i<n1;i++)
printf("空闲分区ID:%d起止:%d结束:%d长度:%d ",i,kongxian[i].start,kongxian[i].end,kongxian[i].length);
}
voidprint2()//打印作业分区
{
inti;
for(i=0;i<n2;i++)
printf("作业分区ID：%d起止:%d结束:%d长度:%d ",i,zuoye[i].start,zuoye[i].end,zuoye[i].length);
}
intmain()
{
inti,j,t,len,flag,id;
intfront,middle,behind;
intt1,t2;
init();
print1();
printf("输入1装入新作业，输入0回收作业，输入-1结束 ");
while(scanf("%d",&t)!=EOF)
{
if(t==1)//装入新作业
{
printf("请输入作业的占用空间的长度");
scanf("%d",&len);
flag=0;
for(i=0;i<n1;i++)
{
if(kongxian[i].length>=len)//首次适应算法
{
flag=1;
break;
}
}
if(!flag)
{
printf("内存分配失败 ");
}
else
{
//将该作业加入作业区里
zuoye[n2].start=kongxian[i].start;
zuoye[n2].end=zuoye[n2].start+len;
zuoye[n2].length=len;
n2++;//作业数加1
if(kongxian[i].length==len)//该分区全部用于分配，删除该空闲分区
{
for(j=i;j<n1-1;j++)
{
kongxian[j].start=kongxian[j+1].start;
kongxian[j].end=kongxian[j+1].end;
kongxian[j].length=kongxian[j+1].length;
}
n1--;
}
else//该空闲分区部分用于分配，剩余的留在空闲分区中
{
kongxian[i].start+=len;
kongxian[i].length-=len;
}
}
}
elseif(t==0)
{
printf("输入要回收的作业ID");
scanf("%d",&id);
front=middle=behind=0;
for(i=0;i<n1;i++)
{
if(kongxian[i].start>zuoye[id].end)
break;
if(kongxian[i].end==zuoye[id].start)//待回收的作业上面有空闲分区
{
front=1;
t1=i;
}
if(kongxian[i].start==zuoye[id].end)//待回收的作业下面有空闲分区
{
behind=1;
t2=i;
}
}
if(!front&&!behind)//待回收的作业上下均没有空闲分区
{
kongxian[n1].start=zuoye[id].start;
kongxian[n1].end=zuoye[id].end;
kongxian[n1].length=zuoye[id].length;
n1++;//空闲分区增加一个
qsort(kongxian,n1,sizeof(structkongxian),cmp1);//插入空闲分区后排序
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
if(front&&behind)//待回收的作业上下均有空闲分区
middle=1;
if(front&&!middle)//合并待回收的作业和上面的空闲分区
{
kongxian[t1].end+=zuoye[id].length;
kongxian[t1].length+=zuoye[id].length;
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
if(middle)//合并待回收的作业和上下的空闲分区
{
kongxian[t1].end=kongxian[t2].end;
kongxian[t1].length+=(zuoye[id].length+kongxian[t2].length);
//删除空闲分区t2
for(j=t2;j<n1-1;j++)
{
kongxian[j].start=kongxian[j+1].start;
kongxian[j].end=kongxian[j+1].end;
kongxian[j].length=kongxian[j+1].length;
}
n1--;
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
if(behind&&!middle)//合并待回收的作业和下面的分区
{
kongxian[t2].start-=zuoye[id].length;
kongxian[t2].length+=zuoye[id].length;
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
}
else
{
printf("操作结束 ");
break;
}
print1();
print2();
}
return0;
}
⑵ c语言中什么是动态分配内存
就是当你的程序中使用数组或者是指针变量的时候，为了能够合理地利用内存空间来进行程序运行，自动开辟内存在栈区，最后用完这些内存再将其回收的方式。动态内存分配不像静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要来分配，分配大小就是程序要求大小。
一般在C语言中使用malloc和free方法
头文件为malloc.h或者是stdlib.h，
⑶ 求知道动态分区最佳适应算法模拟的c语言代码。简单点的短点的
动态分区分配算法: 1.首次适应算法(FF/first fit) 2.循环首次适应算法(next fit) 3.最佳适应算法(best fit) 从最小的分区开始分配 4.最坏适应算法(worst fit) 从最大的分区开始分配 5.快速适应算法/分类搜索法(quick fit) 将空闲分区根据其容量的大小进行分类
⑷ C语言中动态内存分配函数的用法及作用（比如malloc,calloc,realloc等）
先举个例子：某用户需要一个将任意多个整数按大小排序的程序。（在计算机文件夹中，当文件很多时经常用到排序）
1。若不用动态分配内存，那就定义一个超大的数组吧！问题是，如果用户不需要那么大，不就浪费了？如果定义的数组还不够大，不就不能满足需求了？
2。如果用动态分配，就解决上述问题了。当你需要多大内存时，就给你多大——如果有的话——这就是动态分配的意义。
现在看上述问题的代码，我调试过的：
----------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h> /* calloc、exit需要声明头文件 */
void main()
{
int n,*p,i,j,m;
printf("本程序可对任意个整数排序;\n");
printf("请输入整数的总个数: ");
scanf("%d",&n);
p=(int *)calloc(n,sizeof(int)); /* calloc函数的使用 */
if(p==0) {
printf("分配失败!\n");
exit(1); /* 当分配失败时，exit可以终止程序 */
}
printf("请输入这些整数:\n");
for(i=0;i<n;i++)
scanf("%d",p+i); /* 利用指针移位的方法赋值 */
for(i=1;i<n;i++) /* 冒泡排序法 */
{
for(j=0;j<n-i;j++)
if(*(p+j)>*(p+j+1))
{
m=*(p+j);
*(p+j)=*(p+j+1);
*(p+j+1)=m;
}
}
printf("将这些整数从小到大排列输出为:");
for(i=0;i<n;i++)
{
if(i%5==0) printf("\n"); /* 每隔5个数换行 */
printf(" %11d;",*(p+i));
/* 为了整齐，每个数占11个字符，当数字很多时这很重要 */
}
printf("\n");
free(p); /* 释放空间 */
}
----------------------------------------------------------------------
调用calloc函数时，calloc(n,sizeof(int))表示请求n个连续的、每个长度为整型的空间，若成功返回这些空间的首地址。（int *）表示将这个地址放在指针中。到此为止，就可以用指针来对分配到的空间操作了。注意，最后一定要用free函数释放申请到的空间，否则这部分空间会一直占着。
malloc、calloc、realloc的用法（以上述问题为例）及区别：
1。malloc(n*sizeof(int)) /* 请求n个连续的、每个长度为整型的空间，若成功返回这些空间的首地址，失败返回0 */
2。calloc(n,sizeof(int)) /* 请求n个连续的、每个长度为整型的空间，若成功返回这些空间的首地址并将每个空间赋值为0，失败返回0 */
3。realloc(p,sizeof(int)*n) /* 给一个已经分配了地址的指针重新分配空间,参数p为原有的空间地址,sizeof(int)*n是重新申请的地址长度，用于分配不足的时候。个人觉得没用——不够就找到原分配处改大一点不就行了？！ */
我能说得只有这些了，有些东西看起来麻烦，当你小试一下就会发现，不过如此嘛！学C要多练、多思，不怕麻烦。不知道您学了递归没有？有个经典的“汉诺塔”问题，那家伙——得整死人啊！到现在我还一知半解的……
希望我的回答对您有帮助！
⑸ C语言中的动态内存分配的用法举例
1、malloc函数：其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。
2、free函数：由于内存区域总是有限的，不能不限制地分配下去，而且一个程序要尽量节省资源，所以当所分配的内存区域不用时，就要释放它，以便其它的变量或者程序使用。这时我们就要用到free函数。
3、calloc函数：其作用是在内存的动态存储区中分配n个长度为 size 的连续空间。函数返回一个指向分配区域的起始位置的指针；如果分配不成功，则返回NULL。
(5)动态分区存储管理算法c语言扩展阅读：
函数运算符：
new
运算符new用于向系统申请动态存储空间，并把首地址作为运算结果，它的使用形式为：
指针变量=new 数据类型；
例如：
int *p=new int
该语句的作用是会用new从内存中申请了一个int型变量（4个字节），并将该变量的首地址赋给指针变量p。
new所建立的变量的初始值是任意的，也可在用new分配内存的同时进行初始化。使用形式为：
指针变量=new 数据类型（初始值）。
delete
堆内存可按照要求进行分配，程序对内存的需求量随时会发生变化，有时程序在运行种可能会不再需要由new分配的内存空间，而且程序还未运行结束，这时就需要把先前占用的内存空间释放给堆内存，以后重新分配，供程序的其他部分使用。运算符delete用于释放new分配的内存空间，删除建立的对象，它的使用形式为：
delete指针变量；
其中的指针变量中保存着new分配的内存的首地址。
⑹ 如何用C语言做自动动态存储数据
这个方法是有的。
（注：一般用结构体判断，所以下面的解释都是结构体型的。首先说明，我定义了一个结构体
struct stu{ char ch[maxlen];struct stu *next;};）
首先声明头文件malloc.h，即#included<malloc.h>
随后使用动态内存分配， 比如int *p;p=(struct stu*)malloc(sizeof(struct stu*) * m)。
-------以上是开辟内存单元
-------------------------------------------
接下来说说如何扩充内存单元
你讲：“如何用C语言做自动动态存储数据”，其实所谓的“自动动态存储数据”，关键是2点
1、怎么动态存储
2、怎么在存储单元不够用时扩充。
对于第1个问题，用链式结构就好了，这很简单，具体看看有关于介绍链表的书就好。不推荐《数据结构》，推荐《算法与数据结构》或《数据结构与算法分析》。
针对第2个问题，由于不知道你水平如何，所以现在只提一种简单有效的方法，那就是用if()语句做判断，例如前面的*p：if(p==NULL)
{ p2=(struct stu*)malloc(sizeof(struct stu*) * m*2);//<-内存扩大两倍
p->ch[maxlen]=p2->ch[maxlen];
}
这样就好了。（注意：maxlen这里在具体实现代码时要变。）
如果你觉得我的描述有点简单，咱们还可以继续讨论。如果觉得难了点，那你真的要好好了解数据结构与算法之间的关系了。
加油吧朋友！！！！！！！
⑺ C语言如何动态分配存储空间
#include <stdio.h>
#include <malloc.h>
#include <memory.h>
#include <string.h>
/* 工程功能:简单学生管理系统，
包含插入，删除，修改操作，采用链表数据模型
*/
typedef struct student{
int Num;//学号
char name[12];//姓名
int age;//年龄
struct student* pNext;//指向下一条记录的指针
}STUDENT,*PSTUDENT;
#define LEN sizeof(STUDENT)
PSTUDENT pHeader,pNail;//头结点指针,尾结点指针
int n=0;//学生信息条数
void PrintMenu();//打印操作菜单
bool ExistStudent(int Num);//是否存在学号为Num的学生信息，有则返回true,否则,false
void InsertInfo();//插入学生信息到末尾
bool DeleteInfo(int Num);//删除学号为Num的学生信息
bool UpdateInfo(int Num,PSTUDENT pNewInfo);//修改学号为Num的学生信息为pNewInfo指向的内容
void PrintInfo();//打印所有学生信息
int main()
{
PrintMenu();
int iSel=0;
while(1)
{
printf("输入操作选择:");
scanf("%d",&iSel);
switch(iSel)
{
case 0:
return 0;
case 1:
PrintInfo();
continue;
case 2:
InsertInfo();
continue;
case 3:
{
int num=0;
printf("输入要删除的学生学号:");
scanf("%d",&num);
if(DeleteInfo(num))
printf("删除成功!\n");
else
printf("删除失败!\n");
continue;
}
case 4:
{
int num=0;
printf("输入要修改的学生学号:");
scanf("%d",&num);
STUDENT stu={0};
printf("输入该学生的新信息(空格分隔):");
scanf("%d%s%d",&stu.Num,&stu.name,&stu.age);
if(UpdateInfo(num,&stu))
printf("修改成功!\n");
else
printf("修改失败!\n");
continue;
}
continue;
default:
continue;
}
}
return 0;
}
void PrintMenu()
{
printf("******操作菜单******\n");
printf("* 1. 打印学生信息\n");
printf("* 2. 添加学生信息\n");
printf("* 3. 删除学生信息\n");
printf("* 4. 修改学生信息\n");
printf("* 0. 退出系统\n");
printf("*********************\n");
}
void InsertInfo()
{
//pCur为当前输入的信息结构指针,pNail为前一个学生信息结构指针
PSTUDENT pCur;
printf("请输入学生记录(各元素用空格分隔,输入学号为0时停止)\n");
while(true)
{
pCur = (PSTUDENT)malloc(LEN);
memset(pCur,NULL,LEN);
printf("==>:");
scanf("%d%s%d",&pCur->Num,pCur->name,&pCur->age);
if(pCur->Num==0)
break;
if(ExistStudent(pCur->Num))
{
printf("该学生信息已经存在！\n");
break;
}
if(n==0)
{
//初始化头结点和保存前一个结构指针
pNail=pHeader=pCur;
pHeader->pNext=NULL;
}
else
{
pNail->pNext=pCur;
pNail=pCur;
pCur->pNext=NULL;
}
n++;
}
}
bool DeleteInfo(int Num)
{
PSTUDENT pStu=pHeader;
if(!pStu)
return false;
for(pStu;pStu!=NULL;pStu=pStu->pNext)
{
if(Num==pStu->Num)
{
//要删除的为头结点
pHeader=pStu->pNext;
return true;
}
else if(pStu->pNext&&Num==pStu->pNext->Num)
{
pStu->pNext=pStu->pNext->pNext;
return true;
}
}
return false;
}
bool UpdateInfo(int Num,PSTUDENT pNewInfo)
{
PSTUDENT pStu=pHeader;
if(!pStu)
return false;
if(Num!=pNewInfo->Num&&ExistStudent(pNewInfo->Num))
return false;
for(pStu;pStu!=NULL;pStu=pStu->pNext)
{
if(Num==pStu->Num)
{
pStu->Num=pNewInfo->Num;
memset(pStu->name,0,sizeof(pStu->name));
strcpy(pStu->name,pNewInfo->name);
pStu->age=pNewInfo->age;
return true;
}
}
return true;
}
void PrintInfo()
{
PSTUDENT pStu=pHeader;
if(!pStu)
{
printf("没有学生信息!\n");
return;
}
for(pStu;pStu!=NULL;pStu=pStu->pNext)
printf("学号:%d 姓名:%s 年龄:%d\n",pStu->Num,pStu->name,pStu->age);
}
bool ExistStudent(int Num)
{
PSTUDENT pStu=pHeader;
if(!pStu)
return false;
for(pStu;pStu!=NULL;pStu=pStu->pNext)
{
if(Num==pStu->Num)
return true;
}
return false;
}
⑻ C语言中的动态存储管理的命令的作用是什么
malloc()是动态内存分配函数，用来向系统请求分配内存空间。当无法知道内存具体的位置时，想要绑定真正的内存空间，就要用到malloc()函数。因为malloc只分配内存空间，并不能对分配的空间进行初始化，所以申请到的内存中的值是随机的，经常会使用memset()进行置0操作后再使用。
⑼ 用C语言实现内存动态模拟分区~
建议你先从简单动态数组的分配和释放开始。
在c语言中，分配可通过malloc和new函数实现，而释放相对应的是free、delete
调用格式为
int
*a=（ElemType）malloc（n*sizeof（ElemType））或者
int
*a=new
int[n]；释放时，直接free（a）或者delete（a）就行了