遗传算法在 Java 中的实现229

遗传算法是一种启发式搜索算法，它模拟生物进化过程来解决优化问题。它广泛应用于各种领域，包括机器学习、优化和调度问题。

Java 中的遗传算法

在 Java 中实现遗传算法涉及以下步骤：
表示解决方案：使用染色体（一组基因）来表示潜在的解决方案。
初始化种群：创建具有随机基因的初始种群。
评估适应度：计算每个染色体的适应度，以衡量其解决问题的有效性。
选择：根据其适应度选择染色体进行繁殖。
交叉：将选定的染色体配对进行交叉，创建新后代。
突变：以一定概率随机改变后代中的某些基因。
重复：重复上述步骤直到达到终止条件（例如，达到最大代数或达到所需适应度）。

示例代码

以下 Java 代码展示了一个基本的遗传算法实现：```java
import ;
import ;
public class GeneticAlgorithm {
// 种群大小
private static final int POPULATION_SIZE = 100;
// 染色体长度
private static final int CHROMOSOME_LENGTH = 10;
// 交叉概率
private static final double CROSSOVER_PROBABILITY = 0.8;
// 突变概率
private static final double MUTATION_PROBABILITY = 0.2;
// 目标染色体
private static final int[] TARGET_CHROMOSOME = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
public static void main(String[] args) {
// 初始化种群
int[][] population = initializePopulation();
// 进化种群
for (int i = 0; i < 1000; i++) {
// 评估适应度
int[] fitnesses = evaluateFitness(population);
// 选择
int[][] parents = selectParents(fitnesses);
// 交叉
int[][] offspring = crossover(parents);
// 突变
offspring = mutate(offspring);
// 更新种群
population = updatePopulation(population, offspring);
// 打印最佳适应度
("代 " + i + ":最佳适应度: " + (fitnesses).max().getAsInt());
}
}
// 初始化种群
private static int[][] initializePopulation() {
int[][] population = new int[POPULATION_SIZE][CHROMOSOME_LENGTH];
for (int i = 0; i < POPULATION_SIZE; i++) {
for (int j = 0; j < CHROMOSOME_LENGTH; j++) {
population[i][j] = (int) (() * 10);
}
}
return population;
}
// 评估适应度
private static int[] evaluateFitness(int[][] population) {
int[] fitnesses = new int[POPULATION_SIZE];
for (int i = 0; i < POPULATION_SIZE; i++) {
int fitness = 0;
for (int j = 0; j < CHROMOSOME_LENGTH; j++) {
if (population[i][j] == TARGET_CHROMOSOME[j]) {
fitness++;
}
}
fitnesses[i] = fitness;
}
return fitnesses;
}
// 选择
private static int[][] selectParents(int[] fitnesses) {
int[][] parents = new int[2][CHROMOSOME_LENGTH];
int maxFitness1 = 0;
int maxFitness2 = 0;
int parent1 = 0;
int parent2 = 0;
for (int i = 0; i < POPULATION_SIZE; i++) {
if (fitnesses[i] > maxFitness1) {
maxFitness1 = fitnesses[i];
parent1 = i;
}
}
for (int i = 0; i < POPULATION_SIZE; i++) {
if (fitnesses[i] > maxFitness2 && i != parent1) {
maxFitness2 = fitnesses[i];
parent2 = i;
}
}
parents[0] = population[parent1];
parents[1] = population[parent2];
return parents;
}
// 交叉
private static int[][] crossover(int[][] parents) {
Random random = new Random();
int[][] offspring = new int[2][CHROMOSOME_LENGTH];
int crossoverPoint = (CHROMOSOME_LENGTH);
for (int i = 0; i < crossoverPoint; i++) {
offspring[0][i] = parents[0][i];
offspring[1][i] = parents[1][i];
}
for (int i = crossoverPoint; i < CHROMOSOME_LENGTH; i++) {
offspring[0][i] = parents[1][i];
offspring[1][i] = parents[0][i];
}
return offspring;
}
// 突变
private static int[][] mutate(int[][] offspring) {
Random random = new Random();
for (int i = 0; i < CHROMOSOME_LENGTH; i++) {
if (() < MUTATION_PROBABILITY) {
offspring[0][i] = (int) (() * 10);
offspring[1][i] = (int) (() * 10);
}
}
return offspring;
}
// 更新种群
private static int[][] updatePopulation(int[][] population, int[][] offspring) {
int[][] newPopulation = new int[POPULATION_SIZE][CHROMOSOME_LENGTH];
for (int i = 0; i < POPULATION_SIZE; i++) {
newPopulation[i] = population[i];
}
newPopulation[0] = offspring[0];
newPopulation[1] = offspring[1];
return newPopulation;
}
}
```