贪心算法+Java实现C的函数指针

先囧一下，其实本来没有这篇的。
最近在读算法的相关书籍，正好读到贪心算法，大家知道算法的书籍大多是通过C或C++来提供源码的，贪心算法经常会涉及到多个计算结果的对比然后取最优解，C++的处理方式一般都是函数指针，提供一个类似函数指针的数组，然后遍历循环每个函数获得result的结果集。然而java是没有指针的，当然更没有函数指针这一说，那遇到这种情况我们代码要怎么写呢。
百度喵了一眼，看到两个字，接口。
没错，就是接口。接口 + 多态，抽象来看不就是一个方法，多个实现嘛。不过区别在于函数指针可以随便指定函数，而接口相当于一个规范，不满足这个规范的方法我们是无法通过接口去调用的。不过，既然现在需求是循环一系列函数获取某个值并进行比较，那这些函数一定是遵循一个规范的，所以我们用接口一定可以搞定。
顺便简单介绍下贪心算法：
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。
贪心算法的经典问题就是0-1背包问题，N个物品，1个背包，每个物品的重量为w1到wN，价值为p1到pN，背包能承载的最大重量为C，求解最优的装法。当然前提是物品只有装和不装两个选择，不存在装多个的问题，所以叫01背包问题。
好了，铺垫完了，上代码：

package com.amuro.greedy;

public class Goods
{
    public int weight;
    public int price;
}

首先定义我们的物品类，封装重量和价值。下面定义接口：

package com.amuro.greedy.algorithm;

import java.util.List;

import com.amuro.greedy.Goods;

public interface IGreedy
{
    public static final int CAPACITY = 150;

    public int getResult(List<Goods> goodsList);
}

很简单，就一个getResult方法来获取算法的结果，而CAPACITY为设定的背包的最大重量。然后来看三个贪心的实现，分别是：每次取最贵的，每次取最轻的（让物品数量最多），每次取价格密度最高的（price / weight）：

package com.amuro.greedy.algorithm;

import java.util.ArrayList;
import java.util.List;

import com.amuro.greedy.Goods;

/**
 * 每次优先选最贵的
 * @author Amuro
 *
 */
public class Greedy1 implements IGreedy
{

    @Override
    public int getResult(List<Goods> goodsList)
    {
        if(goodsList == null || goodsList.size() == 0)
        {
            return -1;
        }

        @SuppressWarnings("unchecked")
        List<Goods> tempList = (List<Goods>) ((ArrayList<Goods>)goodsList).clone();

        int result = 0;
        int currentWeight = 0;

        while(true)
        {
            Goods maxPriceGoods = selectTheMostExpensiveGoods(tempList);

            currentWeight += maxPriceGoods.weight;

            if(currentWeight > 150)
            {
                break;
            }

            result += maxPriceGoods.price;
            tempList.remove(maxPriceGoods);
        }

        return result;
    }

    private Goods selectTheMostExpensiveGoods(List<Goods> tempList)
    {
        Goods maxPriceGoods = tempList.get(0);

        for(int i = 1; i < tempList.size(); i++)
        {
            Goods goods = tempList.get(i);

            if(goods.price > maxPriceGoods.price)
            {
                maxPriceGoods = goods;
            }
        }

        return maxPriceGoods;
    }

}

package com.amuro.greedy.algorithm;

import java.util.ArrayList;
import java.util.List;

import com.amuro.greedy.Goods;

/**
 * 每次选最轻的
 * @author Amuro
 *
 */
public class Greedy2 implements IGreedy
{

    @Override
    public int getResult(List<Goods> goodsList)
    {
        if(goodsList == null || goodsList.size() == 0)
        {
            return -1;
        }

        @SuppressWarnings("unchecked")
        List<Goods> tempList = (List<Goods>) ((ArrayList<Goods>)goodsList).clone();

        int result = 0;
        int currentWeight = 0;

        while(true)
        {
            Goods lightestGoods = selectedTheLightestGoods(tempList);

            currentWeight += lightestGoods.weight;

            if(currentWeight > 150)
            {
                break;
            }

            result += lightestGoods.price;
            tempList.remove(lightestGoods);
        }

        return result;
    }

    private Goods selectedTheLightestGoods(List<Goods> tempList)
    {
        Goods lightestGoods = tempList.get(0);

        for(int i = 1; i < tempList.size(); i++)
        {
            Goods goods = tempList.get(i);
            if(goods.weight < lightestGoods.weight)
            {
                lightestGoods = goods;
            }
        }

        return lightestGoods;
    }

}

package com.amuro.greedy.algorithm;

import java.util.ArrayList;
import java.util.List;

import com.amuro.greedy.Goods;

/**
 * 每次选价值密度最高的
 * @author Amuro
 *
 */
public class Greedy3 implements IGreedy
{

    @Override
    public int getResult(List<Goods> goodsList)
    {
        if(goodsList == null || goodsList.size() == 0)
        {
            return -1;
        }

        @SuppressWarnings("unchecked")
        List<Goods> tempList = (List<Goods>) ((ArrayList<Goods>)goodsList).clone();

        int result = 0;
        int currentWeight = 0;

        while(true)
        {
            Goods mostDensityGoods = selectedMostDensityGoods(tempList);

            currentWeight += mostDensityGoods.weight;

            if(currentWeight > 150)
            {
                break;
            }

            result += mostDensityGoods.price;
            tempList.remove(mostDensityGoods);
        }

        return result;
    }

    private Goods selectedMostDensityGoods(List<Goods> tempList)
    {
        Goods mostDensityGoods = tempList.get(0);

        for(int i = 1; i < tempList.size(); i++)
        {
            Goods goods = tempList.get(i);

            float mostDensity = mostDensityGoods.price / mostDensityGoods.weight;
            float currentDensity = goods.price / goods.weight;

            if(currentDensity > mostDensity)
            {
                mostDensityGoods = goods;
            }

        }

        return mostDensityGoods;
    }
}

代码很好理解，就不多说了，注意拿到传进来的list记得要clone，不然做了remove操作后，原来的list也被你改了。这里发现个bug，就是循环退出的条件不够，如果所有物品重量加起来都没有超过150程序就要死循环了，嘛，如果这样这个最优解也没有意义了，各位可自行修改，本来重点也不是这个。
好，当我们涉及多个算法的时候，脑子里的第一反应是什么，没错，策略模式，我们需要封装一个类供外部调用，隐藏算法的细节和调用方式。来看GreedyManager类：

package com.amuro.greedy;

import java.util.List;

import com.amuro.greedy.algorithm.IGreedy;

public class GreedyManager
{
    private List<Goods> goodsList;

    private String[] algorithems = {
            "com.amuro.greedy.algorithm.Greedy1", 
            "com.amuro.greedy.algorithm.Greedy2",
            "com.amuro.greedy.algorithm.Greedy3"};

    public GreedyManager(List<Goods> goodsList)
    {
        this.goodsList = goodsList;
    }

    public int doAlgorithm() throws InstantiationException, IllegalAccessException, ClassNotFoundException
    {
        int result = getClass(algorithems[0]).getResult(goodsList);

        for(int i = 1;i < algorithems.length; i++)
        {
            int temp = getClass(algorithems[i]).getResult(goodsList);
            if(temp > result)
            {
                result = temp;
            }
        }

        return result;
    }

    private IGreedy getClass(String className) throws InstantiationException, IllegalAccessException, ClassNotFoundException
    {
        return ((IGreedy)Class.forName(className).newInstance());
    }
}

OK，这篇的重点基本都在这个类了。C++的函数指针数组我们没法实现，但别忘了我们有反射，所以我们可以配置一个类名的数组供循环来调用。然后通过循环，得到每一种贪心计算结果的result，再取出最大的结果给外部调用者。以后再有新的贪心计算规则时，只要增加一个IGreedy的子类，并在数组中增加一个String就可以啦~ 传说中的对修改关闭，对扩展开放。
最后看一下客户端调用：

package com.amuro.greedy;

import java.util.ArrayList;
import java.util.List;

public class Client
{
    public static void main(String[] args)
    {
        Client clt = new Client();
        clt.doAlgorithm();
    }

    private List<Goods> goodsList;
    private GreedyManager greedyManager;

    public Client()
    {
        init();
    }

    private int[] weights = {35, 30, 60, 50, 40, 10, 25};
    private int[] prices = {10, 40, 30, 50, 35, 40, 30};

    private void init()
    {
        goodsList = new ArrayList<>();

        for(int i = 0;i < weights.length;i++)
        {
            Goods goods = new Goods();
            goods.weight = weights[i];
            goods.price = prices[i];

            goodsList.add(goods);
        }

        greedyManager = new GreedyManager(goodsList);

    }

    public void doAlgorithm()
    {
        try
        {
            System.out.println("Result->" + greedyManager.doAlgorithm());
        }
        catch (InstantiationException e)
        {
            e.printStackTrace();
        }
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
    }
}

看一下输出结果：Result->170。
大家有兴趣可以自己算一下，第三种贪心算法就是最优解170~
就酱~