Java实现遗传算法

最新推荐文章于 2024-08-06 18:05:09 发布
最新推荐文章于 2024-08-06 18:05:09 发布
阅读量862 收藏 15
点赞数
分类专栏： 算法

转载请注明出处：http://blog.csdn.net/xiaojimanman/article/details/50277547

http://www.llwjy.com/blogdetail/8d8f9fa295e57c774c2b8223166aee1b.html

个人博客站已经上线了，网址 www.llwjy.com ~欢迎各位吐槽~

-------------------------------------------------------------------------------------------------

      关于遗传算法的详细原理以及具体的定义这里就不多介绍，想了解的可以自行百度，下面就简单介绍下自己对遗传算法的理解，本文对基因的编码采用二进制规则。


算法思想：

      遗传算法参照达尔文的进化论，认为物种都是向好的方向去发展（适者生存），因此可以认为到足够的代数之后，得到的最值可实际的最值很接近。


算法步骤：

1）随机产生一个种群；
2）计算种群的适应度、最好适应度、最差适应度、平均适应度等指标；
3）验证种群代数是否达到自己设置的阈值，如果达到结束计算，否则继续下一步计算；
4）采用转盘赌法选择可以产生下一代的父代，产生下一代种群（种群中个体数量不变）；
5）种群发生基因突变；
6）重复2、3、4、5步。


算法实现-基因部分

1、种群个体（这里认为是染色体），在个体中，我们为这个个体添加两个属性，个体的基因和基因对应的适应度（函数值）。

[java] view plain copy
print ?
  1. public class Chromosome {  
  2.     private boolean[] gene;//基因序列  
  3.     private double score;//对应的函数得分  
  4. }  
public class Chromosome {
	private boolean[] gene;//基因序列
	private double score;//对应的函数得分
}


2、随机生成基因序列，基因的每一个位置是0还是1，这里采用完全随机的方式实现。
[java] view plain copy
print ?
  1. public Chromosome(int size) {  
  2.     if (size <= 0) {  
  3.         return;  
  4.     }  
  5.     initGeneSize(size);  
  6.     for (int i = 0; i < size; i++) {  
  7.         gene[i] = Math.random() >= 0.5;  
  8.     }  
  9. }  
  10.   
  11. private void initGeneSize(int size) {  
  12.     if (size <= 0) {  
  13.         return;  
  14.     }  
  15.     gene = new boolean[size];  
  16. }  
public Chromosome(int size) {
	if (size <= 0) {
		return;
	}
	initGeneSize(size);
	for (int i = 0; i < size; i++) {
		gene[i] = Math.random() >= 0.5;
	}
}

private void initGeneSize(int size) {
	if (size <= 0) {
		return;
	}
	gene = new boolean[size];
}

3、把基因转化为对应的值，比如101对应的数字是5，这里采用位运算来实现。

[java] view plain copy
print ?
  1. public int getNum() {  
  2.     if (gene == null) {  
  3.         return 0;  
  4.     }  
  5.     int num = 0;  
  6.     for (boolean bool : gene) {  
  7.         num <<= 1;  
  8.         if (bool) {  
  9.             num += 1;  
  10.         }  
  11.     }  
  12.     return num;  
  13. }  
public int getNum() {
	if (gene == null) {
		return 0;
	}
	int num = 0;
	for (boolean bool : gene) {
		num <<= 1;
		if (bool) {
			num += 1;
		}
	}
	return num;
}

4、基因发生变异，对于变异的位置这里完全采取随机的方式实现，变异原则是由1变为0，0变为1。

[java] view plain copy
print ?
  1. public void mutation(int num) {  
  2.     //允许变异  
  3.     int size = gene.length;  
  4.     for (int i = 0; i < num; i++) {  
  5.         //寻找变异位置  
  6.         int at = ((int) (Math.random() * size)) % size;  
  7.         //变异后的值  
  8.         boolean bool = !gene[at];  
  9.         gene[at] = bool;  
  10.     }  
  11. }  
public void mutation(int num) {
	//允许变异
	int size = gene.length;
	for (int i = 0; i < num; i++) {
		//寻找变异位置
		int at = ((int) (Math.random() * size)) % size;
		//变异后的值
		boolean bool = !gene[at];
		gene[at] = bool;
	}
}

5、克隆基因，用于产生下一代，这一步就是将已存在的基因copy一份。

[java] view plain copy
print ?
  1. public static Chromosome clone(final Chromosome c) {  
  2.     if (c == null || c.gene == null) {  
  3.         return null;  
  4.     }  
  5.     Chromosome copy = new Chromosome();  
  6.     copy.initGeneSize(c.gene.length);  
  7.     for (int i = 0; i < c.gene.length; i++) {  
  8.         copy.gene[i] = c.gene[i];  
  9.     }  
  10.     return copy;  
  11. }  
public static Chromosome clone(final Chromosome c) {
	if (c == null || c.gene == null) {
		return null;
	}
	Chromosome copy = new Chromosome();
	copy.initGeneSize(c.gene.length);
	for (int i = 0; i < c.gene.length; i++) {
		copy.gene[i] = c.gene[i];
	}
	return copy;
}

6、父母双方产生下一代，这里两个个体产生两个个体子代，具体哪段基因差生交叉，完全随机。

[java] view plain copy
print ?
  1. public static List<Chromosome> genetic(Chromosome p1, Chromosome p2) {  
  2.     if (p1 == null || p2 == null) { //染色体有一个为空，不产生下一代  
  3.         return null;  
  4.     }  
  5.     if (p1.gene == null || p2.gene == null) { //染色体有一个没有基因序列，不产生下一代  
  6.         return null;  
  7.     }  
  8.     if (p1.gene.length != p2.gene.length) { //染色体基因序列长度不同，不产生下一代  
  9.         return null;  
  10.     }  
  11.     Chromosome c1 = clone(p1);  
  12.     Chromosome c2 = clone(p2);  
  13.     //随机产生交叉互换位置  
  14.     int size = c1.gene.length;  
  15.     int a = ((int) (Math.random() * size)) % size;  
  16.     int b = ((int) (Math.random() * size)) % size;  
  17.     int min = a > b ? b : a;  
  18.     int max = a > b ? a : b;  
  19.     //对位置上的基因进行交叉互换  
  20.     for (int i = min; i <= max; i++) {  
  21.         boolean t = c1.gene[i];  
  22.         c1.gene[i] = c2.gene[i];  
  23.         c2.gene[i] = t;  
  24.     }  
  25.     List<Chromosome> list = new ArrayList<Chromosome>();  
  26.     list.add(c1);  
  27.     list.add(c2);  
  28.     return list;  
  29. }  
public static List<Chromosome> genetic(Chromosome p1, Chromosome p2) {
	if (p1 == null || p2 == null) { //染色体有一个为空，不产生下一代
		return null;
	}
	if (p1.gene == null || p2.gene == null) { //染色体有一个没有基因序列，不产生下一代
		return null;
	}
	if (p1.gene.length != p2.gene.length) { //染色体基因序列长度不同，不产生下一代
		return null;
	}
	Chromosome c1 = clone(p1);
	Chromosome c2 = clone(p2);
	//随机产生交叉互换位置
	int size = c1.gene.length;
	int a = ((int) (Math.random() * size)) % size;
	int b = ((int) (Math.random() * size)) % size;
	int min = a > b ? b : a;
	int max = a > b ? a : b;
	//对位置上的基因进行交叉互换
	for (int i = min; i <= max; i++) {
		boolean t = c1.gene[i];
		c1.gene[i] = c2.gene[i];
		c2.gene[i] = t;
	}
	List<Chromosome> list = new ArrayList<Chromosome>();
	list.add(c1);
	list.add(c2);
	return list;
}



算法实现-遗传算法

1、对于遗传算法，我们需要有对应的种群以及我们需要设置的一些常量：种群数量、基因长度、基因突变个数、基因突变率等，具体参照如下代码：

[java] view plain copy
print ?
  1. public abstract class GeneticAlgorithm {  
  2.     private List<Chromosome> population = new ArrayList<Chromosome>();//种群  
  3.     private int popSize = 100;//种群数量  
  4.     private int geneSize;//基因最大长度  
  5.     private int maxIterNum = 500;//最大迭代次数  
  6.     private double mutationRate = 0.01;//基因变异的概率  
  7.     private int maxMutationNum = 3;//最大变异步长  
  8.       
  9.     private int generation = 1;//当前遗传到第几代  
  10.       
  11.     private double bestScore;//最好得分  
  12.     private double worstScore;//最坏得分  
  13.     private double totalScore;//总得分  
  14.     private double averageScore;//平均得分  
  15.       
  16.     private double x; //记录历史种群中最好的X值  
  17.     private double y; //记录历史种群中最好的Y值  
  18.     private int geneI;//x y所在代数  
  19. }  
public abstract class GeneticAlgorithm {
	private List<Chromosome> population = new ArrayList<Chromosome>();//种群
	private int popSize = 100;//种群数量
	private int geneSize;//基因最大长度
	private int maxIterNum = 500;//最大迭代次数
	private double mutationRate = 0.01;//基因变异的概率
	private int maxMutationNum = 3;//最大变异步长
	
	private int generation = 1;//当前遗传到第几代
	
	private double bestScore;//最好得分
	private double worstScore;//最坏得分
	private double totalScore;//总得分
	private double averageScore;//平均得分
	
	private double x; //记录历史种群中最好的X值
	private double y; //记录历史种群中最好的Y值
	private int geneI;//x y所在代数
}

2、初始化种群，在遗传算法开始时，我们需要初始化一个原始种群，这就是原始的第一代。

[java] view plain copy
print ?
  1. private void init() {  
  2.     for (int i = 0; i < popSize; i++) {  
  3.         population = new ArrayList<Chromosome>();  
  4.         Chromosome chro = new Chromosome(geneSize);  
  5.         population.add(chro);  
  6.     }  
  7.     caculteScore();  
  8. }  
private void init() {
	for (int i = 0; i < popSize; i++) {
		population = new ArrayList<Chromosome>();
		Chromosome chro = new Chromosome(geneSize);
		population.add(chro);
	}
	caculteScore();
}

3、在初始种群存在后，我们需要计算 种群的适应度以及最好适应度、最坏适应度和平均适应度等。

[java] view plain copy
print ?
  1. private void caculteScore() {  
  2.     setChromosomeScore(population.get(0));  
  3.     bestScore = population.get(0).getScore();  
  4.     worstScore = population.get(0).getScore();  
  5.     totalScore = 0;  
  6.     for (Chromosome chro : population) {  
  7.         setChromosomeScore(chro);  
  8.         if (chro.getScore() > bestScore) { //设置最好基因值  
  9.             bestScore = chro.getScore();  
  10.             if (y < bestScore) {  
  11.                 x = changeX(chro);  
  12.                 y = bestScore;  
  13.                 geneI = generation;  
  14.             }  
  15.         }  
  16.         if (chro.getScore() < worstScore) { //设置最坏基因值  
  17.             worstScore = chro.getScore();  
  18.         }  
  19.         totalScore += chro.getScore();  
  20.     }  
  21.     averageScore = totalScore / popSize;  
  22.     //因为精度问题导致的平均值大于最好值，将平均值设置成最好值  
  23.     averageScore = averageScore > bestScore ? bestScore : averageScore;  
  24. }  
private void caculteScore() {
	setChromosomeScore(population.get(0));
	bestScore = population.get(0).getScore();
	worstScore = population.get(0).getScore();
	totalScore = 0;
	for (Chromosome chro : population) {
		setChromosomeScore(chro);
		if (chro.getScore() > bestScore) { //设置最好基因值
			bestScore = chro.getScore();
			if (y < bestScore) {
				x = changeX(chro);
				y = bestScore;
				geneI = generation;
			}
		}
		if (chro.getScore() < worstScore) { //设置最坏基因值
			worstScore = chro.getScore();
		}
		totalScore += chro.getScore();
	}
	averageScore = totalScore / popSize;
	//因为精度问题导致的平均值大于最好值，将平均值设置成最好值
	averageScore = averageScore > bestScore ? bestScore : averageScore;
}

4、在计算个体适应度的时候，我们需要根据基因 计算对应的Y值，这里我们设置两个抽象方法，具体实现由类的实现去实现。

[java] view plain copy
print ?
  1. private void setChromosomeScore(Chromosome chro) {  
  2.     if (chro == null) {  
  3.         return;  
  4.     }  
  5.     double x = changeX(chro);  
  6.     double y = caculateY(x);  
  7.     chro.setScore(y);  
  8.   
  9. }  
  10.   
  11. /** 
  12.  * @param chro 
  13.  * @return 
  14.  * @Author:lulei   
  15.  * @Description: 将二进制转化为对应的X 
  16.  */  
  17. public abstract double changeX(Chromosome chro);  
  18.   
  19.   
  20. /** 
  21.  * @param x 
  22.  * @return 
  23.  * @Author:lulei   
  24.  * @Description: 根据X计算Y值 Y=F(X) 
  25.  */  
  26. public abstract double caculateY(double x);  
private void setChromosomeScore(Chromosome chro) {
	if (chro == null) {
		return;
	}
	double x = changeX(chro);
	double y = caculateY(x);
	chro.setScore(y);

}

/**
 * @param chro
 * @return
 * @Author:lulei  
 * @Description: 将二进制转化为对应的X
 */
public abstract double changeX(Chromosome chro);


/**
 * @param x
 * @return
 * @Author:lulei  
 * @Description: 根据X计算Y值 Y=F(X)
 */
public abstract double caculateY(double x);

5、在计算完种群适应度之后，我们需要使用 转盘赌法选取可以 产生下一代的个体，这里有个条件就是只有个人的适应度不小于平均适应度才会长生下一代（适者生存）。

[java] view plain copy
print ?
  1. private Chromosome getParentChromosome (){  
  2.     double slice = Math.random() * totalScore;  
  3.     double sum = 0;  
  4.     for (Chromosome chro : population) {  
  5.         sum += chro.getScore();  
  6.         //转到对应的位置并且适应度不小于平均适应度  
  7.         if (sum > slice && chro.getScore() >= averageScore) {  
  8.             return chro;  
  9.         }  
  10.     }  
  11.     return null;  
  12. }  
private Chromosome getParentChromosome (){
	double slice = Math.random() * totalScore;
	double sum = 0;
	for (Chromosome chro : population) {
		sum += chro.getScore();
		//转到对应的位置并且适应度不小于平均适应度
		if (sum > slice && chro.getScore() >= averageScore) {
			return chro;
		}
	}
	return null;
}

6、选择可以产生下一代的个体之后，就要交配 产生下一代。

[java] view plain copy
print ?
  1. private void evolve() {  
  2.     List<Chromosome> childPopulation = new ArrayList<Chromosome>();  
  3.     //生成下一代种群  
  4.     while (childPopulation.size() < popSize) {  
  5.         Chromosome p1 = getParentChromosome();  
  6.         Chromosome p2 = getParentChromosome();  
  7.         List<Chromosome> children = Chromosome.genetic(p1, p2);  
  8.         if (children != null) {  
  9.             for (Chromosome chro : children) {  
  10.                 childPopulation.add(chro);  
  11.             }  
  12.         }   
  13.     }  
  14.     //新种群替换旧种群  
  15.     List<Chromosome> t = population;  
  16.     population = childPopulation;  
  17.     t.clear();  
  18.     t = null;  
  19.     //基因突变  
  20.     mutation();  
  21.     //计算新种群的适应度  
  22.     caculteScore();  
  23. }  
private void evolve() {
	List<Chromosome> childPopulation = new ArrayList<Chromosome>();
	//生成下一代种群
	while (childPopulation.size() < popSize) {
		Chromosome p1 = getParentChromosome();
		Chromosome p2 = getParentChromosome();
		List<Chromosome> children = Chromosome.genetic(p1, p2);
		if (children != null) {
			for (Chromosome chro : children) {
				childPopulation.add(chro);
			}
		} 
	}
	//新种群替换旧种群
	List<Chromosome> t = population;
	population = childPopulation;
	t.clear();
	t = null;
	//基因突变
	mutation();
	//计算新种群的适应度
	caculteScore();
}

7、在产生下一代的过程中，可能会发生 基因变异。

[java] view plain copy
print ?
  1. private void mutation() {  
  2.     for (Chromosome chro : population) {  
  3.         if (Math.random() < mutationRate) { //发生基因突变  
  4.             int mutationNum = (int) (Math.random() * maxMutationNum);  
  5.             chro.mutation(mutationNum);  
  6.         }  
  7.     }  
  8. }  
private void mutation() {
	for (Chromosome chro : population) {
		if (Math.random() < mutationRate) { //发生基因突变
			int mutationNum = (int) (Math.random() * maxMutationNum);
			chro.mutation(mutationNum);
		}
	}
}

8、将上述步骤 一代一代的重复执行。

[java] view plain copy
print ?
  1. public void caculte() {  
  2.     //初始化种群  
  3.     generation = 1;  
  4.     init();  
  5.     while (generation < maxIterNum) {  
  6.         //种群遗传  
  7.         evolve();  
  8.         print();  
  9.         generation++;  
  10.     }  
  11. }  
public void caculte() {
	//初始化种群
	generation = 1;
	init();
	while (generation < maxIterNum) {
		//种群遗传
		evolve();
		print();
		generation++;
	}
}


编写实现类

      由于上述遗传算法的类是一个抽象类，因此我们需要针对特定的事例编写实现类，假设我们计算 Y=100-log(X)在[6,106]上的最值。


1、我们假设基因的长度为24（基因的长度由要求结果的有效长度确定），因此对应的二进制最大值为 1<< 24，我们做如下设置

[java] view plain copy
print ?
  1. public class GeneticAlgorithmTest extends GeneticAlgorithm{  
  2.       
  3.     public static final int NUM = 1 << 24;  
  4.   
  5.     public GeneticAlgorithmTest() {  
  6.         super(24);    
  7.     }  
  8. }  
public class GeneticAlgorithmTest extends GeneticAlgorithm{
	
	public static final int NUM = 1 << 24;

	public GeneticAlgorithmTest() {
		super(24);  
	}
}

2、对X值的抽象方法进行实现

[java] view plain copy
print ?
  1. @Override  
  2. public double changeX(Chromosome chro) {  
  3.     // TODO Auto-generated method stub    
  4.     return ((1.0 * chro.getNum() / NUM) * 100) + 6;  
  5. }  
@Override
public double changeX(Chromosome chro) {
	// TODO Auto-generated method stub  
	return ((1.0 * chro.getNum() / NUM) * 100) + 6;
}

3、对Y的抽象方法进行实现

[java] view plain copy
print ?
  1. @Override  
  2. public double caculateY(double x) {  
  3.     // TODO Auto-generated method stub    
  4.     return 100 - Math.log(x);  
  5. }  
@Override
public double caculateY(double x) {
	// TODO Auto-generated method stub  
	return 100 - Math.log(x);
}


运行结果

img


遗传算法思考

      自己看了很多遗传算法的介绍，上面提到的最优解都是最后一代的最值，自己就有一个疑问了，为什么我知道前面所有带中的最值，也就是程序中的X  Y值，为什么不能用X Y值做遗传算法最后的结果值呢？


完整代码

1、Chromosome类

[java] view plain copy
print ?
  1.  /**   
  2.  *@Description: 基因遗传染色体    
  3.  */   
  4. package com.lulei.genetic.algorithm;    
  5.   
  6. import java.util.ArrayList;  
  7. import java.util.List;  
  8.   
  9. public class Chromosome {  
  10.     private boolean[] gene;//基因序列  
  11.     private double score;//对应的函数得分  
  12.       
  13.     public double getScore() {  
  14.         return score;  
  15.     }  
  16.   
  17.     public void setScore(double score) {  
  18.         this.score = score;  
  19.     }  
  20.   
  21.     /** 
  22.      * @param size 
  23.      * 随机生成基因序列 
  24.      */  
  25.     public Chromosome(int size) {  
  26.         if (size <= 0) {  
  27.             return;  
  28.         }  
  29.         initGeneSize(size);  
  30.         for (int i = 0; i < size; i++) {  
  31.             gene[i] = Math.random() >= 0.5;  
  32.         }  
  33.     }  
  34.       
  35.     /** 
  36.      * 生成一个新基因 
  37.      */  
  38.     public Chromosome() {  
  39.           
  40.     }  
  41.       
  42.     /** 
  43.      * @param c 
  44.      * @return 
  45.      * @Author:lulei   
  46.      * @Description: 克隆基因 
  47.      */  
  48.     public static Chromosome clone(final Chromosome c) {  
  49.         if (c == null || c.gene == null) {  
  50.             return null;  
  51.         }  
  52.         Chromosome copy = new Chromosome();  
  53.         copy.initGeneSize(c.gene.length);  
  54.         for (int i = 0; i < c.gene.length; i++) {  
  55.             copy.gene[i] = c.gene[i];  
  56.         }  
  57.         return copy;  
  58.     }  
  59.       
  60.     /** 
  61.      * @param size 
  62.      * @Author:lulei   
  63.      * @Description: 初始化基因长度 
  64.      */  
  65.     private void initGeneSize(int size) {  
  66.         if (size <= 0) {  
  67.             return;  
  68.         }  
  69.         gene = new boolean[size];  
  70.     }  
  71.       
  72.       
  73.     /** 
  74.      * @param c1 
  75.      * @param c2 
  76.      * @Author:lulei   
  77.      * @Description: 遗传产生下一代 
  78.      */  
  79.     public static List<Chromosome> genetic(Chromosome p1, Chromosome p2) {  
  80.         if (p1 == null || p2 == null) { //染色体有一个为空，不产生下一代  
  81.             return null;  
  82.         }  
  83.         if (p1.gene == null || p2.gene == null) { //染色体有一个没有基因序列，不产生下一代  
  84.             return null;  
  85.         }  
  86.         if (p1.gene.length != p2.gene.length) { //染色体基因序列长度不同，不产生下一代  
  87.             return null;  
  88.         }  
  89.         Chromosome c1 = clone(p1);  
  90.         Chromosome c2 = clone(p2);  
  91.         //随机产生交叉互换位置  
  92.         int size = c1.gene.length;  
  93.         int a = ((int) (Math.random() * size)) % size;  
  94.         int b = ((int) (Math.random() * size)) % size;  
  95.         int min = a > b ? b : a;  
  96.         int max = a > b ? a : b;  
  97.         //对位置上的基因进行交叉互换  
  98.         for (int i = min; i <= max; i++) {  
  99.             boolean t = c1.gene[i];  
  100.             c1.gene[i] = c2.gene[i];  
  101.             c2.gene[i] = t;  
  102.         }  
  103.         List<Chromosome> list = new ArrayList<Chromosome>();  
  104.         list.add(c1);  
  105.         list.add(c2);  
  106.         return list;  
  107.     }  
  108.       
  109.     /** 
  110.      * @param num 
  111.      * @Author:lulei   
  112.      * @Description: 基因num个位置发生变异 
  113.      */  
  114.     public void mutation(int num) {  
  115.         //允许变异  
  116.         int size = gene.length;  
  117.         for (int i = 0; i < num; i++) {  
  118.             //寻找变异位置  
  119.             int at = ((int) (Math.random() * size)) % size;  
  120.             //变异后的值  
  121.             boolean bool = !gene[at];  
  122.             gene[at] = bool;  
  123.         }  
  124.     }  
  125.       
  126.     /** 
  127.      * @return 
  128.      * @Author:lulei   
  129.      * @Description: 将基因转化为对应的数字 
  130.      */  
  131.     public int getNum() {  
  132.         if (gene == null) {  
  133.             return 0;  
  134.         }  
  135.         int num = 0;  
  136.         for (boolean bool : gene) {  
  137.             num <<= 1;  
  138.             if (bool) {  
  139.                 num += 1;  
  140.             }  
  141.         }  
  142.         return num;  
  143.     }  
  144. }  
 /**  
 *@Description: 基因遗传染色体   
 */ 
package com.lulei.genetic.algorithm;  

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

public class Chromosome {
	private boolean[] gene;//基因序列
	private double score;//对应的函数得分
	
	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}

	/**
	 * @param size
	 * 随机生成基因序列
	 */
	public Chromosome(int size) {
		if (size <= 0) {
			return;
		}
		initGeneSize(size);
		for (int i = 0; i < size; i++) {
			gene[i] = Math.random() >= 0.5;
		}
	}
	
	/**
	 * 生成一个新基因
	 */
	public Chromosome() {
		
	}
	
	/**
	 * @param c
	 * @return
	 * @Author:lulei  
	 * @Description: 克隆基因
	 */
	public static Chromosome clone(final Chromosome c) {
		if (c == null || c.gene == null) {
			return null;
		}
		Chromosome copy = new Chromosome();
		copy.initGeneSize(c.gene.length);
		for (int i = 0; i < c.gene.length; i++) {
			copy.gene[i] = c.gene[i];
		}
		return copy;
	}
	
	/**
	 * @param size
	 * @Author:lulei  
	 * @Description: 初始化基因长度
	 */
	private void initGeneSize(int size) {
		if (size <= 0) {
			return;
		}
		gene = new boolean[size];
	}
	
	
	/**
	 * @param c1
	 * @param c2
	 * @Author:lulei  
	 * @Description: 遗传产生下一代
	 */
	public static List<Chromosome> genetic(Chromosome p1, Chromosome p2) {
		if (p1 == null || p2 == null) { //染色体有一个为空，不产生下一代
			return null;
		}
		if (p1.gene == null || p2.gene == null) { //染色体有一个没有基因序列，不产生下一代
			return null;
		}
		if (p1.gene.length != p2.gene.length) { //染色体基因序列长度不同，不产生下一代
			return null;
		}
		Chromosome c1 = clone(p1);
		Chromosome c2 = clone(p2);
		//随机产生交叉互换位置
		int size = c1.gene.length;
		int a = ((int) (Math.random() * size)) % size;
		int b = ((int) (Math.random() * size)) % size;
		int min = a > b ? b : a;
		int max = a > b ? a : b;
		//对位置上的基因进行交叉互换
		for (int i = min; i <= max; i++) {
			boolean t = c1.gene[i];
			c1.gene[i] = c2.gene[i];
			c2.gene[i] = t;
		}
		List<Chromosome> list = new ArrayList<Chromosome>();
		list.add(c1);
		list.add(c2);
		return list;
	}
	
	/**
	 * @param num
	 * @Author:lulei  
	 * @Description: 基因num个位置发生变异
	 */
	public void mutation(int num) {
		//允许变异
		int size = gene.length;
		for (int i = 0; i < num; i++) {
			//寻找变异位置
			int at = ((int) (Math.random() * size)) % size;
			//变异后的值
			boolean bool = !gene[at];
			gene[at] = bool;
		}
	}
	
	/**
	 * @return
	 * @Author:lulei  
	 * @Description: 将基因转化为对应的数字
	 */
	public int getNum() {
		if (gene == null) {
			return 0;
		}
		int num = 0;
		for (boolean bool : gene) {
			num <<= 1;
			if (bool) {
				num += 1;
			}
		}
		return num;
	}
}

2、GeneticAlgorithm类

[java] view plain copy
print ?
  1.  /**   
  2.  *@Description:      
  3.  */   
  4. package com.lulei.genetic.algorithm;    
  5.   
  6. import java.util.ArrayList;  
  7. import java.util.List;  
  8.   
  9.     
  10. public abstract class GeneticAlgorithm {  
  11.     private List<Chromosome> population = new ArrayList<Chromosome>();  
  12.     private int popSize = 100;//种群数量  
  13.     private int geneSize;//基因最大长度  
  14.     private int maxIterNum = 500;//最大迭代次数  
  15.     private double mutationRate = 0.01;//基因变异的概率  
  16.     private int maxMutationNum = 3;//最大变异步长  
  17.       
  18.     private int generation = 1;//当前遗传到第几代  
  19.       
  20.     private double bestScore;//最好得分  
  21.     private double worstScore;//最坏得分  
  22.     private double totalScore;//总得分  
  23.     private double averageScore;//平均得分  
  24.       
  25.     private double x; //记录历史种群中最好的X值  
  26.     private double y; //记录历史种群中最好的Y值  
  27.     private int geneI;//x y所在代数  
  28.       
  29.     public GeneticAlgorithm(int geneSize) {  
  30.         this.geneSize = geneSize;  
  31.     }  
  32.       
  33.     public void caculte() {  
  34.         //初始化种群  
  35.         generation = 1;  
  36.         init();  
  37.         while (generation < maxIterNum) {  
  38.             //种群遗传  
  39.             evolve();  
  40.             print();  
  41.             generation++;  
  42.         }  
  43.     }  
  44.       
  45.     /** 
  46.      * @Author:lulei   
  47.      * @Description: 输出结果 
  48.      */  
  49.     private void print() {  
  50.         System.out.println("--------------------------------");  
  51.         System.out.println("the generation is:" + generation);  
  52.         System.out.println("the best y is:" + bestScore);  
  53.         System.out.println("the worst fitness is:" + worstScore);  
  54.         System.out.println("the average fitness is:" + averageScore);  
  55.         System.out.println("the total fitness is:" + totalScore);  
  56.         System.out.println("geneI:" + geneI + "\tx:" + x + "\ty:" + y);  
  57.     }  
  58.       
  59.       
  60.     /** 
  61.      * @Author:lulei   
  62.      * @Description: 初始化种群 
  63.      */  
  64.     private void init() {  
  65.         for (int i = 0; i < popSize; i++) {  
  66.             population = new ArrayList<Chromosome>();  
  67.             Chromosome chro = new Chromosome(geneSize);  
  68.             population.add(chro);  
  69.         }  
  70.         caculteScore();  
  71.     }  
  72.       
  73.     /** 
  74.      * @Author:lulei   
  75.      * @Description:种群进行遗传 
  76.      */  
  77.     private void evolve() {  
  78.         List<Chromosome> childPopulation = new ArrayList<Chromosome>();  
  79.         //生成下一代种群  
  80.         while (childPopulation.size() < popSize) {  
  81.             Chromosome p1 = getParentChromosome();  
  82.             Chromosome p2 = getParentChromosome();  
  83.             List<Chromosome> children = Chromosome.genetic(p1, p2);  
  84.             if (children != null) {  
  85.                 for (Chromosome chro : children) {  
  86.                     childPopulation.add(chro);  
  87.                 }  
  88.             }   
  89.         }  
  90.         //新种群替换旧种群  
  91.         List<Chromosome> t = population;  
  92.         population = childPopulation;  
  93.         t.clear();  
  94.         t = null;  
  95.         //基因突变  
  96.         mutation();  
  97.         //计算新种群的适应度  
  98.         caculteScore();  
  99.     }  
  100.       
  101.     /** 
  102.      * @return 
  103.      * @Author:lulei   
  104.      * @Description: 轮盘赌法选择可以遗传下一代的染色体 
  105.      */  
  106.     private Chromosome getParentChromosome (){  
  107.         double slice = Math.random() * totalScore;  
  108.         double sum = 0;  
  109.         for (Chromosome chro : population) {  
  110.             sum += chro.getScore();  
  111.             if (sum > slice && chro.getScore() >= averageScore) {  
  112.                 return chro;  
  113.             }  
  114.         }  
  115.         return null;  
  116.     }  
  117.       
  118.     /** 
  119.      * @Author:lulei   
  120.      * @Description: 计算种群适应度 
  121.      */  
  122.     private void caculteScore() {  
  123.         setChromosomeScore(population.get(0));  
  124.         bestScore = population.get(0).getScore();  
  125.         worstScore = population.get(0).getScore();  
  126.         totalScore = 0;  
  127.         for (Chromosome chro : population) {  
  128.             setChromosomeScore(chro);  
  129.             if (chro.getScore() > bestScore) { //设置最好基因值  
  130.                 bestScore = chro.getScore();  
  131.                 if (y < bestScore) {  
  132.                     x = changeX(chro);  
  133.                     y = bestScore;  
  134.                     geneI = generation;  
  135.                 }  
  136.             }  
  137.             if (chro.getScore() < worstScore) { //设置最坏基因值  
  138.                 worstScore = chro.getScore();  
  139.             }  
  140.             totalScore += chro.getScore();  
  141.         }  
  142.         averageScore = totalScore / popSize;  
  143.         //因为精度问题导致的平均值大于最好值，将平均值设置成最好值  
  144.         averageScore = averageScore > bestScore ? bestScore : averageScore;  
  145.     }  
  146.       
  147.     /** 
  148.      * 基因突变 
  149.      */  
  150.     private void mutation() {  
  151.         for (Chromosome chro : population) {  
  152.             if (Math.random() < mutationRate) { //发生基因突变  
  153.                 int mutationNum = (int) (Math.random() * maxMutationNum);  
  154.                 chro.mutation(mutationNum);  
  155.             }  
  156.         }  
  157.     }  
  158.       
  159.     /** 
  160.      * @param chro 
  161.      * @Author:lulei   
  162.      * @Description: 设置染色体得分 
  163.      */  
  164.     private void setChromosomeScore(Chromosome chro) {  
  165.         if (chro == null) {  
  166.             return;  
  167.         }  
  168.         double x = changeX(chro);  
  169.         double y = caculateY(x);  
  170.         chro.setScore(y);  
  171.   
  172.     }  
  173.       
  174.     /** 
  175.      * @param chro 
  176.      * @return 
  177.      * @Author:lulei   
  178.      * @Description: 将二进制转化为对应的X 
  179.      */  
  180.     public abstract double changeX(Chromosome chro);  
  181.       
  182.       
  183.     /** 
  184.      * @param x 
  185.      * @return 
  186.      * @Author:lulei   
  187.      * @Description: 根据X计算Y值 Y=F(X) 
  188.      */  
  189.     public abstract double caculateY(double x);  
  190.   
  191.     public void setPopulation(List<Chromosome> population) {  
  192.         this.population = population;  
  193.     }  
  194.   
  195.     public void setPopSize(int popSize) {  
  196.         this.popSize = popSize;  
  197.     }  
  198.   
  199.     public void setGeneSize(int geneSize) {  
  200.         this.geneSize = geneSize;  
  201.     }  
  202.   
  203.     public void setMaxIterNum(int maxIterNum) {  
  204.         this.maxIterNum = maxIterNum;  
  205.     }  
  206.   
  207.     public void setMutationRate(double mutationRate) {  
  208.         this.mutationRate = mutationRate;  
  209.     }  
  210.   
  211.     public void setMaxMutationNum(int maxMutationNum) {  
  212.         this.maxMutationNum = maxMutationNum;  
  213.     }  
  214.   
  215.     public double getBestScore() {  
  216.         return bestScore;  
  217.     }  
  218.   
  219.     public double getWorstScore() {  
  220.         return worstScore;  
  221.     }  
  222.   
  223.     public double getTotalScore() {  
  224.         return totalScore;  
  225.     }  
  226.   
  227.     public double getAverageScore() {  
  228.         return averageScore;  
  229.     }  
  230.   
  231.     public double getX() {  
  232.         return x;  
  233.     }  
  234.   
  235.     public double getY() {  
  236.         return y;  
  237.     }  
  238. }  
 /**  
 *@Description:     
 */ 
package com.lulei.genetic.algorithm;  

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

  
public abstract class GeneticAlgorithm {
	private List<Chromosome> population = new ArrayList<Chromosome>();
	private int popSize = 100;//种群数量
	private int geneSize;//基因最大长度
	private int maxIterNum = 500;//最大迭代次数
	private double mutationRate = 0.01;//基因变异的概率
	private int maxMutationNum = 3;//最大变异步长
	
	private int generation = 1;//当前遗传到第几代
	
	private double bestScore;//最好得分
	private double worstScore;//最坏得分
	private double totalScore;//总得分
	private double averageScore;//平均得分
	
	private double x; //记录历史种群中最好的X值
	private double y; //记录历史种群中最好的Y值
	private int geneI;//x y所在代数
	
	public GeneticAlgorithm(int geneSize) {
		this.geneSize = geneSize;
	}
	
	public void caculte() {
		//初始化种群
		generation = 1;
		init();
		while (generation < maxIterNum) {
			//种群遗传
			evolve();
			print();
			generation++;
		}
	}
	
	/**
	 * @Author:lulei  
	 * @Description: 输出结果
	 */
	private void print() {
		System.out.println("--------------------------------");
		System.out.println("the generation is:" + generation);
		System.out.println("the best y is:" + bestScore);
		System.out.println("the worst fitness is:" + worstScore);
		System.out.println("the average fitness is:" + averageScore);
		System.out.println("the total fitness is:" + totalScore);
		System.out.println("geneI:" + geneI + "\tx:" + x + "\ty:" + y);
	}
	
	
	/**
	 * @Author:lulei  
	 * @Description: 初始化种群
	 */
	private void init() {
		for (int i = 0; i < popSize; i++) {
			population = new ArrayList<Chromosome>();
			Chromosome chro = new Chromosome(geneSize);
			population.add(chro);
		}
		caculteScore();
	}
	
	/**
	 * @Author:lulei  
	 * @Description:种群进行遗传
	 */
	private void evolve() {
		List<Chromosome> childPopulation = new ArrayList<Chromosome>();
		//生成下一代种群
		while (childPopulation.size() < popSize) {
			Chromosome p1 = getParentChromosome();
			Chromosome p2 = getParentChromosome();
			List<Chromosome> children = Chromosome.genetic(p1, p2);
			if (children != null) {
				for (Chromosome chro : children) {
					childPopulation.add(chro);
				}
			} 
		}
		//新种群替换旧种群
		List<Chromosome> t = population;
		population = childPopulation;
		t.clear();
		t = null;
		//基因突变
		mutation();
		//计算新种群的适应度
		caculteScore();
	}
	
	/**
	 * @return
	 * @Author:lulei  
	 * @Description: 轮盘赌法选择可以遗传下一代的染色体
	 */
	private Chromosome getParentChromosome (){
		double slice = Math.random() * totalScore;
		double sum = 0;
		for (Chromosome chro : population) {
			sum += chro.getScore();
			if (sum > slice && chro.getScore() >= averageScore) {
				return chro;
			}
		}
		return null;
	}
	
	/**
	 * @Author:lulei  
	 * @Description: 计算种群适应度
	 */
	private void caculteScore() {
		setChromosomeScore(population.get(0));
		bestScore = population.get(0).getScore();
		worstScore = population.get(0).getScore();
		totalScore = 0;
		for (Chromosome chro : population) {
			setChromosomeScore(chro);
			if (chro.getScore() > bestScore) { //设置最好基因值
				bestScore = chro.getScore();
				if (y < bestScore) {
					x = changeX(chro);
					y = bestScore;
					geneI = generation;
				}
			}
			if (chro.getScore() < worstScore) { //设置最坏基因值
				worstScore = chro.getScore();
			}
			totalScore += chro.getScore();
		}
		averageScore = totalScore / popSize;
		//因为精度问题导致的平均值大于最好值，将平均值设置成最好值
		averageScore = averageScore > bestScore ? bestScore : averageScore;
	}
	
	/**
	 * 基因突变
	 */
	private void mutation() {
		for (Chromosome chro : population) {
			if (Math.random() < mutationRate) { //发生基因突变
				int mutationNum = (int) (Math.random() * maxMutationNum);
				chro.mutation(mutationNum);
			}
		}
	}
	
	/**
	 * @param chro
	 * @Author:lulei  
	 * @Description: 设置染色体得分
	 */
	private void setChromosomeScore(Chromosome chro) {
		if (chro == null) {
			return;
		}
		double x = changeX(chro);
		double y = caculateY(x);
		chro.setScore(y);

	}
	
	/**
	 * @param chro
	 * @return
	 * @Author:lulei  
	 * @Description: 将二进制转化为对应的X
	 */
	public abstract double changeX(Chromosome chro);
	
	
	/**
	 * @param x
	 * @return
	 * @Author:lulei  
	 * @Description: 根据X计算Y值 Y=F(X)
	 */
	public abstract double caculateY(double x);

	public void setPopulation(List<Chromosome> population) {
		this.population = population;
	}

	public void setPopSize(int popSize) {
		this.popSize = popSize;
	}

	public void setGeneSize(int geneSize) {
		this.geneSize = geneSize;
	}

	public void setMaxIterNum(int maxIterNum) {
		this.maxIterNum = maxIterNum;
	}

	public void setMutationRate(double mutationRate) {
		this.mutationRate = mutationRate;
	}

	public void setMaxMutationNum(int maxMutationNum) {
		this.maxMutationNum = maxMutationNum;
	}

	public double getBestScore() {
		return bestScore;
	}

	public double getWorstScore() {
		return worstScore;
	}

	public double getTotalScore() {
		return totalScore;
	}

	public double getAverageScore() {
		return averageScore;
	}

	public double getX() {
		return x;
	}

	public double getY() {
		return y;
	}
}

3、GeneticAlgorithmTest类

[java] view plain copy
print ?
  1.  /**   
  2.  *@Description:      
  3.  */   
  4. package com.lulei.genetic.algorithm;    
  5.     
  6. public class GeneticAlgorithmTest extends GeneticAlgorithm{  
  7.       
  8.     public static final int NUM = 1 << 24;  
  9.   
  10.     public GeneticAlgorithmTest() {  
  11.         super(24);    
  12.     }  
  13.       
  14.     @Override  
  15.     public double changeX(Chromosome chro) {  
  16.         // TODO Auto-generated method stub    
  17.         return ((1.0 * chro.getNum() / NUM) * 100) + 6;  
  18.     }  
  19.   
  20.     @Override  
  21.     public double caculateY(double x) {  
  22.         // TODO Auto-generated method stub    
  23.         return 100 - Math.log(x);  
  24.     }  
  25.   
  26.     public static void main(String[] args) {  
  27.         GeneticAlgorithmTest test = new GeneticAlgorithmTest();  
  28.         test.caculte();  
  29.     }  
  30. }  
 /**  
 *@Description:     
 */ 
package com.lulei.genetic.algorithm;  
  
public class GeneticAlgorithmTest extends GeneticAlgorithm{
	
	public static final int NUM = 1 << 24;

	public GeneticAlgorithmTest() {
		super(24);  
	}
	
	@Override
	public double changeX(Chromosome chro) {
		// TODO Auto-generated method stub  
		return ((1.0 * chro.getNum() / NUM) * 100) + 6;
	}

	@Override
	public double caculateY(double x) {
		// TODO Auto-generated method stub  
		return 100 - Math.log(x);
	}

	public static void main(String[] args) {
		GeneticAlgorithmTest test = new GeneticAlgorithmTest();
		test.caculte();
	}
}

-------------------------------------------------------------------------------------------------
小福利
-------------------------------------------------------------------------------------------------
      个人在极客学院上《Lucene案例开发》课程已经上线了（目前上线到第二课），欢迎大家吐槽~

第一课：Lucene概述

第二课：Lucene 常用功能介绍

第三课：网络爬虫

第四课：数据库连接池

第五课：小说网站的采集

第六课：小说网站数据库操作

第七课：小说网站分布式爬虫的实现


i_wanna_rock
关注
专栏目录
JAVA实现遗传算法
小鸡慢慢的专栏
12-12 4万+
转载请注明出处：http://blog.csdn.net/xiaojimanman/article/details/50277547 http://www.llwjy.com/blogdetail/8d8f9fa295e57c774c2b8223166aee1b.html 个人博客站已经上线了，网址 www.llwjy.com ~欢迎各位吐槽~ -----------------------...
java实现遗传算法.md
09-15
### Java 实现遗传算法 #### 一、遗传算法概述 遗传算法（Genetic Algorithm, GA）是一种基于自然选择和遗传学原理的全局优化技术。它通过模拟自然界中的遗传进化过程来寻找最优解或近似最优解。在计算机科学领域...
遗传算法使用Java实现
luchi007的专栏
12-10 734
最近需要学习神经网络，对于神经网络问题的求解其中需要用到遗传算法，所以今天学习了一下遗传算法，主要参看了 http://blog.csdn.net/emiyasstar__/article/details/6938608这篇博客的文章，同时将其使用C++实现的程序用Java再次实现了一遍，不足之处还请指出多包涵   遗传算法：也称进化算法 。 遗传算法是受达尔文的进化论的启发，借鉴生物进化过...
Java8 遗传算法基础（一）
最新发布
龙哥盟
08-06 1279
协议：CC BY-NC-SA 4.0 一、简介 Electronic supplementary material The online version of this chapter (doi:10.​1007/​978-1-4842-0328-6_​1) contains supplementary material, which is available to authorized users. 数字计算机和信息时代的兴起彻底改变了现代生活方式。数字计算机的发明使我们能够将生活的许多领域数字化。这
java：实现遗传算法
04-03
遗传算法的步骤： （1）染色体的编码与解码 对于区间[a,b]上的值x进行解码表示；对于某一个个体的编码为b1,b2,...,bn,解码后对应的参数x值为： x=a+(b-a)/(2^n-1)sum(bk*2^(k-1)).....k=1,2,...n; (2)个体适应度函数 对于目标函数最大化问题，采用Fitness(f(x))=f(x)-Cmin ，f(x)>Cmin ，其中Cmin为目标函数的最小估计； =0, 其他 对于目标函数最小化问题，采用Fitness(f(x))=Cmax-f(x) , f(x)<Cmax，其中Cmin为目标函数的最大估计； =0, 其它 （3）选择算子 选择思想：轮盘赌选择 假设第t代种群P（t）中共有N个染色体xi(1<=i<=N),各染色体的适应值为f(xi),故染色体xi被选中的概率为： P(xi)=f(xi)/sum(f(xj)), j=1,2,...N. (4)交叉算子 Pc:交叉概率；范围在0.4---0.99之间 交叉准则：可以
用Java实现简单的遗传算法
爱上Java8
08-17 1382
遗传算法是解决复杂问题的一种搜索策略，是一种智能计算。他模拟自然界中的种群进化。从这点看，它和神经网络这些算法的起源很像，都是使用计算机去模拟一些自然法则和运作规律。同样，和神经网络一样，遗传算法也是一种基于概率的算法。当然，在现代启发式算法中，很多算法都都是基于概率的，比如神经网络，粒子群算法，模拟退火等。这类方法的要解决的一个问题就是NP问题，要求得结果是满意解，而非最优解。理解这点，我觉得很
GA.rar_java实现遗传算法
09-24
在本案例中，"GA.rar"是一个包含Java实现遗传算法的压缩包，其中的核心文件是"GA.java"。下面将详细讲解遗传算法的基本概念、工作原理以及在Java中的实现细节。 ### 遗传算法基础 1. **编码**：遗传算法首先需要将...
遗传算法-使用Matlab+Python+Java实现遗传算法-解决非线性最优解+TSP问题-超优质项目.zip
02-18
在这个“遗传算法-使用Matlab+Python+Java实现遗传算法-解决非线性最优解+TSP问题-超优质项目”中，我们将深入探讨遗传算法的核心概念、在不同编程语言中的实现方式，以及如何应用它来解决旅行商问题（TSP）。...
java实现遗传算法解决tsp问题
07-23
Java 实现遗传算法解决TSP问题是一个典型的计算机科学与信息技术应用案例。TSP（旅行商问题）是一个经典的组合优化问题，目标是找到访问每个城市一次并返回起点的最短路径。遗传算法是一种模拟自然选择和遗传机制的...
遗传算法java实现
08-11
运输路线和方式规划问题研究的遗传算法java实现代码，可以运行~
用JAVA写的遗传算法（含例子）
03-17
用java写的遗传算法，例子是求f(x1,x2)=100*(x1*x1-x2)*(x1*x1-x2)+(1-x1)*(1-x1)的最优解
java 遗传算法 编程
12-08
本书是学习如何利用遗传算法来解决问题的入门指南，书中包含了Java语言编写的、能运行的项目和解决方案。本书引导读者一步一步地实现各种遗传算法及一些常见应用场景，帮助读者在实践中加深理解，从而能够解决自己独特的问题。本书首先介绍了基本概念，并在随后的章节中添加了机器人控制、旅行商问题等例子，展示了实现遗传算法的更多知识技能。 通过阅读本书，你将熟悉遗传算法与编程语言相关的问题和概念，掌握构建自己的算法所需的全部知识，并且将获得用遗传算法解决问题的能力。请拿起本书，进入遗传算法这个迷人的领域，看看真正能工作的Java代码，并运用于你自己的项目和研究中。
遗传算法-java
05-30
用java语言实现的遗传算法，可以下载用来给自己参考一下。
遗传算法java实现代码
11-04
一个二元最优化问题的遗传算法用java实现的代码
遗传算法-java版
Li_789的博客
03-21 765
遗传算法（Genetic Algorithm，GA）是一种模拟自然进化过程的搜索算法，常用于解决优化问题。它通过模拟自然选择、交叉和变异等机制，逐代优化种群中个体的适应度，最终找到问题的较优解。随机生成一组个体作为初始种群。计算每个个体的适应度，即其解决问题的能力。根据个体的适应度，选择一部分个体作为父代，用于繁殖下一代。随机选择一些个体进行交叉，生成新的个体。对新生成的个体进行变异，引入随机扰动，增加种群的多样性。用新生成的个体替换原种群中适应度较低的个体。
遗传算法Java实现版
luchi007的专栏
12-10 457
ttp://blog.csdn.net/emiyasstar__/article/details/6938608这篇博客的文章，同时将其使用C++实现的程序用Java再次实现了一遍，不足之处还请指出多包涵遗传算法：也称进化算法 。 遗传算法是受达尔文的进化论的启发，借鉴生物进化过程而提出的一种启发式搜索算法。因此在介绍遗传算法前有必要简单的介绍生物进化知识遗传算法教科书上的步骤：      1.评估每条染色体所对应个体的适应度。      2.遵照适应度越高，选择概率越大的原则，从种群中选择两个个体作为父方
java简单实现遗传算法
cccccttttyyy的博客
05-19 1355
此篇文章没有太复杂的算法，相当简单，但对于初学者来说，用来简单了解入门还是可以的。 原文地址：http://blog.csdn.net/why_still_confused/article/details/52198767 简化步骤： 1.选择，从给出的染色体种群中选择染色体，由随机数决定：可能多次选取同一个染色体。基于原博客并未做出重大改变。 提议：可将变异个体加入而不是替换在种群中，进
Java实现遗传算法详解
"遗传算法的Java实现" 在遗传算法（Genetic Algorithm, GA）中，我们利用生物进化原理来解决优化问题。遗传算法是一种全局搜索方法，通过模拟自然选择、遗传和突变等过程，不断迭代优化解决方案。在这个Java版本的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值