Java 遗传算法

遗传算法(Genetic Algorithm, GA)是一种基于自然选择和遗传学原理的优化算法,用于求解复杂的搜索和优化问题。在Java中实现遗传算法通常包括以下几个步骤:

  1. 初始化种群:生成一组随机解作为初始种群。
  2. 适应度评估:定义一个适应度函数,用于评估每个解的优劣。
  3. 选择:根据适应度选择适应度较高的个体作为父代,用于生成下一代。
  4. 交叉(Crossover):通过交换父代的部分基因来生成子代。
  5. 变异(Mutation):以一定的概率随机改变子代的基因,增加种群的多样性。
  6. 替代:用子代替代部分或全部父代,形成新的种群。
  7. 终止条件:设定终止条件(如达到最大迭代次数或适应度达到某个阈值),终止算法。

以下是一个简单的Java实现遗传算法的示例,用于解决一个优化问题(如最大化某个函数)。

import java.util.ArrayList;  
import java.util.Collections;  
import java.util.List;  
import java.util.Random;  
  
class Individual {  
    private int[] genes;  
    private double fitness;  
  
    public Individual(int geneLength) {  
        genes = new int[geneLength];  
        Random rand = new Random();  
        for (int i = 0; i < geneLength; i++) {  
            genes[i] = rand.nextInt(2); // 0 or 1  
        }  
    }  
  
    public double getFitness() {  
        return fitness;  
    }  
  
    public void setFitness(double fitness) {  
        this.fitness = fitness;  
    }  
  
    public int[] getGenes() {  
        return genes;  
    }  
  
    @Override  
    public String toString() {  
        StringBuilder sb = new StringBuilder();  
        for (int gene : genes) {  
            sb.append(gene);  
        }  
        return sb.toString();  
    }  
}  
  
class GeneticAlgorithm {  
    private static final int POPULATION_SIZE = 100;  
    private static final int GENE_LENGTH = 10;  
    private static final int MAX_GENERATIONS = 1000;  
    private static final double MUTATION_RATE = 0.01;  
  
    public static void main(String[] args) {  
        List<Individual> population = initializePopulation(POPULATION_SIZE, GENE_LENGTH);  
  
        for (int generation = 0; generation < MAX_GENERATIONS; generation++) {  
            evaluateFitness(population);  
            List<Individual> newPopulation = generateNewPopulation(population);  
            population = newPopulation;  
  
            // 输出当前最优解  
            Collections.sort(population, (i1, i2) -> Double.compare(i2.getFitness(), i1.getFitness()));  
            System.out.println("Generation " + generation + ": Best Fitness = " + population.get(0).getFitness());  
        }  
    }  
  
    private static List<Individual> initializePopulation(int populationSize, int geneLength) {  
        List<Individual> population = new ArrayList<>();  
        for (int i = 0; i < populationSize; i++) {  
            population.add(new Individual(geneLength));  
        }  
        return population;  
    }  
  
    private static void evaluateFitness(List<Individual> population) {  
        for (Individual individual : population) {  
            // 示例适应度函数:计算二进制字符串中1的个数(可以根据具体问题修改)  
            int countOnes = 0;  
            for (int gene : individual.getGenes()) {  
                if (gene == 1) {  
                    countOnes++;  
                }  
            }  
            individual.setFitness(countOnes);  
        }  
    }  
  
    private static List<Individual> generateNewPopulation(List<Individual> population) {  
        List<Individual> newPopulation = new ArrayList<>();  
        while (newPopulation.size() < POPULATION_SIZE) {  
            Individual parent1 = selectParent(population);  
            Individual parent2 = selectParent(population);  
            Individual child = crossover(parent1, parent2);  
            mutate(child);  
            newPopulation.add(child);  
        }  
        return newPopulation;  
    }  
  
    private static Individual selectParent(List<Individual> population) {  
        // 轮盘赌选择  
        double totalFitness = population.stream().mapToDouble(Individual::getFitness).sum();  
        double randomValue = new Random().nextDouble() * totalFitness;  
        double cumulativeFitness = 0.0;  
  
        for (Individual individual : population) {  
            cumulativeFitness += individual.getFitness();  
            if (cumulativeFitness >= randomValue) {  
                return individual;  
            }  
        }  
        return population.get(population.size() - 1); // 如果没有匹配,返回最后一个  
    }  
  
    private static Individual crossover(Individual parent1, Individual parent2) {  
        int crossoverPoint = new Random().nextInt(parent1.getGenes().length);  
        int[] childGenes = new int[parent1.getGenes().length];  
  
        System.arraycopy(parent1.getGenes(), 0, childGenes, 0, crossoverPoint);  
        System.arraycopy(parent2.getGenes(), crossoverPoint, childGenes, crossoverPoint, parent2.getGenes().length - crossoverPoint);  
  
        return new Individual() {  
            {  
                this.genes = childGenes;  
            }  
        };  
    }  
  
    private static void mutate(Individual individual) {  
        Random rand = new Random();  
        for (int i = 0; i < individual.getGenes().length; i++) {  
            if (rand.nextDouble() < MUTATION_RATE) {  
                individual.getGenes()[i] = 1 - individual.getGenes()[i]; // 0变1,1变0  
            }  
        }  
    }  
}

注意事项

  1. 适应度函数:根据具体问题定义,这里示例的是计算二进制字符串中1的个数。
  2. 选择方法:这里使用了轮盘赌选择(Roulette Wheel Selection),但还有其他选择方法如锦标赛选择(Tournament Selection)等。
  3. 交叉和变异:交叉和变异操作的具体实现可以根据问题需求进行调整。
  4. 性能优化:可以根据实际需求对算法进行优化,比如使用精英保留策略(Elite Preservation)等。

这个示例展示了基本的遗传算法框架,你可以根据具体需求进行扩展和修改。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值