遗传算法简介及代码详解

一、什么是Jupyter和遗传算法Jupyter是一种交互式计算环境，可以用于数据清洗和转换、数值模拟、统计建模、数据可视化和机器学习等多种数据处理工作。

而遗传算法是一种模拟自然选择和遗传规律的优化算法，主要用于解决复杂的优化问题。

二、Jupyter中的遗传算法实现在Jupyter中，可以使用Python编程语言来实现遗传算法。

首先需要引入相关的库，如numpy、random等，然后按照遗传算法的基本原理来编写代码。

三、遗传算法的基本原理1. 初始化种裙：随机生成一定数量的个体作为初始种裙。

2. 选择：根据个体的适应度值，利用适应度函数进行选择，选择适应度高的个体作为父母个体。

3. 交叉：通过交叉操作，将父母个体的基因进行组合，产生新的个体。

4. 变异：对新个体的基因进行变异操作，引入新的基因信息。

5. 重复选择、交叉和变异操作，直到满足终止条件。

6. 最终得到适应度较高的个体，即为所求的优化解。

四、使用Jupyter编写遗传算法代码的步骤1. 引入相关的库```pythonimport numpy as npimport random```2. 初始化种裙```pythondef init_population(pop_size, chromosome_length):population = np.random.randint(0, 2, (pop_size, chromosome_length))return population```3. 选择```pythondef select(population, fitness_value):index = np.random.choice(np.arange(len(population)),size=len(population), replace=True,p=fitness_value/fitness_value.sum())return population[index]```4. 交叉```pythondef crossover(parents, pc=0.6):children = np.empty(parents.shape)for i in range(0, len(parents), 2):if np.random.rand() < pc:crossover_point = np.random.randint(1, len(parents[i])) children[i] = np.concatenate((parents[i][:crossover_point], parents[i+1][crossover_point:]))children[i+1] =np.concatenate((parents[i+1][:crossover_point],parents[i][crossover_point:]))else:children[i] = parents[i]children[i+1] = parents[i+1]return children```5. 变异```pythondef mutate(children, pm=0.01):for i in range(len(children)):for j in range(len(children[i])):if np.random.rand() < pm:children[i][j] = 1 - children[i][j]return children```6. 遗传算法主程序```pythonpop_size = 100chromosome_length = 10max_gen = 100population = init_population(pop_size, chromosome_length)for gen in range(max_gen):fitness_value = calculate_fitness_value(population)parents = select(population, fitness_value)children = crossover(parents)new_population = mutate(children)population = new_population```五、总结通过Jupyter和Python编程语言，我们可以比较轻松地实现遗传算法，并用于解决各种优化问题。

遗传算法详解（含MATLAB代码）Python遗传算法框架使用实例（一）使用Geatpy实现句子匹配在前面几篇文章中，我们已经介绍了高性能Python遗传和进化算法框架——Geatpy的使用。

本篇就一个案例进行展开讲述：pip install geatpy更新至Geatpy2的方法：pip install --upgrade --user geatpy查看版本号，在Python中执行：import geatpyprint(geatpy.__version__)我们都听过“无限猴子定理”，说的是有无限只猴子用无限的时间会产生特定的文章。

在无限猴子定理中，我们“假定”猴子们是没有像人类那样“智能”的，而且“假定”猴子不会自我学习。

因此，这些猴子需要“无限的时间"。

而在遗传算法中，由于采用的是启发式的进化搜索，因此不需要”无限的时间“就可以完成类似的工作。

当然，需要产生的文章篇幅越长，那么就需要越久的时间才能完成。

下面以产生"T om is a little boy, isn't he? Yes he is, he is a good and smart child and he is always ready to help others, all in all we all like him very much."的句子为例，讲述如何利用Geatpy实现句子的搜索。

之前的文章中我们已经讲述过如何使用Geatpy的进化算法框架实现遗传算法编程。

这里就直接用框架。

把自定义问题类和执行脚本编写在下面的"main.py”文件中：# -*- coding: utf-8 -*-import numpy as npimport geatpy as eaclass MyProblem(ea.Problem): # 继承Problem父类def __init__(self):name = 'MyProblem' # 初始化name（函数名称，可以随意设置） # 定义需要匹配的句子strs = 'Tom is a little boy, isn't he? Yes he is, he is a good and smart child and he is always ready to help others, all in all we all like him very much.'self.words = []for c in strs:self.words.append(ord(c)) # 把字符串转成ASCII码M = 1 # 初始化M（目标维数）maxormins = [1] # 初始化maxormins（目标最小最大化标记列表，1：最小化该目标；-1：最大化该目标）Dim = len(self.words) # 初始化Dim（决策变量维数）varTypes = [1] * Dim # 初始化varTypes（决策变量的类型，元素为0表示对应的变量是连续的；1表示是离散的）lb = [32] * Dim # 决策变量下界ub = [122] * Dim # 决策变量上界lbin = [1] * Dim # 决策变量下边界ubin = [1] * Dim # 决策变量上边界# 调用父类构造方法完成实例化ea.Problem.__init__(self, name, M, maxormins, Dim, varTypes, lb, ub, lbin, ubin)def aimFunc(self, pop): # 目标函数Vars = pop.Phen # 得到决策变量矩阵diff = np.sum((Vars - self.words)**2, 1)pop.ObjV = np.array([diff]).T # 把求得的目标函数值赋值给种群pop的ObjV执行脚本if __name__ == "__main__":"""================================实例化问题对象============================="""problem = MyProblem() # 生成问题对象"""==================================种群设置================================"""Encoding = 'RI' # 编码方式NIND = 50 # 种群规模Field = ea.crtfld(Encoding, problem.varTypes, problem.ranges,problem.borders) # 创建区域描述器population = ea.Population(Encoding, Field, NIND) # 实例化种群对象（此时种群还没被初始化，仅仅是完成种群对象的实例化）"""================================算法参数设置=============================="""myAlgorithm = ea.soea_DE_rand_1_L_templet(problem, population) # 实例化一个算法模板对象myAlgorithm.MAXGEN = 2000 # 最大进化代数"""===========================调用算法模板进行种群进化========================="""[population, obj_trace, var_trace] = myAlgorithm.run() # 执行算法模板population.save() # 把最后一代种群的信息保存到文件中# 输出结果best_gen = np.argmin(obj_trace[:, 1]) # 记录最优种群是在哪一代best_ObjV = obj_trace[best_gen, 1]print('最优的目标函数值为：%s'%(best_ObjV))print('有效进化代数：%s'%(obj_trace.shape[0]))print('最优的一代是第 %s 代'%(best_gen + 1))print('评价次数：%s'%(myAlgorithm.evalsNum))print('时间已过 %s 秒'%(myAlgorithm.passTime))for num in var_trace[best_gen, :]:print(chr(int(num)), end = '')上述代码中首先定义了一个问题类MyProblem，然后调用Geatpy内置的soea_DE_rand_1_L_templet算法模板，它实现的是差分进化算法DE-rand-1-L，详见源码：运行结果如下：种群信息导出完毕。

遗传算法代码python一、简介遗传算法是一种通过模拟自然选择和遗传学原理来寻找最优解的优化算法。

它广泛应用于各种领域，包括优化问题、搜索和机器学习等。

二、代码概述以下是一个简单的遗传算法的Python代码示例，用于解决简单的优化问题。

该算法使用一个简单的二进制编码方式，并使用适应度函数来评估每个个体的适应度。

三、代码实现```pythonimportnumpyasnp#遗传算法参数POPULATION_SIZE=100#种群规模CROSSOVER_RATE=0.8#交叉概率MUTATION_RATE=0.1#变异概率MAX_GENERATIONS=100#最大迭代次数#适应度函数deffitness(individual):#在这里定义适应度函数，评估每个个体的适应度#这里简单地返回个体值的平方，可以根据实际问题进行调整returnnp.sum(individual**2)#初始种群生成pop=np.random.randint(2,size=(POPULATION_SIZE,))#迭代过程forgenerationinrange(MAX_GENERATIONS):#评估种群中每个个体的适应度fitness_values=np.apply_along_axis(fitness,1,pop)#选择种群selected_idx=np.random.choice(np.arange(POPULATION_SIZE), size=POPULATION_SIZE,replace=True,p=fitness_values/fitness_va lues.sum())selected_pop=pop[selected_idx]#交叉操作ifCROSSOVER_RATE>np.random.rand():cross_points=np.random.rand(POPULATION_SIZE,2)<0.5#随机选择交叉点cross_pop=np.array([np.hstack((individual[cross_points[i, 0]:cross_points[i,1]]+individual[cross_points[i,1]:],other))f ori,otherinenumerate(selected_pop)]).T#合并个体并随机交叉得到新的个体cross_pop=cross_pop[cross_points]#将交叉后的个体重新排列成原始种群大小selected_pop=np.vstack((selected_pop,cross_pop))#将新个体加入种群中#变异操作ifMUTATION_RATE>np.random.rand():mutated_pop=selected_pop+np.random.randn(POPULATION_SIZE, 1)*np.sqrt(np.log(POPULATION_SIZE))*(selected_pop!=pop).astyp e(np.float)#根据变异概率对个体进行变异操作，得到新的个体种群mutated_pop=mutated_pop[mutated_pop!=0]#将二进制种群中值为0的个体去掉，因为这些个体是随机的二进制串，不是解的一部分，不应该参与变异操作selected_pop=mutated_pop[:POPULATION_SIZE]#将新种群中除最后一个以外的部分加入原始种群中（即新的种群被排除了适应度最差的个体）#选择当前最好的个体（用于更新最优解）best_idx=np.argmax(fitness_values)best_solution=selected_pop[best_idx]print(f"Generation{generation}:Bestsolution:{best_solutio n}")```四、使用示例假设要解决一个简单的优化问题：求一个一维函数的最小值。

GATBX遗传算法工具箱函数及实例讲解基本原理：遗传算法是一种典型的启发式算法，属于非数值算法范畴。

它是模拟达尔文的自然选择学说和自然界的生物进化过程的一种计算模型。

它是采用简单的编码技术来表示各种复杂的结构，并通过对一组编码表示进行简单的遗传操作和优胜劣汰的自然选择来指导学习和确定搜索的方向。

遗传算法的操作对象是一群二进制串（称为染色体、个体），即种群，每一个染色体都对应问题的一个解。

从初始种群出发，采用基于适应度函数的选择策略在当前种群中选择个体，使用杂交和变异来产生下一代种群。

如此模仿生命的进化进行不断演化，直到满足期望的终止条件。

运算流程：Step 1：对遗传算法的运行参数进行赋值。

参数包括种群规模、变量个数、交叉概率、变异概率以及遗传运算的终止进化代数。

Step 2：建立区域描述器。

根据轨道交通与常规公交运营协调模型的求解变量的约束条件，设置变量的取值范围。

Step 3：在Step 2的变量取值范围内，随机产生初始群体，代入适应度函数计算其适应度值。

Step 4：执行比例选择算子进行选择操作。

Step 5：按交叉概率对交叉算子执行交叉操作。

Step 6：按变异概率执行离散变异操作。

Step 7：计算Step 6得到局部最优解中每个个体的适应值，并执行最优个体保存策略。

Step 8：判断是否满足遗传运算的终止进化代数，不满足则返回Step 4，满足则输出运算结果。

运用遗传算法工具箱:运用基于Matlab的遗传算法工具箱非常方便，遗传算法工具箱里包括了我们需要的各种函数库。

目前，基于Matlab的遗传算法工具箱也很多，比较流行的有英国设菲尔德大学开发的遗传算法工具箱GATBX、GAOT以及Math Works公司推出的GADS。

实际上，GADS就是大家所看到的Matlab中自带的工具箱。

我在网上看到有问为什么遗传算法函数不能调用的问题，其实，主要就是因为用的工具箱不同。

因为，有些人用的是GATBX带有的函数，但MATLAB自带的遗传算法工具箱是GADS，GADS当然没有GATBX里的函数，因此运行程序时会报错，当你用MATLAB来编写遗传算法代码时，要根据你所安装的工具箱来编写代码。

matlab遗传算法代码
1 、算法概述
遗传算法（Genetic Algorithms，GA）是一种仿生学优化算法，它借用遗传学中物
竞天择的进化规则，模拟“自然选择”与“遗传进化”得出选择最优解的过程。

其基本原
理是对现有的种群中的各个个体，将其表示成某种形式的编码，然后根据自变量与约束条件，利用杂交、变异等操作，产生新一代解的种群，不断重复这一过程，最终求出收敛到
最优解的种群。

2、遗传算法的作用
遗传算法的主要作用在于优化多元函数，能够在大量的变量影响目标函数值的情况下
寻求最优解。

和其它现有的数值优化技术比较，如梯度下降法等，遗传算法更能适应“凸”和“非凸”都能解决，不受约束条件与搜索空间的影响较大，又叫做“智能搜索法”。

在
计算机视觉等计算机技术领域，经常用遗传算法来对一系列特征参数进行搜索和调节，成
功优化提高了系统的正确处理率。

3、matlab遗传算法的实现
Matlab的遗传算法应用是基于GA Toolbox工具箱，它提供了一个功能强大的、可扩
展的包装器，可用于构建遗传算法模型。

(1)编写最优化函数：
使用和设置最优化表达式或函数、变量；
(2)设置参数编码：
设置变量的编码，比如选择0-1二进制、0-10十进制；
(3)选择遗传算法的方法
选择遗传算法的方法，可以在多个选择中选择，比如变异、杂交等；
(4)设置运算参数：
设置每代的种群数、最大进化的世代数；
(5)运行遗传算法：
根据设定的参数运行遗传算法，算出收敛到最优解的种群；
(6)获得最优解：
获得收敛到最优解的条件下的最优解，得出最优解所在位置等参数，完成整个优化搜索。

遗传算法代码遗传算法是一种基于自然选择和遗传学原理的优化算法，用于解决许多复杂的优化问题，如机器学习、图像处理、组合优化等。

以下是一个简单的遗传算法代码示例：1. 初始化种群首先，我们需要创建一组初始个体，称为种群。

每个个体都是由一组基因表示的，这些基因可能是一些数字、布尔值或其他类型的值。

我们可以使用随机数生成器生成这些基因，并将它们组合成一个个体。

2. 适应度函数为了衡量每个个体的表现，我们需要编写一个适应度函数。

该函数将计算每个个体的适应度得分，该得分反映了该个体在解决优化问题方面的能力。

适应度函数将对每个个体进行评分，并将其分配到一个适应度等级。

3. 选择操作选择操作是基于每个个体的适应度得分来选择哪些个体将被选择并用于生成下一代种群。

较高适应度的个体将有更高的概率被选择，而较低适应度的个体将有更低的概率被选择。

这通常是通过轮盘赌选择方法实现的。

4. 交叉操作交叉操作是将两个个体的基因组合并以生成新的个体。

我们可以将两个随机个体中的某些基因进行交换，从而创建新的个体。

这样的交叉操作将增加种群的多样性，使其更有可能找到最优解。

5. 变异操作变异操作是用于引入种群中的随机性的操作。

在变异操作中，我们将随机选择一个个体，并随机更改其中的一个或多个基因。

这将引入新的、未经探索的基因组合，从而增加种群的多样性。

6. 迭代随着种群不断进化，每个个体的适应度得分也将不断提高。

我们将重复执行选择、交叉和变异操作，以生成新的个体，并淘汰旧的个体。

这个不断迭代的过程将继续，直到达到预设的迭代次数或找到最优解为止。

这是一个简单的遗传算法代码示例，它演示了如何使用遗传算法来解决优化问题。

在实际应用中，我们可以进一步对算法进行优化，以获得更好的结果。

遗传算法( GA , Genetic Algorithm ) ，也称进化算法。

遗传算法是受达尔文的进化论的启发，借鉴生物进化过程而提出的一种启发式搜索算法。

因此在介绍遗传算法前有必要简单的介绍生物进化知识。

一.进化论知识作为遗传算法生物背景的介绍，下面内容了解即可：种群(Population)：生物的进化以群体的形式进行，这样的一个群体称为种群。

个体：组成种群的单个生物。

基因 ( Gene ) ：一个遗传因子。

染色体 ( Chromosome )：包含一组的基因。

生存竞争，适者生存：对环境适应度高的、牛B的个体参与繁殖的机会比较多，后代就会越来越多。

适应度低的个体参与繁殖的机会比较少，后代就会越来越少。

遗传与变异：新个体会遗传父母双方各一部分的基因，同时有一定的概率发生基因变异。

简单说来就是：繁殖过程，会发生基因交叉( Crossover ) ，基因突变( Mutation ) ，适应度( Fitness )低的个体会被逐步淘汰，而适应度高的个体会越来越多。

那么经过N代的自然选择后，保存下来的个体都是适应度很高的，其中很可能包含史上产生的适应度最高的那个个体。

二.遗传算法思想借鉴生物进化论，遗传算法将要解决的问题模拟成一个生物进化的过程，通过复制、交叉、突变等操作产生下一代的解，并逐步淘汰掉适应度函数值低的解，增加适应度函数值高的解。

这样进化N代后就很有可能会进化出适应度函数值很高的个体。

举个例子，使用遗传算法解决“0-1背包问题”的思路：0-1背包的解可以编码为一串0-1字符串（0：不取，1：取）；首先，随机产生M个0-1字符串，然后评价这些0-1字符串作为0-1背包问题的解的优劣；然后，随机选择一些字符串通过交叉、突变等操作产生下一代的M个字符串，而且较优的解被选中的概率要比较高。

这样经过G代的进化后就可能会产生出0-1背包问题的一个“近似最优解”。

编码：需要将问题的解编码成字符串的形式才能使用遗传算法。

遗传算法matlab程序代码
遗传算法（GA）是一种用于求解优化问题的算法，其主要思想是模拟
生物进化过程中的“选择、交叉、变异”操作，通过模拟这些操作，来寻
找最优解。

Matlab自带了GA算法工具箱，可以直接调用来实现遗传算法。

以下是遗传算法Matlab程序代码示例：
1.初始化
首先定义GA需要优化的目标函数f，以及GA算法的相关参数，如种
群大小、迭代次数、交叉概率、变异概率等，如下所示：
options = gaoptimset('PopulationSize',10,...
'Generations',50,...
2.运行遗传算法
运行GA算法时，需要调用MATLAB自带的ga函数，将目标函数、问
题的维度、上下界、约束条件和算法相关参数作为输入参数。

其中，上下
界和约束条件用于限制空间，防止到无效解。

代码如下：
[某,fval,reason,output,population] = ga(f,2,[],[],[],[],[-10,-10],[10,10],[],options);
3.结果分析
最后，将结果可视化并输出，可以使用Matlab的plot函数绘制出目
标函数的值随迭代次数的变化，如下所示：
plot(output.generations,output.bestf)
某label('Generation')
ylabel('Best function value')
总之，Matlab提供了方便易用的GA算法工具箱，开发者只需要根据具体问题定义好目标函数和相关参数，就能够在短时间内快速实现遗传算法。

浮点数编码实现遗传算法遗传算法主要包括三个主要操作，选择、交叉和变异。

用浮点数编码进行运算，三种操作方法如下：选择：1. 计算i f 和n i S f =∑2. 计算ii nf P S =3. 累计概率1ii j j g P ==∑4. 产生均匀分布0~1的随机数r5. 将r 与i g 比较，如果1i i g r g -≤≤，则选择个体i 进入到下一代新群体6. 反复执行4和5，直至新群体的个体数目等于父代群体规模交叉：11(1)(1)t tt A B A t t t B A Bx x x x x x αααα++=+-=+- 其中，1t A x +和1t B x +是交叉之后的个体，t A x 和tB x 是随机选择的两个个体，α是交叉的一个常数, 取值为(0,1]。

变异：1max min()()%20()()%21t t t A A A tt A A x k x x r rand x x k x x r rand +⎧+⋅-⋅==⎨-⋅-⋅=⎩，，1t A x +是变异之后的个体，tA x 是变异之前的个体，k 是变异的一个常数，取值为(0,1]，max x 是个体的上限，min x 是个体的下限，r 是产生的随机数。

适应度线性变换：F aF b '=+其中F 是原适应度，F '是变换之后的适应度，a,b 是变换的系数。

适应度线性变换要满足下面两个条件：条件一：avgavg F F '= 条件二：maxavg F C F '=⋅C=1.2~2缩放时参数a,b 的计算方法可以用如下方法： 如果满足：maxmin 1avg C F F F C ⋅->-就令：max (1)avg avg C a F F F -=-max max avg avg avgF C F b F F F -⋅=-否则：min avgavg F a F F =- min min avgavg F F b F F ⋅=- 实现代码如下：#include<stdio.h>#include<stdlib.h>#include<math.h>#include<time.h>#define M 80 //种群数量#define XMIN -1 //下限#define XMAX 2 //上限#define PI 3.1415926#define PC 0.8 //交叉概率#define PM 0.18 //变异概率#define PA 0.01 //交叉因子struct Node{double Pmember;double Myfitness; //Myfitness是适应度double Myfitsum; //Myfitsum是适应度占总体适应度的百分比，然后从第一个个体往后累加，主要用于选择操作}Nownode[M],Nextnode[M]; //本代群体和下一代群体int nodeindex[M]; //交叉时随机配对，存放配对的群体下标int T=0;double fx(double x) //根据x计算fx{double y;y=x*sin(10*PI*x)+2;//y=100-(x-5)*(x-5);return y;}int calfitness() //计算适应度值{int i;double minfitness,maxfitness,avefitness=0;double C=1.7,a,b;double temp;minfitness=Nownode[0].Myfitness=fx(Nownode[0].Pmember);maxfitness=minfitness;avefitness=maxfitness;for(i=1;i<M;i++){Nownode[i].Myfitness=fx(Nownode[i].Pmember);avefitness+=Nownode[i].Myfitness;if(minfitness>Nownode[i].Myfitness){minfitness=Nownode[i].Myfitness;}if(maxfitness<Nownode[i].Myfitness){maxfitness=Nownode[i].Myfitness;}}if(minfitness<0)//如果有负的适应度值，就把所以的适应度都加上一个数，使适应度全都为正数{temp=minfitness;Nownode[0].Myfitness+=-temp;avefitness=Nownode[0].Myfitness;maxfitness=Nownode[0].Myfitness;minfitness=Nownode[0].Myfitness;for(i=1;i<M;i++){Nownode[i].Myfitness+=-temp;avefitness+=Nownode[i].Myfitness;if(minfitness>Nownode[i].Myfitness){minfitness=Nownode[i].Myfitness;}if(maxfitness<Nownode[i].Myfitness){maxfitness=Nownode[i].Myfitness;}}}//适应度线性变换avefitness=avefitness/M;//计算平均适应度if(minfitness>(C*avefitness-maxfitness)/(C-1)){a=(C-1)*avefitness/(maxfitness-avefitness);b=(maxfitness-C*avefitness)*avefitness/(maxfitness-avefitness);}else{a=avefitness/(avefitness-minfitness);b=minfitness*avefitness/(avefitness-minfitness);}for(i=0;i<M;i++){Nownode[i].Myfitness=a*Nownode[i].Myfitness+b;}Nownode[0].Myfitsum=Nownode[0].Myfitness;for(i=1;i<M;i++){Nownode[i].Myfitsum=Nownode[i].Myfitness+Nownode[i-1].Myfitsum;//每一个Myfitsum都是自己的适应度加上前一个的Myfitsum}for(i=0;i<M;i++){Nownode[i].Myfitsum=Nownode[i].Myfitsum/Nownode[M-1].Myfitsum;//每一个Myfitsum除以所有适应度之和，使Myfitsum为0~1之间}return 0;}double randn() //产生XMIN到XMAX之间的随机数{return XMIN+1.0*rand()/RAND_MAX*(XMAX-XMIN);}int initpopulation() //初始化种群{int i;for(i=0;i<M;i++){Nownode[i].Pmember=randn();}calfitness(); //计算适应度return 0;}int assignment(struct Node *node1,struct Node *node2)//把node2的值赋值给node1{node1->Pmember=node2->Pmember;node1->Myfitness=node2->Myfitness;node1->Myfitsum=node2->Myfitsum;return 0;}int copypopulation() //复制操作{int i,num=0;double temp;while(num<M){temp=1.0*rand()/RAND_MAX;for(i=1;i<M;i++){if(temp<=Nownode[0].Myfitsum){assignment(&Nextnode[num++],&Nownode[0]);//把第一个个体复制到下一代break;}if(temp>=Nownode[i-1].Myfitsum&&temp<=Nownode[i].Myfitsum)//把第i个个体复制到下一代{assignment(&Nextnode[num++],&Nownode[i]);break;}}}for(i=0;i<M;i++){assignment(&Nownode[i],&Nextnode[i]); //更新本代个体}calfitness(); //计算适应度return 0;}int isrepeat(int temp,int n) //产生随机下标判断是否重复{int i;for(i=0;i<n;i++){if(nodeindex[i]==temp)return 1;}return 0;}int crossover(){int i,temp;double temp_pc;for(i=0;i<M;i++) //产生交叉点的下标{do {temp=rand()%M;} while(isrepeat(temp,i));nodeindex[i]=temp;}for(i=0;i<M;i=i+2){temp_pc=1.0*rand()/RAND_MAX; //如果满足交叉的条件，就开始交叉if(temp_pc<=PC){Nownode[nodeindex[i]].Pmember=PA*Nownode[nodeindex[i+1]].Pmember+(1-PA)*Nowno de[nodeindex[i]].Pmember;Nownode[nodeindex[i+1]].Pmember=PA*Nownode[nodeindex[i]].Pmember+(1-PA)*Nowno de[nodeindex[i+1]].Pmember;}}calfitness(); //计算适应度return 0;}int mutation() //变异操作{int i,temp;double k=0.8,temp_pm;for(i=0;i<M;i++){temp_pm=1.0*rand()/RAND_MAX;if(temp_pm<=PM) //如果满足变异条件，就开始变异{temp=rand()%2;if(temp==0){Nownode[i].Pmember=Nownode[i].Pmember+k*(XMAX-Nownode[i].Pmember)*1.0*rand( )/RAND_MAX;}else{Nownode[i].Pmember=Nownode[i].Pmember-k*(Nownode[i].Pmember-XMIN)*1.0*rand()/ RAND_MAX;}}}calfitness(); //计算适应度return 0;}int findmaxfit()//找到适应度最大的个体{int i,index=0;double temp=0;for(i=0;i<M;i++){if(temp<Nownode[i].Myfitness){index=i;temp=Nownode[i].Myfitness;}}return index;}int main(){int i=0,index;int num=0,num1=0,num2=0;srand(time(NULL));while(num++<1000){T=0;initpopulation();while(T++<200){copypopulation();crossover();mutation();}index=findmaxfit();if(fabs(Nownode[index].Pmember-1.85)<=0.1){num1++;}else{num2++;}}printf("正确的次数有%d次\n",num1);printf("错误的次数有%d次\n",num2);return 0;}。

遗传算法简述及代码详解声明：本文内容整理自网络，认为原作者同意转载，如有冒犯请联系我。

遗传算法基本内容遗传算法为群体优化算法，也就是从多个初始解开始进行优化，每个解称为一个染色体，各染色体之间通过竞争、合作、单独变异，不断进化。

遗传学与遗传算法中的基础术语比较染色体：又可以叫做基因型个体(individuals)群体/种群(population)：一定数量的个体组成，及一定数量的染色体组成，群体中个体的数量叫做群体大小。

初始群体：若干染色体的集合，即解的规模，如30，50等，认为是随机选取的数据集合。

适应度(fitness)：各个个体对环境的适应程度优化时先要将实际问题转换到遗传空间，就是把实际问题的解用染色体表示，称为编码，反过程为解码/译码，因为优化后要进行评价（此时得到的解是否较之前解优越），所以要返回问题空间，故要进行解码。

SGA采用二进制编码，染色体就是二进制位串，每一位可称为一个基因；如果直接生成二进制初始种群，则不必有编码过程，但要求解码时将染色体解码到问题可行域内。

遗传算法的准备工作:1) 数据转换操作，包括表现型到基因型的转换和基因型到表现型的转换。

前者是把求解空间中的参数转化成遗传空间中的染色体或者个体(encoding)，后者是它的逆操作(decoding)2) 确定适应度计算函数，可以将个体值经过该函数转换为该个体的适应度，该适应度的高低要能充分反映该个体对于解得优秀程度。

非常重要的过程。

遗传算法基本过程为:1) 编码，创建初始群体2) 群体中个体适应度计算3) 评估适应度4) 根据适应度选择个体5) 被选择个体进行交叉繁殖6) 在繁殖的过程中引入变异机制7) 繁殖出新的群体，回到第二步实例一：（建议先看实例二）求 []30,0∈x 范围内的()210-=x y 的最小值1) 编码算法选择为"将x 转化为2进制的串"，串的长度为5位（串的长度根据解的精度设 定，串长度越长解得精度越高）。