⑴ 如何用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）就行了