實現這個算法是學習算法分析與設計這門課程的需要。
貪心算法是所接觸到的第一類算法。算法從局部的最優出發，簡單而快捷。對於一個問題的最
優解只能用窮舉法得到時，用貪心法是尋找問題次優解的較好算法。
貪心法是一種改進了的分級處理方法。用貪心法設計算法的特點是一步一步地進行，根據某個
優化測度（可能是目標函數，也可能不是目標函數），每一步上都要保證能獲得局部最優解。每一
步只考慮一個數據，它的選取應滿足局部優化條件。若下一個數據與部分最優解連在一起不再是可
行解時，就不把該數據添加到部分解中，直到把所有數據枚舉完，或者不能再添加爲止。這種能夠
得到某種度量意義下的最優解的分級處理方法稱爲貪心法。
選擇能產生問題最優解的最優度量標準是使用貪心法的核心問題。
假定有n個物體和一個揹包，物體i 有質量wi，價值爲pi，而揹包的載荷能力爲M。若將物體i的
一部分xi（1<=i<=n,0<=xi<=1)裝入揹包中，則有價值pi*xi。在約束條件
（w1*x1+w2*x2+…………+wn*xn)<=M下使目標(p1*x1+p2*x2+……+pn*xn)達到極大，此處
0<=xi<=1,pi>0,1<=i<=n.這個問題稱爲揹包問題（Knapsack problem）。
要想得到最優解，就要在效益增長和揹包容量消耗兩者之間尋找平衡。也就是說，總應該把那
些單位效益最高的物體先放入揹包。
在實現算法的程序中，實現算法的核心程序倒沒碰到很大的問題，然而實現尋找最優度量標準
程序時麻煩不斷！
在尋找最優度量標準時，大致方向是用冒泡排序算法。也就是根據p[i]/w[i]的大小來對w[i]來
排序。
在直接用此算法時，可以有如下的一段代碼：
//根據效益tempArray[i]對重量w[i]排序，爲進入貪心算法作準備
1 void sort(float tempArray[], flaot w[], int n)
2 {
3 int i = 0, j = 0;
4 int index = 0;
5
6 //用類似冒泡排序算法，根據效益p[i]/w[i]對w[i]排序
7 for (i = 0; i < n; i++)
8 {
9 float swapMemory = 0;
10 float temp;
11
12 temp = tempArray[i];
13 index = i;
14
15 for (j = i + 1; j < n; j++)
16 {
17 if (temp < tempArray[j])
18 {
19 temp = tempArray[j];
20 index = j;
21 }
22 }
23
24 //對w[i]排序
25 swapMemory = w[index];
26 w[index] = w[i];
27 w[i] = swapMemory;
28 }
29
30 return;
31 }
然而仔細對算法分析後可以發現，“拿來主義”在這裏用不上了！
對算法的測試用例是p[3] = {25, 24, 15};w[3] = {18, 15, 10}。得到的結果如下：
please input the total count of object: 3
Please input array of p :
25 24 15
Now please input array of w :
18 15 10
sortResult[i] is :
1 -107374176.000000 1 1.600000 2 1.600000
after arithmetic data: x[i]
0.000000 0.333333 0.000000
可以看到其效益爲x[3] = {1.4, 1.6, 1.5}，於是在M = 20的情況下，其預想中的輸出結果是
0，1，0.5。然而事實上是不是就這樣呢？
當程序進入此函數經過必要的變量初始化後，進入了外圍循環，也就是程序的第7行。第一輪循
環中，temp = tempArray[0] = 1.4,index = i = 0;程序運行到第15行，也就是進入了內層循環。
內層循環的主要任務是從第i + 1個元素之後找到一個最大的效益並保存此時的下標。到了第24行後
，就開始對w[i]進行排序。
問題就在這裏了！排序後的w[i] = {1.6, 1.6, 1.5}，因此對w[i]排序後就既改變了w[i]的原
有順序，還改變了w[i]的原來值！
據此，做出一些修改，得到了如下的一段代碼：
1 void sort(float tempArray[], int sortResult[], int n)
2 {
3 int i = 0, j = 0;
4 int index = 0, k = 0;
5
6 for (i = 0; i < n; i++)//對映射數組賦初值0
7 {
8 sortResult[i] = 0;
9 }
10
11 for (i = 0; i < n; i++)
12 {
13 float swapMemory = 0;
14 float temp;
15
16 temp = tempArray[i];
17 index = i;
18
19 for (j = i; j < n; j++)
20 {
21 if ((temp < tempArray[j]) && (sortResult[j] == 0))
22 {
23 temp = tempArray[j];
24 index = j;
25 }
26 }
27
28 if (sortResult[index] == 0)
29 {
30 sortResult[index] = ++k;
31 }
32 }
33
34 for (i = 0; i < n; i++)
35 {
36 if (sortResult[i] == 0)
37 {
38 sortResult[i] = ++k;
39 }
40 }
41
42 return;
43 }
修改後最大的一個改變是沒有繼續沿用直接對w[i]排序，而是用w[i]的一個映射數組
sortResult[i]。sortResult[i]中元素值存放的是根據效益計算得w[i]的大小順序！這樣w[i]原有
的值和位置都沒有改變，從而使算法得以實現！
至於有沒有更好的實現版本，還在探索中！
#include <stdio.h>
#define MAXSIZE 100 //假設物體總數
#define M 20 //揹包的載荷能力
//算法核心，貪心算法
void GREEDY(float w[], float x[], int sortResult[], int n)
{
float cu = M;
int i = 0;
int temp = 0;
for (i = 0; i < n; i++)//準備輸出結果
{
x[i] = 0;
}
for (i = 0; i < n; i++)
{
temp = sortResult[i];//得到取物體的順序
if (w[temp] > cu)
{
break;
}
x[temp] = 1;//若合適則取出
cu -= w[temp];//將容量相應的改變
}
if (i <= n)//使揹包充滿
{
x[temp] = cu / w[temp];
}
return;
}
void sort(float tempArray[], int sortResult[], int n)
{
int i = 0, j = 0;
int index = 0, k = 0;
for (i = 0; i < n; i++)//對映射數組賦初值0
{
sortResult[i] = 0;
}
for (i = 0; i < n; i++)
{
float temp = tempArray[i];
index = i;
//找到最大的效益並保存此時的下標
for (j = 0; j < n; j++)
{
if ((temp < tempArray[j]) && (sortResult[j] == 0))
{
temp = tempArray[j];
index = j;
}
}
//對w[i]作標記排序
if (sortResult[index] == 0)
{
sortResult[index] = ++k;
}
}
//修改效益最低的sortResult[i]標記
for (i = 0; i < n; i++)
{
if (sortResult[i] == 0)
{
sortResult[i] = ++k;
}
}
return;
}
//得到本算法的所有輸入信息
void getData(float p[], float w[], int *n)
{
int i = 0;
printf("please input the total count of object: ");
scanf("%d", n);
printf("Please input array of p :/n");
for (i = 0; i < (*n); i++)
{
scanf("%f", &p[i]);
}
printf("Now please input array of w :/n");
for (i = 0; i < (*n); i++)
{
scanf("%f", &w[i]);
}
return;
}
void output(float x[], int n)
{
int i;
printf("/n/nafter arithmetic data: advise method/n");
for (i = 0; i < n; i++)
{
printf("x[%d]/t", i);
}
printf("/n");
for (i = 0; i < n; i++)
{
printf("%2.3f/t", x[i]);
}
return;
}
void main()
{
float p[MAXSIZE], w[MAXSIZE], x[MAXSIZE];
int i = 0, n = 0;
int sortResult[MAXSIZE];
getData(p, w, &n);
for (i = 0; i < n; i++)
{
x[i] = p[i] / w[i];
}
sort(x, sortResult, n);
GREEDY(w, x, sortResult, n);
output(x, n);
getch();
}