操作系统: 最佳适配算法和邻近适配算法的模拟实现（内存分配算法）

实现动态分区的分配算法。

(1) 最佳适配算法：选择内存空闲块中最适合进程大小的块分配。

(2) 邻近适配算法：从上一次分配的地址开始查找符合要求的块，所查找到的第一个满足要求的空闲块就分配给进程。

模拟添加进程的时候，假定内存是一块完整的空闲区，对于算法(1)来说，分配的时候遍历所有的空闲内存块，找出其中最适合的一块，注意此时内存分区的总块数可能已经发生了变化；

对于算法(2)来说，则需要从上次分配的内存块（使用变量记录即可）接着向下找到第一个满足条件的块即可,内存分区的总块可能也已经发生了变化。

模拟删除进程（释放内存）的时候，则需要注意如果当前内存块的上下有空闲块，则需要将其合并为一整个空闲块，也需要注意内存总块的数量变化。

最佳适配算法

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <vector>  
3. #include <string>  
4. #include <cstring>  
5. #include <map>  
6. #include <algorithm>  
7. using namespace std;  
8. struct node  
9. {  
10.     int num;  
11.     int is_data;  
12. };  
13. int main()  
14. {  
15.     vector<node> cluster;  
16.     vector<node> TTemp;  
17.     map <int,int> mp;  
18.     mp.clear();  
19.     node temp;  
20.     int R_num;  
21.     int curnum;  
22.       
23.     temp.is_data=0;  
24.     temp.num=10;  
25.     cluster.push_back(temp);  
26.      
27.     cout<<"请使用add命令添加一个进程，delete命令删除一个进程!"<<endl;  
28.     while(1)  
29.     {  
30.        string s;  
31.        cin>>s;  
32.        if(s=="add")  
33.        {  
34.         cout<<"请输入进程号及其的大小"<<endl;  
35.         cin>>R_num>>curnum;  
36.   
37.         int flag=0;  
38.         int curIndex;  
39.       
40.         int cmp=11;  
41.         for(int i=0;i<cluster.size();i++)  
42.         {  
43.             if(cluster[i].is_data==0&&cluster[i].num>=curnum)  
44.             {  
45.                 flag=1;  
46.                 if(cluster[i].num-curnum<cmp)  
47.                 {  
48.                     curIndex=i;  
49.                     cmp=cluster[i].num-curnum;  
50.                 }  
51.             }  
52.         }  
53.         if(flag)  
54.         {  
55.             cluster[curIndex].is_data=1;  
56.             mp[R_num]=curIndex;  
57.   
58.             node op;  
59.             TTemp.clear();  
60.             int is_flag=0;  
61.             if(cluster[curIndex].num>curnum)  
62.             {  
63.                 op.is_data=0;  
64.                 op.num=cluster[curIndex].num-curnum;  
65.                 is_flag=1;  
66.             }  
67.   
68.         for(int i=0;i<cluster.size();i++)  
69.         {  
70.             if(i==curIndex)  
71.             {  
72.                 cluster[curIndex].num=curnum;  
73.                 TTemp.push_back(cluster[curIndex]);  
74.                 mp[R_num]=i;  
75.   
76.                 if(is_flag)  
77.                 {  
78.                     TTemp.push_back(op);  
79.                 }  
80.             }  
81.             else  
82.             TTemp.push_back(cluster[i]);  
83.         }  
84.           
85.         cluster.swap(TTemp);  
86.           
87.           
88.         for(int i=0;i<cluster.size();i++)  
89.         cout<<"大小 "<<cluster[i].num<<"  是否分配 "<<cluster[i].is_data<<endl;  
90.           
91.     }  
92.     else  
93.     {  
94.         cout<<"内存不足！"<<endl;  
95.     }  
96.  }  
97.             
98.      else if(s=="delete")  
99.      {  
100.             int deletenum;  
101.             cout<<"请输入删除的进程："<<endl;  
102.             cin>>deletenum;  
103.   
104.         int i=mp[deletenum];  
105.         while(--i>=0 && cluster[i].is_data==0)  
106.         {  
107.           
108.         }  
109.         int j=mp[deletenum];  
110.         while(++j<cluster.size() && cluster[j].is_data==0)  
111.         {  
112.           
113.         }  
114.   
115.         node kk;  
116.         kk.num=0;  
117.         for(int e=i+1;e<=j-1;e++)  
118.         {  
119.             kk.num+=cluster[e].num;  
120.         }     
121.         kk.is_data=0;  
122.   
123.         TTemp.clear();  
124.         for(int p=0;p<cluster.size();)  
125.         {  
126.             if(p==i+1)  
127.             {  
128.                 p=j;  
129.                 TTemp.push_back(kk);  
130.             }  
131.             else{  
132.                 TTemp.push_back(cluster[p]);  
133.                 p++;  
134.         }  
135.           
136.     }  
137.         cluster.swap(TTemp);  
138.       
139.         for(int i=0;i<cluster.size();i++)  
140.         cout<<"大小 "<<cluster[i].num<<"  是否分配 "<<cluster[i].is_data<<endl;  
141.   
142.        }  
143.    }  
144.     return 0;  
145. }  

邻近适配算法

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <vector>  
3. #include <string>  
4. #include <cstring>  
5. #include <map>  
6. #include <algorithm>  
7. using namespace std;  
8. struct node  
9. {  
10.     int num;  
11.     int is_data;  
12. };  
13. int main()  
14. {  
15.     vector<node> cluster;  
16.     vector<node> TTemp;  
17.     map <int,int> mp;  
18.     mp.clear();  
19.     node temp;  
20.     int R_num;  
21.     int curnum;  
22.     int last_ID=0;  
23.     temp.is_data=0;  
24.     temp.num=10;  
25.     cluster.push_back(temp);  
26.      
27.     cout<<"请使用add命令添加一个进程，delete命令删除一个进程!"<<endl;  
28.     
29.     while(1)  
30.     {  
31.        string s;  
32.        cin>>s;  
33.        if(s=="add")  
34.        {  
35.         cout<<"请输入进程号及其的大小"<<endl;  
36.         cin>>R_num>>curnum;  
37.   
38.         int flag=0;  
39.         int curIndex;  
40.           
41.         //for(int i=beg_pos;i<cluster.size();i++)  
42.         int i=last_ID+1;  
43.         while(1)  
44.         {  
45.             if(i==cluster.size())  
46.             i=0;  
47.             if(cluster[i].is_data==0&&cluster[i].num>=curnum)  
48.             {  
49.                 flag=1;  
50.                 curIndex=i;  
51.                 break;  
52.             }  
53.             i++;  
54.         }  
55.         if(flag)  
56.         {  
57.             cluster[curIndex].is_data=1;  
58.             mp[R_num]=curIndex;  
59.   
60.             node op;  
61.             TTemp.clear();  
62.             int is_flag=0;  
63.             if(cluster[curIndex].num>curnum)  
64.             {  
65.                 op.is_data=0;  
66.                 op.num=cluster[curIndex].num-curnum;  
67.                 is_flag=1;  
68.             }  
69.   
70.         for(int i=0;i<cluster.size();i++)  
71.         {  
72.             if(i==curIndex)  
73.             {  
74.                 cluster[curIndex].num=curnum;  
75.                 TTemp.push_back(cluster[curIndex]);  
76.                 mp[R_num]=i;  
77.                 last_ID=i;   
78.                 if(is_flag)  
79.                 {  
80.                     TTemp.push_back(op);  
81.                 }  
82.             }  
83.             else  
84.             TTemp.push_back(cluster[i]);  
85.         }  
86.           
87.         cluster.swap(TTemp);  
88.           
89.         for(int i=0;i<cluster.size();i++)  
90.         cout<<"大小 "<<cluster[i].num<<"  是否分配 "<<cluster[i].is_data<<endl;  
91.           
92.     }  
93.     else  
94.     {  
95.         cout<<"内存不足！"<<endl;  
96.     }  
97.  }  
98.             
99.      else if(s=="delete")  
100.      {  
101.             int deletenum;  
102.             cout<<"请输入删除的进程："<<endl;  
103.             cin>>deletenum;  
104.   
105.         int i=mp[deletenum];  
106.         while(--i>=0 && cluster[i].is_data==0)  
107.         {  
108.           
109.         }  
110.         int j=mp[deletenum];  
111.         while(++j<cluster.size() && cluster[j].is_data==0)  
112.         {  
113.           
114.         }  
115.   
116.         node kk;  
117.         kk.num=0;  
118.         for(int e=i+1;e<=j-1;e++)  
119.         {  
120.             kk.num+=cluster[e].num;  
121.         }     
122.         kk.is_data=0;  
123.   
124.         TTemp.clear();  
125.         for(int p=0;p<cluster.size();)  
126.         {  
127.             if(p==last_ID)  
128.             last_ID=TTemp.size();  
129.             if(p==i+1)  
130.             {  
131.                 p=j;  
132.                 TTemp.push_back(kk);  
133.             }  
134.             else{  
135.                 TTemp.push_back(cluster[p]);  
136.                 p++;  
137.         }  
138.           
139.     }  
140.         cluster.swap(TTemp);  
141.       
142.         for(int i=0;i<cluster.size();i++)  
143.         cout<<"大小 "<<cluster[i].num<<"  是否分配 "<<cluster[i].is_data<<endl;  
144.   
145.        }  
146.    }  
147.     return 0;  
148. }  

原文地址： http://blog.csdn.net/nk_test/article/details/50413665