遗传算法的C语言程序案例
遗传算法旅行商问题c语言代码
遗传算法是一种模拟自然选择过程的优化算法，可以用于解决各种复杂的组合优化问题。
其中，旅行商问题是一个经典的组合优化问题，也是一个典型的NP难题，即寻找最优解的时间复杂度是指数级的。
在本文中，我们将讨论如何使用遗传算法来解决旅行商问题，并给出相应的C语言代码实现。
我们将介绍旅行商问题的数学模型，然后简要介绍遗传算法的原理，最后给出C语言代码实现。
旅行商问题是指一个旅行商要拜访n个城市，恰好拜访每个城市一次，并返回出发城市，要求总路程最短。
数学上可以用一个n*n的距离矩阵d[i][j]表示城市i到城市j的距离，问题可以形式化为求解一个排列p={p1,p2,...,pn}，使得目标函数f(p)=Σd[p[i]][p[i+1]]+d[p[n]][p[1]]最小。
这个问题是一个组合优化问题，其搜索空间是一个n维的离散空间。
遗传算法是一种基于生物进化过程的优化算法，主要包括选择、交叉、变异等操作。
在使用遗传算法解决旅行商问题时，可以将每个排列p看作一个个体，目标函数f(p)看作个体的适应度，通过选择、交叉和变异等操作来搜索最优解。
以下是遗传算法解决旅行商问题的C语言代码实现：1. 我们需要定义城市的距离矩阵和其他相关参数，例如城市的数量n，种裙大小pop_size，交叉概率pc，变异概率pm等。
2. 我们初始化种裙，即随机生成pop_size个排列作为初始种裙。
3. 我们进入遗传算法的迭代过程。
在每一代中，我们首先计算种裙中每个个体的适应度，然后通过选择、交叉和变异操作来更新种裙。
4. 选择操作可以采用轮盘赌选择法，即根据个体的适应度来进行选择，适应度越高的个体被选中的概率越大。
5. 交叉操作可以采用部分映射交叉方法，即随机选择两个个体，然后随机选择一个交叉点，将交叉点之后的基因片段进行交换。
6. 变异操作可以采用变异率为pm的单点变异方法，即随机选择一个个体和一个位置，将该位置的基因值进行随机变异。
7. 我们重复进行迭代操作，直到达到停止条件（例如达到最大迭代次数或者适应度达到阈值）。
用混合遗传算法解决单机调度问题c语言程序
用混合遗传算法解决单机调度问题c语言程序#include#include#include#include#include#include "ceshi.h"void main(){s_individual *temp=NULL;long run_start,run_finish,run_sum=0;float run_avg=0;int sum_k=0;srand((unsigned)time(NULL));/*将当前时间设置成随机函数的种子，所以每次产生的数都不一样*///printf("%d\n",time(NULL));//srand((unsigned)1398759277);if((outfp = fopen("newfile1","w")) == NULL){fprintf(stderr,"Cannot open output file %s\n","file1");exit(-1);}init_parameter();//初始化工件参数print_parameter();//打印工件参数for(run=1; run<=maxruns; run++){run_start=clock();initialize();//初始化包括初始参数设置initmalloc();//分配全局空间gererate_pop();//产生初始种群statistics(oldpop);//统计种群数据，得到最优个体init_temperature=(min-max)/log(preceive); temperature_k=init_temperature;while(k{generation();//交叉select_better(oldpop,newpop);//保留最佳个体newpop popsize_copy(oldpop,newpop);gen_mu(newpop);//变异保留最佳个体select_better(oldpop,newpop);popsize_copy(oldpop,newpop);CSA(newpop);//模拟退火操作定步长抽样select_better(oldpop,newpop);statistics(newpop);run_finish=clock();if (last_fitness==bestfit.fitness){last_maxgen++;}else{last_maxgen=0;last_runtime=run_finish;}last_fitness=bestfit.fitness;k++;//退温temperature_k=temperature_k*ptemper;temp=oldpop;oldpop=newpop;newpop=temp;}sum_k=sum_k+k;run_time=last_runtime-run_start;run_sum=run_sum+run_time;print_popsize();ceshi_popstatic();freeall();}run_avg=(float)run_sum/float(maxruns);fprintf(outfp,"\nmax=%d min=%d avg=%d run_sum=%f avg_k=%d\n",pop_max,pop_min,pop_sum/maxruns,run_avg,su m_k);fclose(outfp);}。
解TSP问题的遗传算法C语言程序
解TSP问题的遗传算法C语言程序#include<stdio.h>#include<stdlib.h>#include<math.h>#include<alloc.h>#include<conio.h>#include<float.h>#include<time.h>#include<graphics.h>#include<bios.h>#define maxpop 100#define maxstring 100struct pp{unsigned char chrom[maxstring];float x,fitness;unsigned int parent1,parent2,xsite;};struct pp *oldpop,*newpop,*p1;unsigned int popsize,lchrom,gem,maxgen,co_min,jrand;unsigned int nmutation,ncross,jcross,maxpp,minpp,maxxy;floatpcross,pmutation,sumfitness,avg,max,min,seed,maxold,oldrand[maxstring];unsigned char x[maxstring],y[maxstring]; float*dd,ff,maxdd,refpd,fm[201]; FILE *fp,*fp1;float objfunc(float);void statistics();int select();int flip(float);int crossover();void generation();void initialize();void report();float decode();void crtinit();void inversion();float random1();void randomize1();main(){unsigned int gen,k,j,tt;char fname[10];float ttt;clrscr();co_min=0;if((oldpop=(struct pp *)farmalloc(maxpop*sizeof(struct pp)))==NULL) {printf("memory requst fail!\n");exit(0);} if((dd=(float*)farmalloc(maxstring*maxstring*sizeof(float)))==NULL){printf("memory requst fail!\n");exit(0);} if((newpop=(struct pp *)farmalloc(maxpop*sizeof(struct pp)))==NULL){printf("memory requst fail!\n");exit(0);} if((p1=(struct pp*)farmalloc(sizeof(struct pp)))==NULL){printf("memory requst fail!\n");exit(0);} for(k=0;k<maxpop;k++) oldpop[k].chrom[0]='\0'; for(k=0;k<maxpop;k++) newpop[k].chrom[0]='\0'; printf("Enter Result Data Filename:"); gets(fname);if((fp=fopen(fname,"w+"))==NULL){printf("cannot open file\n");exit(0);}gen=0;randomize();initialize();fputs("this is result of the TSP problem:",fp);fprintf(fp,"city: %2d psize: %3d Ref.TSP_path:%f\n",lchrom,popsize,refpd);fprintf(fp,"Pc: %f Pm: %f Seed: %f\n",pcross,pmutation,seed);fprintf(fp,"X site:\n");for(k=0;k<lchrom;k++){if((k%16)==0) fprintf(fp,"\n"); fprintf(fp,"%5d",x[k]);}fprintf(fp,"\n Y site:\n"); for(k=0;k<lchrom;k++){if((k%16)==0) fprintf(fp,"\n"); fprintf(fp,"%5d",y[k]);}fprintf(fp,"\n");crtinit();statistics(oldpop);report(gen,oldpop);getch();maxold=min;fm[0]=100.0*oldpop[maxpp].x/ff; do {gen=gen+1;generation();statistics(oldpop);if(max>maxold){maxold=max;co_min=0;}fm[gen%200]=100.0*oldpop[maxpp].x/ff; report(gen,oldpop);gotoxy(30,25);ttt=clock()/18.2;tt=ttt/60;printf("Run Clock: %2d: %2d: %4.2f",tt/60,tt%60,ttt-tt*60.0);printf("Min=%6.4fNm:%d\n",min,co_min); }while((gen<100)&&!bioskey(1)); printf("\n gen= %d",gen);do{gen=gen+1;generation();statistics(oldpop);if(max>maxold){maxold=max;co_min=0;}fm[gen%200]=100.0*oldpop[maxpp].x/ff; report(gen,oldpop);if((gen%100)==0)report(gen,oldpop); gotoxy(30,25);ttt=clock()/18.2;tt=ttt/60;printf("Run Clock: %2d: %2d: %4.2f",tt/60,tt%60,ttt-tt*60.0);printf("Min=%6.4fNm:%d\n",min,co_min); }while((gen<maxgen)&&!bioskey(1));getch();for(k=0;k<lchrom;k++) {if((k%16)==0)fprintf(fp,"\n");fprintf(fp,"%5d",oldpop[maxpp].chrom[k]);}fprintf(fp,"\n");fclose(fp);farfree(dd);farfree(p1);farfree(oldpop);farfree(newpop);restorecrtmode();exit(0);}/*%%%%%%%%%%%%%%%%*/float objfunc(float x1) {float y;y=100.0*ff/x1;return y;}/*&&&&&&&&&&&&&&&&&&&*/void statistics(pop) struct pp *pop;{int j;sumfitness=pop[0].fitness; min=pop[0].fitness; max=pop[0].fitness; maxpp=0;minpp=0;for(j=1;j<popsize;j++) {sumfitness=sumfitness+pop[j].fitness;if(pop[j].fitness>max){max=pop[j].fitness;maxpp=j;}if(pop[j].fitness<min){min=pop[j].fitness;minpp=j;}}avg=sumfitness/(float)popsize;}/*%%%%%%%%%%%%%%%%%%%%*/void generation(){unsigned int k,j,j1,j2,i1,i2,mate1,mate2;float f1,f2;j=0;do{mate1=select();pp:mate2=select();if(mate1==mate2)goto pp;crossover(oldpop[mate1].chrom,oldpop[mate2].chrom,j);newpop[j].x=(float)decode(newpop[j].chrom);newpop[j].fitness=objfunc(newpop[j].x); newpop[j].parent1=mate1;newpop[j].parent2=mate2;newpop[j].xsite=jcross;newpop[j+1].x=(float)decode(newpop[j+1].chrom);newpop[j+1].fitness=objfunc(newpop[j+1].x); newpop[j+1].parent1=mate1;newpop[j+1].parent2=mate2;newpop[j+1].xsite=jcross;if(newpop[j].fitness>min){for(k=0;k<lchrom;k++)oldpop[minpp].chrom[k]=newpop[j].chrom[k];oldpop[minpp].x=newpop[j].x;oldpop[minpp].fitness=newpop[j].fitness;co_min++;return;}if(newpop[j+1].fitness>min){for(k=0;k<lchrom;k++)oldpop[minpp].chrom[k]=newpop[j+1].chrom[k];oldpop[minpp].x=newpop[j+1].x;oldpop[minpp].fitness=newpop[j+1].fitness;co_min++;return;}j=j+2;}while(j<popsize);}/*%%%%%%%%%%%%%%%%%*/void initdata(){unsigned int ch,j;clrscr();printf("-----------------------\n");printf("A SGA\n");printf("------------------------\n");/*pause();*/clrscr();printf("*******SGA DATA ENTRY AND INITILIZATION *******\n");printf("\n");printf("input pop size");scanf("%d",&popsize); printf("input chrom length");scanf("%d",&lchrom); printf("input maxgenerations");scanf("%d",&maxgen); printf("input crossoverprobability");scanf("%f",&pcross); printf("input mutationprob");scanf("%f",&pmutation); randomize1();clrscr();nmutation=0;ncross=0;}/*%%%%%%%%%%%%%%%%%%%%*/void initreport(){int j,k;printf("pop size=%d\n",popsize);printf("chromosome length=%d\n",lchrom);printf("maxgen=%d\n",maxgen);printf("pmutation=%f\n",pmutation); printf("pcross=%f\n",pcross);printf("initial generation statistics\n"); printf("ini pop maxfitness=%f\n",max); printf("ini pop avr fitness=%f\n",avg); printf("ini pop min fitness=%f\n",min); printf("ini pop sum fit=%f\n",sumfitness); } void initpop(){unsigned char j1;unsigned int k5,i1,i2,j,i,k,j2,j3,j4,p5[maxstring];float f1,f2;j=0;for(k=0;k<lchrom;k++)oldpop[j].chrom[k]=k;for(k=0;k<lchrom;k++)p5[k]=oldpop[j].chrom[k];randomize();for(;j<popsize;j++){j2=random(lchrom);for(k=0;k<j2+20;k++){j3=random(lchrom);j4=random(lchrom);j1=p5[j3];p5[j3]=p5[j4];p5[j4]=j1;}for(k=0;k<lchrom;k++)oldpop[j].chrom[k]=p5[k]; }for(k=0;k<lchrom;k++)for(j=0;j<lchrom;j++)dd[k*lchrom+j]=hypot(x[k]-x[j],y[k]-y[j]);for(j=0;j<popsize;j++) {oldpop[j].x=(float)decode(oldpop[j].chrom); oldpop[j].fitness=objfunc(oldpop[j].x);oldpop[j].parent1=0;oldpop[j].parent2=0;oldpop[j].xsite=0;}}/*&&&&&&&&&&&&&&&&&*/void initialize(){int k,j,minx,miny,maxx,maxy; initdata();minx=0;miny=0;maxx=0;maxy=0;for(k=0;k<lchrom;k++){x[k]=rand();if(x[k]>maxx)maxx=x[k]; if(x[k]<minx)minx=x[k]; y[k]=rand();if(y[k]>maxy)maxy=y[k]; if(y[k]<miny)miny=y[k]; }if((maxx-minx)>(maxy-miny)){maxxy=maxx-minx;}else {maxxy=maxy-miny;}maxdd=0.0;for(k=0;k<lchrom;k++)for(j=0;j<lchrom;j++){dd[k*lchrom+j]=hypot(x[k]-x[j],y[k]-y[j]);if(maxdd<dd[k*lchrom+j])maxdd=dd[k*lchrom+j];}refpd=dd[lchrom-1];for(k=0;k<lchrom;k++)refpd=refpd+dd[k*lchrom+k+2]; for(j=0;j<lchrom;j++)dd[j*lchrom+j]=4.0*maxdd; ff=(0.765*maxxy*pow(lchrom,0.5)); minpp=0; min=dd[lchrom-1];for(j=0;j<lchrom-1;j++){if(dd[lchrom*j+lchrom-1]<min){min=dd[lchrom*j+lchrom-1];minpp=j;}}initpop();statistics(oldpop);initreport();}/*&&&&&&&&&&&&&&&&&&*/void report(int l,struct pp *pop){int k,ix,iy,jx,jy;unsigned int tt;float ttt;cleardevice();gotoxy(1,1);printf("city:%4d para_size:%4d maxgen:%4d ref_tour:%f\n",lchrom,popsize,maxgen,refpd);printf("ncross:%4d Nmutation:%4d Rungen:%4d AVG=%8.4f MIN=%8.4f\n\n",ncross,nmutation,l,avg,min);printf("inpath:%6.4f Minpath length:%10.4f Ref_co_tour:%f\n",pop[maxpp].x/maxxy,pop[maxpp].x,ff); printf("Co_minpath:%6.4f Maxfit:%10.8f",100.0*pop[maxpp].x/ff,pop[maxpp].fitness); ttt=clock()/18.2;tt=ttt/60;printf("Run clock:%2d:%2d:%4d.2f\n",tt/60,tt%60,ttt-tt*60.0); setcolor(1%15+1);for(k=0;k<lchrom-1;k++){ix=x[pop[maxpp].chrom[k]];iy=y[pop[maxpp].chrom[k]]+110;jx=x[pop[maxpp].chrom[k+1]];jy=y[pop[maxpp].chrom[k+1]]+110;line(ix,iy,jx,jy);putpixel(ix,iy,RED);}ix=x[pop[maxpp].chrom[0]];iy=y[pop[maxpp].chrom[0]]+110;jx=x[pop[maxpp].chrom[lchrom-1]];jy=y[pop[maxpp].chrom[lchrom-1]]+110; line(ix,iy,jx,jy); putpixel(jx,jy,RED);setcolor(11);outtextxy(ix,iy,"*");setcolor(12);for(k=0;k<1%200;k++){ix=k+280;iy=366-fm[k]/3;jx=ix+1;jy=366-fm[k+1]/3;line(ix,iy,jx,jy);putpixel(ix,iy,RED);}printf("GEN:%3d",l);printf("Minpath:%f Maxfit:%f",pop[maxpp].x,pop[maxpp].fitness); printf("Clock:%2d:%2d:%4.2f\n",tt/60,tt%60,ttt-tt*60.0);}/*###############*/float decode(unsigned char *pp) {int j,k,l;float tt;tt=dd[pp[0]*lchrom+pp[lchrom-1]]; for(j=0;j<lchrom-1;j++){tt=tt+dd[pp[j]*lchrom+pp[j+1]];} l=0;for(k=0;k<lchrom-1;k++)for(j=k+1;j<lchrom;j++){if(pp[j]==pp[k])l++;}return tt+4*l*maxdd;}/*%%%%%%%%%%%%%%%%%%*/ void crtinit(){int driver,mode;struct palettetype p;driver=DETECT;mode=0;initgraph(&driver,&mode,""); cleardevice();}/*$$$$$$$$$$$$$$$$$$$$*/ int select(){double rand1,partsum; float r1;int j;partsum=0.0;j=0;rand1=random1()*sumfitness; do{partsum=partsum+oldpop[j].fitness;j=j+1;}while((partsum<rand1)&&(j<popsize));return j-1;}/*$$$$$$$$$$$$$$$*/int crossover(unsigned char *parent1,unsigned char *parent2,int k5) {int k,j,mutate,i1,i2,j5;int j1,j2,j3,s0,s1,s2; unsigned charjj,ts1[maxstring],ts2[maxstring];float f1,f2;s0=0;s1=0;s2=0;if(flip(pcross)){jcross=random(lchrom-1); j5=random(lchrom-1); ncross=ncross+1;if(jcross>j5){k=jcross;jcross=j5;j5=k;}}else jcross=lchrom; if(jcross!=lchrom) {s0=1;k=0;for(j=jcross;j<j5;j++) {ts1[k]=parent1[j]; ts2[k]=parent2[j]; k++; }j3=k;for(j=0;j<lchrom;j++) {j2=0;while((parent2[j]!=ts1[j2])&&(j2<k)){j2++;}if(j2==k){ts1[j3]=parent2[j];j3++;}}j3=k;for(j=0;j<lchrom;j++){j2=0;while((parent1[j]!=ts2[j2])&&(j2<k)){j2++;}if(j2==k){ts2[j3]=parent1[j];j3++;}}for(j=0;j<lchrom;j++){newpop[k5].chrom[j]=ts1[j];newpop[k5+1].chrom[j]=ts2[j]; }}else{for(j=0;j<lchrom;j++){newpop[k5].chrom[j]=parent1[j]; newpop[k5+1].chrom[j]=parent2[j]; } mutate=flip(pmutation);if(mutate){s1=1;nmutation=nmutation+1;for(j3=0;j3<200;j3++){j1=random(lchrom);j=random(lchrom);jj=newpop[k5].chrom[j];newpop[k5].chrom[j]=newpop[k5].chrom[j1];newpop[k5].chrom[j1]=jj;}}mutate=flip(pmutation);if(mutate){s2=1;nmutation=nmutation+1;for(j3=0;j3<100;j3++){j1=random(lchrom);j=random(lchrom);jj=newpop[k5+1].chrom[j];newpop[k5+1].chrom[j]=newpop[k5+1].chrom[j1];newpop[k5+1].chrom[j1]=jj;}}}j2=random(2*lchrom/3);for(j=j2;j<j2+lchrom/3-1;j++)for(k=0;k<lchrom;k++){if(k==j)continue;if(k>j){i2=k;i1=j;}else{i1=k;i2=j;}f1=dd[lchrom*newpop[k5].chrom[i1]+newpop[k5].chrom[i2]]; f1=f1+dd[lchrom*newpop[k5].chrom[(i1+1)%lchrom]+newpop[k5].chrom[(i2+1)%lchrom]];f2=dd[lchrom*newpop[k5].chrom[i1]+newpop[k5].chrom[(i1+1)%lchrom]];f2=f2+dd[lchrom*newpop[k5].chrom[i2]+newpop[k5].chrom[(i2+1)%lchrom]];if(f1<f2){inversion(i1,i2,newpop[k5].chrom);}}j2=random(2*lchrom/3);for(j=j2;j<j2+lchrom/3-1;j++)for(k=0;k<lchrom;k++){if(k==j)continue;if(k>j){i2=k;i1=j;}else{i1=k;i2=j;}f1=dd[lchrom*newpop[k5+1].chrom[i1]+newpop[k5+1].chrom[i2]];f1=f1+dd[lchrom*newpop[k5+1].chrom[(i1+1)%lchrom]+newpop[k5+1].chrom[(i2+1)%lchrom]];f2=dd[lchrom*newpop[k5+1].chrom[i1]+newpop[k5+1].chrom[(i1+1)%lchrom]];f2=f2+dd[lchrom*newpop[k5+1].chrom[i2]+newpop[k5+1].chrom[(i2+1)%lchrom]];if(f1<f2){inversion(i1,i2,newpop[k5+1].chrom);} }return 1;}/*$$$$$$$$$$$$$$$*/void inversion(unsigned int k,unsigned int j,unsigned char *ss) {unsigned int l1,i;unsigned char tt;l1=(j-k)/2;for(i=0;i<l1;i++){tt=ss[k+i+1];ss[k+i+1]=ss[j-i];ss[j-i]=tt;}}/*%%%%%%%%%%%%%%%*/void randomize1(){int i;randomize();for(i=0;i<lchrom;i++) oldrand[i]=random(30001)/30000.0;jrand=0;}/*%%%%%%%%%%%*/float random1(){jrand=jrand+1;if(jrand>=lchrom){jrand=0;randomize1();}return oldrand[jrand]; }/*%%%%%%%%%%*/int flip(float probability) {float ppp;ppp=random(20001)/20000.0; if(ppp<=probability)return 1; return 0;}%TSP问题(又名:旅行商问题，货郎担问题)遗传算法通用matlab程序 %D是距离矩阵，n为种群个数,建议取为城市个数的1~2倍， %C为停止代数，遗传到第 C 代时程序停止,C的具体取值视问题的规模和耗费的时间而定%m为适应值归一化淘汰加速指数 ,最好取为1,2,3,4 ,不宜太大 %alpha为淘汰保护指数,可取为0~1之间任意小数,取1时关闭保护功能,最好取为0.8~1.0 %R为最短路径,Rlength为路径长度function [R,Rlength]=geneticTSP(D,n,C,m,alpha)[N,NN]=size(D);farm=zeros(n,N);%用于存储种群for i=1:nfarm(i,:)=randperm(N);%随机生成初始种群endR=farm(1,:);%存储最优种群len=zeros(n,1);%存储路径长度fitness=zeros(n,1);%存储归一化适应值counter=0;while counter<Cfor i=1:nlen(i,1)=myLength(D,farm(i,:));%计算路径长度endmaxlen=max(len);minlen=min(len);fitness=fit(len,m,maxlen,minlen);%计算归一化适应值rr=find(len==minlen);R=farm(rr(1,1),:);%更新最短路径FARM=farm;%优胜劣汰，nn记录了复制的个数nn=0;for i=1:nif fitness(i,1)>=alpha*rand nn=nn+1;FARM(nn,:)=farm(i,:);endendFARM=FARM(1:nn,:);[aa,bb]=size(FARM);%交叉和变异while aa<nif nn<=2nnper=randperm(2);elsennper=randperm(nn);endA=FARM(nnper(1),:);B=FARM(nnper(2),:);[A,B]=intercross(A,B); FARM=[FARM;A;B]; [aa,bb]=size(FARM);endif aa>nFARM=FARM(1:n,:);%保持种群规模为nendfarm=FARM;clear FARMcounter=counter+1endRlength=myLength(D,R);function [a,b]=intercross(a,b) L=length(a); if L<=10%确定交叉宽度W=1;elseif ((L/10)-floor(L/10))>=rand&&L>10W=ceil(L/10);elseW=floor(L/10);endp=unidrnd(L-W+1);%随机选择交叉范围，从p到p+W for i=1:W%交叉x=find(a==b(1,p+i-1)); y=find(b==a(1,p+i-1)); [a(1,p+i-1),b(1,p+i-1)]=exchange(a(1,p+i-1),b(1,p+i-1));[a(1,x),b(1,y)]=exchange(a(1,x),b(1,y));endfunction [x,y]=exchange(x,y) temp=x;x=y;y=temp;% 计算路径的子程序function len=myLength(D,p) [N,NN]=size(D);len=D(p(1,N),p(1,1)); for i=1:(N-1)len=len+D(p(1,i),p(1,i+1));end%计算归一化适应值子程序function fitness=fit(len,m,maxlen,minlen) fitness=len;for i=1:length(len)fitness(i,1)=(1-((len(i,1)-minlen)/(maxlen-minlen+0.000001))).^m;end。
(完整版)遗传算法c语言代码
遗传算法代码# iiiclude<stdio.h>#mclude<stnng.h> #mclude<stdlib.h> #mclude<math.h> #mclude<tmie.h>^define cities 10 〃城市的个数 ^define MAXX ]00//迭代次数 #define pc 0.8 〃交配概率 #define pm 0.05 〃变异概率 ^define num 10〃种群的人小 int bestsolution;//最优染色体int distance[cities] [cities];// 城市之间的距离stmct group //染色体的结构{int city [cities];// 城市的顺序int adapt;// 适应度 double p 〃在种群中的幸存概率} group [num] ,grouptemp [num];〃随机产生10个城市之间的相互距离 voidinit(){intij ；meniset(distance.0.sizeof(distance)); srand((uiisigned)tuue(NULL)); fbr(i=O ;i<cities;i++){fbr(j=i+l ;j<cities J++){distance [i] [j]=rand()% 100; distance[j][i]=distance[i]Ij];} }fbr(i=O;i<cities;i++)printf( ”************ 城市的距离矩阵如下************\ii n );pruitf(M%4d H,distance[i][j]);}}〃随机产生初试群void groupproduceQ{mt i j 丄k,flag;fbi(i=O ;i<num; i++) //初始化for(j=OJ<citiesj++) group[i].city[j]=-l;srand((uiisigned)tuue(NULL));fbi(i=O ;i<num: i++)血(J=Oj<citi 亡s;){ t=rand()%cities;flag=l;for(k=0;k<j;k++){if(group[i] .city[k]=t){flag=O;break:}} if(flag){group[i].city|j]=t; J++;}}}pnntfC************ 初始种群如下^***************^)；fbi(i=0;i<num: i++)血(J=0 J <citi 亡s;j++) pimtf(M%4d,\gioup[i].city[j]);〃评价函数，找岀最优染色体void pmgjiaQint ij;iiit nl,ii2;mt sumdistance5biggestsum=O; double biggestp=O;fdr(i=O;i<num; i++){sumdistance=O;{nl=group[i].city|j-l];n2=group[i].city[j]; sumdistance4-=distance[nl][n2];}group [1] .adapt=sumd istaiice; 〃每条染色体的路径总和biggestsum+=sumdistance; 〃种群的总路径}fbi(i=O ;i<num: i++){group [i].p= 1 -(double)gioup(i] .adapt/(double)biggestsum;biggestp+=group[i].p;}fbi(i=O ;i<num: i++)gioup[i] .p=gioup[i] .p./biggestp;〃求最佳路劲bestsolution=0;fbi(i=O ;i<num: i++) if(gioup[i].p>gioup[bestsolution].p) bestsolution=i; }〃选择void xuanzeQ{mt ij^temp;double gradient[num]^/梯度概率double xuaiize[num];//选择染色体的随机概率mt xuaii[num];//选择了的染色体〃初始化梯度概率fbi(i=O ;i<num: i++)gradient[i]=O.O; xuaiize[i]=O.O;}gradient[0]=gioup[0].p;fbr(i= 1 ;i<num:i++)gradient[i]=gradient[i-1 ]+group[i] .p; srand((uiisigned)tune(NULL));〃随机产生染色体的存活概率fdr(i=O;i<num: i++){xuanze[i]=(rand()% 100); xuaiize[i]/=100;}〃选择能生存的染色体fdr(i=0;i<num: i++){{if(xu aiize [i] <gradient [j ]){xuan[i]=j; //第i个位置存放第j个染色体break;}}}〃拷贝种群fdr(i=0;i<num: i++){grouptenip [i]. adapt=gioup [i].adapt;giouptemp[i] .p=group[i] .p；fbi(j=0 j <cities;j ++)grouptenip [i].citv|j]=group [i]. c ity[j ];}〃数据更新fdr(i=0;i<num: i++){temp=xuan[i];groupfi] .adapt=giouptemp[temp] .adapt;group [1] .p=giouptemp [temp] .p;fbi(j=0 j <cities;j ++)group[i].city[j]=grouptemp[tenip].city[j]；〃变异void bianyiQ{intij;mt t;mt temp 1 ,temp2.point;double buinyip[num]; 〃染色体的变异概率mtbianyiflag[num];//染色体的变异情况fbi(i=O ;i<num: i++)〃初始化bianyiflag[i]=O;〃随机产生变异概率srand((uiisigned)tune(NULL));fbi(i=O ;i<num: i++){bianyip[i]=(rand()% 100); bianyip[i]/=100;}〃确定可以变异的染色体t=0;for(i=0 ;i<num; i++){if(biaiivip[i]<pm){ biaiiviflag[i]=l; t++；}}〃变异操作，即交换染色体的两个节点srand((iuisigned)tiine(NULL));for(i=0 ;i<num; i++){if(biaiiviflag[i]== 1){templ=rand()%10;temp2=rand()% 10;pomt=group[i]・ city[temp 1 ]; group [i]. city [temp1 ]=gioup [1]. city [temp2 ]; group[i] .city[temp2]=pomt;o e :a【n d(XXVINV£3n¥fo C T bB U T doQonpo】ddno・bb O -S Hg o q o ・Teqo「(£2】o o y )U S S A S()UTCU 二UTo lunp 」f (A R §o q o )2wl^20q o ^.・o %w uc o sXUTPsqsns^******** ***************^f l 】0 A)近士定—障尉QTry f ******************5-:************* **********⑧ 琛c>^建翠 唳********************=)七.s】d宀(dcl.mdno乩z'uxpt%-®^^・・)七宀「(曰目。
遗传算法的C语言实现（二）-----以求解TSP问题为例
遗传算法的C语⾔实现（⼆）-----以求解TSP问题为例上⼀次我们使⽤遗传算法求解了⼀个较为复杂的多元⾮线性函数的极值问题，也基本了解了遗传算法的实现基本步骤。
这⼀次，我再以经典的TSP问题为例，更加深⼊地说明遗传算法中选择、交叉、变异等核⼼步骤的实现。
⽽且这⼀次解决的是离散型问题，上⼀次解决的是连续型问题，刚好形成对照。
⾸先介绍⼀下TSP问题。
TSP(traveling salesman problem,旅⾏商问题)是典型的NP完全问题，即其最坏情况下的时间复杂度随着问题规模的增⼤按指数⽅式增长，到⽬前为⽌还没有找到⼀个多项式时间的有效算法。
TSP问题可以描述为：已知n个城市之间的相互距离，某⼀旅⾏商从某⼀个城市出发，访问每个城市⼀次且仅⼀次，最后回到出发的城市，如何安排才能使其所⾛的路线最短。
换⾔之，就是寻找⼀条遍历n个城市的路径，或者说搜索⾃然⼦集X={1,2,...,n}(X的元素表⽰对n个城市的编号)的⼀个排列P(X)={V1,V2,....,Vn},使得Td=∑d(V i,V i+1)+d(V n,V1)取最⼩值，其中,d(V i,V i+1)表⽰城市V i到V i+1的距离。
TSP问题不仅仅是旅⾏商问题，其他许多NP完全问题也可以归结为TSP问题，如邮路问题，装配线上的螺母问题和产品的⽣产安排问题等等，也使得TSP问题的求解具有更加⼴泛的实际意义。
再来说针对TSP问题使⽤遗传算法的步骤。
（1）编码问题：由于这是⼀个离散型的问题，我们采⽤整数编码的⽅式，⽤1~n来表⽰n个城市，1~n的任意⼀个排列就构成了问题的⼀个解。
可以知道，对于n个城市的TSP问题，⼀共有n!种不同的路线。
(2)种群初始化：对于N个个体的种群，随机给出N个问题的解（相当于是染⾊体）作为初始种群。
这⾥具体采⽤的⽅法是：1,2，...,n作为第⼀个个体，然后2,3，..n分别与1交换位置得到n-1个解，从2开始，3,4,...,n分别与2交换位置得到n-2个解，依次类推。
遗传算法案例及源代码
计算智能作业三：遗传算法计算问题1.问题描述：求下述二元函数的最大值：222121),(m ax x x x x f +=S.t. }7,6,5,4,3,2,1{1∈x }7,6,5,4,3,2,1{2∈x2.程序结构：（1）变量：C ：是一个1*6数组，每个数组里面是一个6位二进制数，它是遗传算法中的染色体。
new_c:每一轮的新变量c 。
first_c:初始群体矩阵。
sur_value ：个体适应值的概率值，为0-1之间的数，所有概率值和为1。
survived ：经过选择运算后产生的个体基因型组合。
intersect_c ：经过交叉运算后产生的个体基因型组合。
mutation_c ：经过变异运算后产生的个体基因型组合。
f ：最后计算得到的最大值 （2）程序里面的方程function out = value_function( ci )：价值函数（自适应度函数），即222121),(x x x x f +=。
function [ sur_value ] = calc_value( c )：计算群体中每一个个体的适应度的值function survived = surviver( sur_value )：利用概率选择函数 function [ intersect_c ] = intersect( new_c )：交叉运算function [ mutation_c ,mutation_value] = mutation( intersect_c )：变异运算3.源程序（1）遗传算法的主程序主程序包括初始群体产生，最终结果展示，即各函数之间的调用关系。
个体编码遗传算法的运算对象是表示个体的符号串，所以必须把变量 x1, x2 编码为无符号二进制整数。
这个二进制整数位个体的基因型。
因为x1, x2 为 0 ~ 7之间的整数，所以分别用3位无符号二进制整数来表示，将它们连接在一起所组成的6位无符号二进制数就形成了个体的基因型，表示一个可行解。
用遗传算法求解多目标函数优化c++程序
遗传算法是一种优化搜索方法，它模拟了自然选择和遗传学中的一些概念，如基因突变、交叉和选择。
这种方法可以用于解决多目标优化问题，其中多个目标之间可能存在冲突。
以下是一个使用C++和OpenCV库实现遗传算法的基本示例。
这个例子解决的是一个简单的多目标优化问题，目标是找到一个最优的图像分割方案，使得两个目标（分割的精度和计算的效率）同时最大化。
注意：这个示例是为了演示遗传算法的基本概念，并不一定适用于所有问题。
你可能需要根据你的具体需求来调整遗传算法的参数和约束条件。
```cpp#include <iostream>#include <vector>#include <algorithm>#include <opencv2/opencv.hpp>// 多目标函数优化struct ObjectiveFunction {std::vector<double> values;void operator()(const std::vector<double>& x) const {// 这里应该根据你的具体问题来定义函数的具体形式// 这里只是一个简单的示例，只考虑了分割精度和计算效率两个目标values.resize(x.size(), 0); // 初始化所有目标值为0values[0] = 1.0; // 精度目标values[1] = 1.0; // 效率目标}};class GeneticAlgorithm {public:GeneticAlgorithm(int populationSize, int generations, double crossoverRate, double mutationRate) : populationSize(populationSize), generations(generations), crossoverRate(crossoverRate), mutationRate(mutationRate) {} std::vector<std::vector<double>> optimize(const std::vector<std::vector<double>>& inputs) {std::vector<std::vector<double>>bestSolution(inputs.size(),std::vector<double>(populationSize, 0)); // 初始化最优解double bestScore = -1; // 初始最佳分数为-1，通常需要先运行一次算法以找到初始最佳分数for (int generation = 0; generation <generations; ++generation) {std::vector<std::vector<double>>population(populationSize,std::vector<double>(populationSize, 0)); // 初始化种群for (int i = 0; i < populationSize; ++i) { std::vector<double>randomSolution(inputs.size(), 0); // 随机生成解for (int j = 0; j < inputs.size(); ++j) {randomSolution[j] = inputs[j][rand() % inputs[j].size()]; // 在输入范围内随机选择一个数作为解}population[i] = randomSolution; // 将随机解加入种群}while (!population.empty()) { // 当种群不为空时继续迭代std::sort(population.begin(), population.end(), [](const std::vector<double>& a, const std::vector<double>& b) { // 对种群进行排序，根据适应度进行排序（这里适应度是解的分数）return ObjectiveFunction()(a) > ObjectiveFunction()(b); // 如果分数更高，则适应度更好，优先选择这个解作为下一代解的一部分});std::vector<double>nextGeneration(population[0]); // 选择当前种群中的第一个解作为下一代解的一部分for (int j = 1; j < populationSize; ++j) { // 对剩余的解进行交叉和变异操作，生成下一代解if (rand() / double(RAND_MAX) < crossoverRate) { // 如果满足交叉条件，则进行交叉操作for (int k = 0; k < inputs.size(); ++k) { // 将两个解的部分基因进行交叉操作，生成新的基因序列nextGeneration[k] = population[j][k]; // 将两个解的部分基因复制到下一代解中if (rand() / double(RAND_MAX) < mutationRate) { // 如果满足变异条件，则对部分基因进行变异操作，增加种群的多样性nextGeneration[k] = nextGeneration[k] * (1 - mutationRate) + population[j][k] * mutationRate; // 对部分基因进行变异操作，增加种群的多样性}}} else { // 如果不满足交叉条件，则直接复制当前解作为下一代解的一部分for (int k = 0; k < inputs.size(); ++k) { // 将当前解的部分基因复制到下一代解中 nextGeneration[k] = population[。
遗传算法求解函数极值C语言代码
#include "stdio.h"#include "stdlib.h"#include "conio.h"#include "math.h"#include "time.h"#define num_C 12 //个体的个数，前6位表示x1，后6位表示x2 #define N 100 //群体规模为100#define pc 0.9 //交叉概率为0.9#define pm 0.1 //变异概率为10%#define ps 0.6 //进行选择时保留的比例#define genmax 2000 //最大代数200int RandomInteger(int low,int high);void Initial_gen(struct unit group[N]);void Sort(struct unit group[N]);void Copy_unit(struct unit *p1,struct unit *p2);void Cross(struct unit *p3,struct unit *p4);void Varation(struct unit group[N],int i);void Evolution(struct unit group[N]);float Calculate_cost(struct unit *p);void Print_optimum(struct unit group[N],int k);/* 定义个体信息*/typedef struct unit{int path[num_C]; //每个个体的信息double cost; //个体代价值};struct unit group[N]; //种群变量groupint num_gen=0; //记录当前达到第几代int main(){int i,j;srand((int)time(NULL)); //初始化随机数发生器Initial_gen(group); //初始化种群Evolution(group); //进化：选择、交叉、变异getch();return 0;}/* 初始化种群*/void Initial_gen(struct unit group[N]){int i,j;struct unit *p;for(i=0;i<=N-1;i++) //初始化种群里的100个个体{p=&group[i]; //p指向种群的第i个个体for(j=0;j<12;j++){p->path[j]=RandomInteger(0,9); //end }Calculate_cost(p); //计算该种群的函数值}//end 初始化种群}/* 种群进化，进化代数由genmax决定*/void Evolution(struct unit group[N]){int i,j;int temp1,temp2,temp3,temp4,temp5;temp1=N*pc/2;temp2=N*(1-pc);temp3=N*(1-pc/2);temp4=N*(1-ps);temp5=N*ps;for(i=1;i<=genmax;i++){//选择for(j=0;j<=temp4-1;j++){ Copy_unit(&group[j],&group[j+temp5]); }//交叉for(j=0;j<=temp1-1;){Cross(&group[temp2+j],&group[temp3+j]);j+=2;}//变异Varation(group,i);}Sort(group);Print_optimum(group,i-1); //输出当代(第i-1代)种群}/* 交叉*/void Cross(struct unit *p3,struct unit *p4){int i,j,cross_point;int son1[num_C],son2[num_C];for(i=0;i<=num_C-1;i++) //初始化son1、son2{son1[i]=-1;son2[i]=-1;}cross_point=RandomInteger(1,num_C-1); //交叉位随机生成//交叉，生成子代//子代1//子代1前半部分直接从父代复制for(i=0;i<=cross_point-1;i++) son1[i]=p3->path[i];for(i=cross_point;i<=num_C-1;i++)for(j=0;j<=num_C-1;j++) //补全p1{son1[i]=p4->path[j];}//end 子代1//子代2//子代1后半部分直接从父代复制for(i=cross_point;i<=num_C-1;i++) son2[i]=p4->path[i];for(i=0;i<=cross_point-1;i++){for(j=0;j<=num_C-1;j++) //补全p1{son2[i]=p3->path[j];}}//end 子代2//end 交叉for(i=0;i<=num_C-1;i++){p3->path[i]=son1[i];p4->path[i]=son2[i];}Calculate_cost(p3); //计算子代p1的函数值Calculate_cost(p4); //计算子代p2的函数值}/* 变异*/void Varation(struct unit group[N],int flag_v){int flag,i,j,k,temp;struct unit *p;flag=RandomInteger(1,100);//在进化后期，增大变异概率if((!flag>(flag_v>100))?(5*100*pm):(100*pm)){i=RandomInteger(0,N-1); //确定发生变异的个体j=RandomInteger(0,num_C-1); //确定发生变异的位k=RandomInteger(0,num_C-1);p=&group[i]; //变异temp=p->path[j];p->path[j]=p->path[k];p->path[k]=temp;Calculate_cost(p); //重新计算变异后的函数值}}/* 将种群中个体按函数值从小到大排序*/void Sort(struct unit group[N]){int i,j;struct unit temp,*p1,*p2;for(j=1;j<=N-1;j++) //排序总共需进行N-1轮{for(i=1;i<=N-1;i++){p1=&group[i-1];p2=&group[i];if(p1->cost>p2->cost) //值大的往后排{Copy_unit(p1,&temp);Copy_unit(p2,p1);Copy_unit(&temp,p2);}}//end 一轮排序}//end 排序}/* 计算某个个体的函数值*/float Calculate_cost(struct unit *p){double x1,x2;x1=0;if(p->path[0]>5){x1=p->path[1]+p->path[2]*0.1+p->path[3]*0.01+p->path[4]*0.001+p->path[5]*0.0001;}else if(p->path[0]<6){x1=0-(p->path[1]+p->path[2]*0.1+p->path[3]*0.01+p->path[4]*0.001+p->path[5]*0.0001);}x2=0;if(p->path[6]>5){}else if(p->path[6]<6){x2=0-(p->path[7]+p->path[8]*0.1+p->path[9]*0.01+p->path[10]*0.001+p->path[11]*0.0001);}p->cost=20+x1*x1+x2*x2-10*(cos(2*3.14*x1)+cos(2*3.14*x2));return(p->cost);}/* 复制种群中的p1到p2中*/void Copy_unit(struct unit *p1,struct unit *p2){int i;for(i=0;i<=num_C-1;i++)p2->path[i]=p1->path[i];p2->cost=p1->cost;}/* 生成一个介于两整型数之间的随机整数*/int RandomInteger(int low,int high){int k;double d;k=rand();k=(k!=RAND_MAX)?k:(k-1); //RAND_MAX是VC中可表示的最大整型数d=(double)k/((double)(RAND_MAX));k=(int)(d*(high-low+1));return (low+k);}/* 输出当代种群中的最优个体*/void Print_optimum(struct unit group[N],int k){struct unit *p;double x1,x2;x1=x2=0;p=&group[0];if(p->path[0]>5){x1=p->path[1]+p->path[2]*0.1+p->path[3]*0.01+p->path[4]*0.001+p->path[5]*0.0001;}else if(p->path[0]<6){}x2=0;if(p->path[6]>5){x2=p->path[7]+p->path[8]*0.1+p->path[9]*0.01+p->path[10]*0.001+p->path[11]*0.0001;}else if(p->path[6]<6){x2=0-(p->path[7]+p->path[8]*0.1+p->path[9]*0.01+p->path[10]*0.001+p->path[11]*0.0001);}printf(" 当x1=%f x2=%f\n",x1,x2);printf(" 函数最小值为：%f \n",p->cost);}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
遗传算法的C语言程序案例一、说明1．本程序演示的是用简单遗传算法随机一个种群，然后根据所给的交叉率，变异率，世代数计算最大适应度所在的代数2．演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的命令；相应的输入数据和运算结果显示在其后。
3．举个例子，输入初始变量后，用y= (x1*x1)+(x2*x2)，其中-2.048<=x1,x2<=2.048作适应度函数求最大适应度即为函数的最大值4．程序流程图5．类型定义int popsize; //种群大小int maxgeneration; //最大世代数double pc; //交叉率double pm; //变异率struct individual{char chrom[chromlength+1];double value;double fitness; //适应度};int generation; //世代数int best_index;int worst_index;struct individual bestindividual; //最佳个体struct individual worstindividual; //最差个体struct individual currentbest;struct individual population[POPSIZE];3．函数声明void generateinitialpopulation();void generatenextpopulation();void evaluatepopulation();long decodechromosome(char *,int,int);void calculateobjectvalue();void calculatefitnessvalue();void findbestandworstindividual();void performevolution();void selectoperator();void crossoveroperator();void mutationoperator();void input();void outputtextreport();6．程序的各函数的简单算法说明如下：（1）．void generateinitialpopulation ()和void input ()初始化种群和遗传算法参数。
input() 函数输入种群大小，染色体长度，最大世代数，交叉率，变异率等参数。
（2）void calculateobjectvalue();计算适应度函数值。
根据给定的变量用适应度函数计算然后返回适度值。
（3）选择函数selectoperator()在函数selectoperator()中首先用rand ()函数产生0～1间的选择算子，当适度累计值不为零时，比较各个体所占总的适应度百分比的累计和与选择算子，直到达到选择算子的值那个个体就被选出，即适应度为fi的个体以fi/∑fk的概率继续存在；显然，个体适应度愈高，被选中的概率愈大。
但是，适应度小的个体也有可能被选中，以便增加下一代群体的多样性。
（4）染色体交叉函数crossoveroperator()这是遗传算法中的最重要的函数之一，它是对个体两个变量所合成的染色体进行交叉，而不是变量染色体的交叉，这要搞清楚。
首先用rand ()函数产生随机概率，若小于交叉概率，则进行染色体交叉，同时交叉次数加1。
这时又要用rand()函数随机产生一位交叉位，把染色体的交叉位的后面部分交叉即可；若大于交叉概率，则进行简单的染色体复制即可。
（5）染色体变异函数mutation()变异是针对染色体字符变异的，而不是对个体而言，即个体变异的概率是一样。
随机产生比较概率，若小于变异概率，则1变为0，0变为1，同时变异次数加1。
（6）long decodechromosome(char *,int,int)本函数是染色体解码函数，它将以数组形式存储的二进制数转成十进制数，然后才能用适应度函数计算。
（7）void findbestandworstindividual()本函数是求最大适应度个体的，每一代的所有个体都要和初始的最佳比较，如果大于就赋给最佳。
（8）void outputtextreport () 输出种群统计结果输出每一代的种群的最大适应度和平均适应度，最后输出全局最大值二、运行环境本程序的开发工具是VC++，在VC++下运行。
源代码#include"stdafx.h"#include <stdio.h>#include <stdlib.h>#include <time.h>/////////////The definiton of user data 定义用户数据////#define Cmax 100 //certain maximal value#define Cmin 0 //certain minimum value#define LENGHT1 3#define LENGHT2 3//总染体长度#define CHROMLENGTH LENGHT1+LENGHT2const int MaxGeneration = 100;const int PopSize = 10;const double Pc = 0.6;const double Pm = 0.001;////////////// 数据结构定义///////////////////struct Individual{char chrom[CHROMLENGTH + 1];double value;double fitness;int generation ;int bestIndex;int worstIndex;Individual bestIndividual ;Individual worstIndividual ;// best individual by nowIndividual currentBest ;Individual population [PopSize] ;///////////////////////void generateInitialPopulation();void generateNextPopulation();void evalutePopulation();long decomdeChromosome(char*, int, int); void calculateObjectValue();void calculateFitnessValue();void findBestAndWorstIndividual();void performEvolution();void selectionOperator();void crossoverOperator();void mutationOperator();void outputTextReport();//以上为函数以及全局变量定义部分int main(){generation = 0; generateInitialPopulation(); evalutePopulation();while (generation < MaxGeneration) { generation++; generateNextPopulation(); evalutePopulation();performEvolution();outputTextReport();}system("pause");return 0;}////////////////////////////////////////////////////////////////////产生第一代样本/////void generateInitialPopulation() {int i, j;srand((unsigned)time(NULL));for (i = 0; i < PopSize; i++) {for (j = 0; j < CHROMLENGTH; j++) {population[i].chrom[j] = ((rand() % 10) < 5) ? '0' : '1';}population[i].chrom[CHROMLENGTH] ='/0';}}////////产生下一代样本//////void generateNextPopulation() {selectionOperator();crossoverOperator();mutationOperator();}//变异算子//void mutationOperator() {int i, j;double p;// bit mutationfor (i = 0; i < PopSize; i++) {for (j = 0; j < CHROMLENGTH; j++) {p = rand() % 1000 / 1000.0;if (p < Pm) {population[i].chrom[j] = (population[i].chrom[j] == '0') ? '1': '0'; }}}}//交叉算子///void crossoverOperator() {int i, j;int index[PopSize];int point, temp;double p;char ch;for (i = 0; i < PopSize; i++) {index[i] = i;}for (i = 0; i < PopSize; i++) {point = rand() %(PopSize - i);temp = index[i];index[i] = index[point + i];index[point + i] = temp;}for (i = 0; i < PopSize - 1; i+=2) {p = rand() % 1000 / 1000.0;if (p < Pc) {point = rand()% (CHROMLENGTH - 1) + 1;for (j = point; j < CHROMLENGTH; j++) {ch = population[index[i]].chrom[j];population[index[i]].chrom[j] = population[index[i + 1]].chrom[j]; population[index[i + 1]].chrom[j] = ch;}}}}///选择算子/////////////void selectionOperator() {int i, index;double p, sum = 0.0;double cfitness[PopSize];Individual newpopulation[PopSize];for (i = 0; i < PopSize; i++) {sum += population[i].fitness;}for (i = 0; i < PopSize; i++) {cfitness[i] = population[i].fitness / sum;}// calculate cumulative fitnessfor (i = 1; i < PopSize; i++) {cfitness[i] = cfitness[i] + cfitness[i - 1];}for (i = 0; i < PopSize; i++) {p = rand() % 1000 / 1000.0;index = 0;while (p > cfitness[index]) {index++;}newpopulation[i] = population[index];}for (i = 0; i < PopSize; i++) {population[i] = newpopulation[i]; /}}/////依据某些公式对样本进行评价////void evalutePopulation() {calculateObjectValue();calculateFitnessValue(); findBestAndWorstIndividual(); /}//找出到目前为止最好的个体//////void findBestAndWorstIndividual() {int i;double sum = 0.0;bestIndividual = population[0];worstIndividual = population[0];for (i = 0; i < PopSize; i++) {if (population[i].fitness > bestIndividual.fitness) { bestIndividual = population[i];bestIndex = i;} else if (population[i].fitness < worstIndividual.fitness) { worstIndividual = population[i];worstIndex = i;}sum += population[i].fitness;}if (generation == 0) {currentBest = bestIndividual;} else {if (bestIndividual.fitness > currentBest.fitness) {currentBest = bestIndividual;}}}//计算适应度///void calculateFitnessValue() {int i;long temp1, temp2;double x1, x2;for (i = 0; i < PopSize; i++) {temp1 = decomdeChromosome(population[i].chrom, 0, LENGHT1);temp2 = decomdeChromosome(population[i].chrom, LENGHT1, LENGHT2); x1 = temp1 * temp1;x2 = temp2 * temp2;population[i].fitness = x1+x2; //x1平方加上x2平方}}//计算目标值//目标函数为f(x) = x1* x1 + x2*x2void calculateObjectValue() {int i;long temp1, temp2;double x1, x2;for (i = 0; i < PopSize; i++) {temp1 = decomdeChromosome(population[i].chrom, 0, LENGHT1);temp2 = decomdeChromosome(population[i].chrom, LENGHT1, LENGHT2); x1 = temp1 * temp1;x2 = temp2 * temp2;population[i].value = x1 + x2;}}//把二进制转化为十进制long decomdeChromosome(char* string, int point, int length) {int i;long decimal = 0L;char * pointer;for(i = 0, pointer=string+point; i < length;i++,pointer++){decimal += (*pointer - '0') << (length - 1 - i);}return decimal;}//进经同时把最坏个体用目前最好个体替代///void performEvolution() {if (bestIndividual.fitness > currentBest.fitness) {currentBest = population[bestIndex];} else {population[worstIndex] = currentBest;}}//打印当前样本信息///void outputTextReport() {int i;double sum;double average;sum = 0.0;for (i = 0; i < PopSize; i++) {sum += population[i].value;}average = sum / PopSize;printf("gen=%d, avg=%f, best=%f",generation, average,currentBest.value); printf(" chromosome=");for( i = 0; i < CHROMLENGTH; i++){printf("%c", currentBest.chrom[i]);}printf("/n");}。