java 遗传算法

最新推荐文章于 2023-01-14 20:30:54 发布
最新推荐文章于 2023-01-14 20:30:54 发布
阅读量93 收藏
点赞数
分类专栏： java 文章标签： 算法 Java J#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ssg502/article/details/83885613
版权 
import
 java.util.
*
;


public
 
class
 Tsp {    
    
private
 String cityName[]
=
{
"
北京
"
,
"
上海
"
,
"
天津
"
,
"
重庆
"
,
"
哈尔滨
"
,
"
长春
"
,
"
沈阳
"
,
"
呼和浩特
"
,
"
石家庄
"
,
"
太原
"
,
"
济南
"
,
"
郑州
"
,
"
西安
"
,
"
兰州
"
,
"
银川
"
,
"
西宁
"
,
"
乌鲁木齐
"
,
"
合肥
"
,
"
南京
"
,
"
杭州
"
,
"
长沙
"
,
"
南昌
"
,
"
武汉
"
,
"
成都
"
,
"
贵州
"
,
"
福建
"
,
"
台北
"
,
"
广州
"
,
"
海口
"
,
"
南宁
"
,
"
昆明
"
,
"
拉萨
"
,
"
香港
"
,
"
澳门
"
};
    
//
private String cityEnd[]=new String[34];


    
private
 
int
 cityNum
=
cityName.length;                
//
城市个数


    
private
 
int
 popSize 
=
 
50
;                
//
种群数量


    
private
 
int
 maxgens 
=
 
20000
;            
//
迭代次数


    
private
 
double
 pxover 
=
 
0.8
;            
//
交叉概率


    
private
 
double
 pmultation 
=
 
0.05
;        
//
变异概率


    
private
 
long
[][] distance 
=
 
new
 
long
[cityNum][cityNum];
    
private
 
int
 range 
=
 
2000
;                
//
用于判断何时停止的数组区间


    
    
private
 
class
 genotype {
        
int
 city[] 
=
 
new
 
int
[cityNum];        
//
单个基因的城市序列


        
long
 fitness;                        
//
该基因的适应度


        
double
 selectP;                        
//
选择概率


        
double
 exceptp;                        
//
期望概率


        
int
 isSelected;                        
//
是否被选择


    }
    
private
 genotype[] citys 
=
 
new
 genotype[popSize];

    
/**

     *     构造函数，初始化种群
     
*/

    
public
 Tsp() {
        
for
 (
int
 i 
=
 
0
; i 
<
 popSize; i
++
) {
            citys[i] 
=
 
new
 genotype();
            
int
[] num 
=
 
new
 
int
[cityNum];
            
for
 (
int
 j 
=
 
0
; j 
<
 cityNum; j
++
)
                num[j] 
=
 j;
            
int
 temp 
=
 cityNum;
            
for
 (
int
 j 
=
 
0
; j 
<
 cityNum; j
++
) {
                
int
 r 
=
 (
int
) (Math.random() 
*
 temp);
                citys[i].city[j] 
=
 num[r];
                num[r] 
=
 num[temp 
-
 
1
];
                temp
--
;
            }
            citys[i].fitness 
=
 
0
;
            citys[i].selectP 
=
 
0
;
            citys[i].exceptp 
=
 
0
;
            citys[i].isSelected 
=
 
0
;
        }
        initDistance();
    }
    
    
/**

     *  计算每个种群每个基因个体的适应度，选择概率，期望概率，和是否被选择。
     
*/

    
public
 
void
 CalAll(){
        
for
( 
int
 i 
=
 
0
; i
<
 popSize; i
++
){
            citys[i].fitness 
=
 
0
;
            citys[i].selectP 
=
 
0
;
            citys[i].exceptp 
=
 
0
;
            citys[i].isSelected 
=
 
0
;
        }
        CalFitness();
        CalSelectP();
        CalExceptP();
        CalIsSelected();
    }

    
/**

     *     填充，将多选的填充到未选的个体当中
     
*/

    
public
 
void
 pad(){
        
int
 best 
=
 
0
;
        
int
 bad 
=
 
0
;
        
while
(
true
){            
            
while
(citys[best].isSelected 
<=
 
1
 
&&
 best
<
popSize
-
1
)
                best 
++
;
            
while
(citys[bad].isSelected 
!=
 
0
 
&&
 bad
<
popSize
-
1
)
                bad 
++
;
            
for
(
int
 i 
=
 
0
; i
<
 cityNum; i
++
)
                citys[bad].city[i] 
=
 citys[best].city[i];
                citys[best].isSelected 
--
;
                citys[bad].isSelected 
++
;
                bad 
++
;    
            
if
(best 
==
 popSize 
||
bad 
==
 popSize)
                
break
;
        }
    }
    
    
/**

     *     交叉主体函数
     
*/

    
public
 
void
 crossover() {
        
int
 x;
        
int
 y;
        
int
 pop 
=
 (
int
)(popSize
*
 pxover 
/
2
);
        
while
(pop
>
0
){
            x 
=
 (
int
)(Math.random()
*
popSize);
            y 
=
 (
int
)(Math.random()
*
popSize);
            
            executeCrossover(x,y);
//
x y 两个体执行交叉


            pop
--
;
        }
    }
    
    
/**

     * 执行交叉函数
     * 
@param
 个体x
     * 
@param
 个体y
     * 对个体x和个体y执行佳点集的交叉，从而产生下一代城市序列
     
*/

    
private
 
void
 executeCrossover(
int
 x,
int
 y){
        
int
 dimension 
=
 
0
;
        
for
( 
int
 i 
=
 
0
 ;i 
<
 cityNum; i
++
)
            
if
(citys[x].city[i] 
!=
 citys[y].city[i]){
                dimension 
++
;
            }    
        
int
 diffItem 
=
 
0
;
        
double
[] diff 
=
 
new
 
double
[dimension];

        
for
( 
int
 i 
=
 
0
 ;i 
<
 cityNum; i
++
){
            
if
(citys[x].city[i] 
!=
 citys[y].city[i]){
                diff[diffItem] 
=
 citys[x].city[i];
                citys[x].city[i] 
=
 
-
1
;
                citys[y].city[i] 
=
 
-
1
;
                diffItem 
++
;
            }    
        }
    
        Arrays.sort(diff);

        
double
[] temp 
=
 
new
 
double
[dimension];
        temp 
=
 gp(x, dimension);

        
for
( 
int
 k 
=
 
0
; k
<
 dimension;k
++
)
            
for
( 
int
 j 
=
 
0
; j
<
 dimension; j
++
)
                
if
(temp[j] 
==
 k){
                    
double
 item 
=
 temp[k];
                    temp[k] 
=
 temp[j];
                    temp[j] 
=
 item;
                    
                    item 
=
 diff[k];
                    diff[k] 
=
 diff[j];
                    diff[j] 
=
 item;    
                }
        
int
 tempDimension 
=
 dimension;
        
int
 tempi 
=
 
0
;

        
while
(tempDimension
>
 
0
 ){
            
if
(citys[x].city[tempi] 
==
 
-
1
){
                citys[x].city[tempi] 
=
 (
int
)diff[dimension 
-
 tempDimension];
                
                tempDimension 
--
;
            }    
            tempi 
++
;
        }

        Arrays.sort(diff);

        temp 
=
 gp(y, dimension);

        
for
( 
int
 k 
=
 
0
; k
<
 dimension;k
++
)
            
for
( 
int
 j 
=
 
0
; j
<
 dimension; j
++
)
                
if
(temp[j] 
==
 k){
                    
double
 item 
=
 temp[k];
                    temp[k] 
=
 temp[j];
                    temp[j] 
=
 item;
                    
                    item 
=
 diff[k];
                    diff[k] 
=
 diff[j];
                    diff[j] 
=
 item;    
                }

        tempDimension 
=
 dimension;
        tempi 
=
 
0
;

        
while
(tempDimension
>
 
0
 ){
            
if
(citys[y].city[tempi] 
==
 
-
1
){
                citys[y].city[tempi] 
=
 (
int
)diff[dimension 
-
 tempDimension];
                
                tempDimension 
--
;
            }    
            tempi 
++
;
        }

    }
    
    
/**

     * 
@param
 individual 个体
     * 
@param
 dimension      维数
     * 
@return
 佳点集    (用于交叉函数的交叉点）    在executeCrossover()函数中使用
     
*/

    
private
 
double
[] gp(
int
 individual, 
int
 dimension){
        
double
[] temp 
=
 
new
 
double
[dimension];
        
double
[] temp1 
=
 
new
 
double
[dimension];
        
int
 p 
=
 
2
 
*
 dimension 
+
 
3
;

        
while
(
!
isSushu(p))
            p
++
;

        
for
( 
int
 i 
=
 
0
; i
<
 dimension; i
++
){
            temp[i] 
=
 
2
*
Math.cos(
2
*
Math.PI
*
(i
+
1
)
/
p) 
*
 (individual
+
1
);
            temp[i] 
=
 temp[i] 
-
 (
int
)temp[i];
            
if
( temp [i]
<
 
0
)
                temp[i] 
=
 
1
+
temp[i];

        }
        
for
( 
int
 i 
=
 
0
; i
<
 dimension; i
++
)
            temp1[i] 
=
 temp[i];
        Arrays.sort(temp1);    
        
//
排序


        
for
( 
int
 i 
=
 
0
; i
<
 dimension; i
++
)
            
for
( 
int
 j 
=
 
0
; j
<
 dimension; j
++
)
                
if
(temp[j]
==
temp1[i])
                    temp[j] 
=
 i;    
        
return
 temp;
    }
    
    
    
/**

     *     变异
     
*/

    
public
 
void
 mutate(){
        
double
 random;
        
int
 temp;
        
int
 temp1;
        
int
 temp2;
        
for
( 
int
 i 
=
 
0
 ; i
<
 popSize; i
++
){
            random 
=
 Math.random();
            
if
(random
<=
pmultation){
                temp1 
=
 (
int
)(Math.random() 
*
 (cityNum));
                temp2 
=
 (
int
)(Math.random() 
*
 (cityNum));
                temp 
=
 citys[i].city[temp1];
                citys[i].city[temp1] 
=
 citys[i].city[temp2];
                citys[i].city[temp2] 
=
 temp;

            }
        }        
    }
    
    
/**

     *    打印当前代数的所有城市序列，以及其相关的参数
     
*/

    
public
 
void
 print(){
    
/**

     * 初始化各城市之间的距离
     
*/

    
private
 
void
 initDistance(){
        
for
 (
int
 i 
=
 
0
; i 
<
 cityNum; i
++
) {
            
for
 (
int
 j 
=
 
0
; j 
<
 cityNum; j
++
){
                distance[i][j] 
=
 Math.abs(i
-
j);
            }
        }
    }
    
    
/**

     * 计算所有城市序列的适应度
     
*/

    
private
 
void
 CalFitness() {
        
for
 (
int
 i 
=
 
0
; i 
<
 popSize; i
++
) {
            
for
 (
int
 j 
=
 
0
; j 
<
 cityNum 
-
 
1
; j
++
)
                citys[i].fitness 
+=
 distance[citys[i].city[j]][citys[i].city[j 
+
 
1
]];
            citys[i].fitness 
+=
 distance[citys[i].city[
0
]][citys[i].city[cityNum 
-
 
1
]];
        }
    }
    
    
/**

     * 计算选择概率
     
*/

    
private
 
void
 CalSelectP(){
        
long
 sum 
=
 
0
;
        
for
( 
int
 i 
=
 
0
; i
<
 popSize; i
++
)
            sum 
+=
 citys[i].fitness;
        
for
( 
int
 i 
=
 
0
; i
<
 popSize; i
++
)
            citys[i].selectP 
=
 (
double
)citys[i].fitness
/
sum;

    }
    
    
/**

     * 计算期望概率
     
*/

    
private
 
void
 CalExceptP(){
        
for
( 
int
 i 
=
 
0
; i
<
 popSize; i
++
)
            citys[i].exceptp 
=
 (
double
)citys[i].selectP 
*
 popSize;
    }
    
    
/**

     * 计算该城市序列是否较优，较优则被选择，进入下一代
     
*/

    
private
 
void
 CalIsSelected(){
        
int
 needSelecte 
=
 popSize;
        
for
( 
int
 i 
=
 
0
; i
<
 popSize; i
++
)
            
if
( citys[i].exceptp
<
1
){
                citys[i].isSelected
++
;
                needSelecte 
--
;
            }
        
double
[] temp 
=
 
new
 
double
[popSize];
        
for
 (
int
 i 
=
 
0
; i 
<
 popSize; i
++
) {

//
            temp[i] = citys[i].exceptp - (int) citys[i].exceptp;

//
            temp[i] *= 10;


            temp[i] 
=
 citys[i].exceptp
*
10
;
        }
        
int
 j 
=
 
0
;
        
while
 (needSelecte 
!=
 
0
) {
            
for
 (
int
 i 
=
 
0
; i 
<
 popSize; i
++
) {
                
if
 ((
int
) temp[i] 
==
 j) {
                    citys[i].isSelected
++
;
                    needSelecte
--
;
                    
if
 (needSelecte 
==
 
0
)
                        
break
;
                }
            }
            j
++
;
        }
        
    }
    
    
/**

     * 
@param
 x
     * 
@return
 判断一个数是否是素数的函数
     
*/

    
private
 
boolean
 isSushu( 
int
 x){
           
if
(x
<
2
) 
return
 
false
;
           
for
(
int
 i
=
2
;i
<=
x
/
2
;i
++
)
           
if
(x
%
i
==
0
&&
x
!=
2
) 
return
 
false
;

           
return
 
true
;
        }
    
    
/**

     * 
@param
 x 数组
     * 
@return
 x数组的值是否全部相等，相等则表示x.length代的最优结果相同，则算法结束
     
*/

    
private
 
boolean
 isSame(
long
[] x){
        
for
( 
int
 i 
=
 
0
; i
<
 x.length 
-
1
; i
++
)
            
if
(x[i] 
!=
x[i
+
1
])
                
return
 
false
;
        
return
 
true
;
    }
    
    
/**

     * 打印任意代最优的路径序列
     
*/

    
private
 
void
 printBestRoute(){
        CalAll();
        
long
 temp 
=
 citys[
0
].fitness;
        
int
 index 
=
 
0
;
        
for
 (
int
 i 
=
 
1
; i 
<
 popSize; i
++
) {
            
if
(citys[i].fitness
<
temp){
                temp 
=
 citys[i].fitness;
                index 
=
 i;
            }
ssg502
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实例源代码, 各种例子都有
06-19
收集的一些小例子..............................................................
java源代码实例
javaDB_EAD的专栏
04-07 107
java哈弗曼编码的实现 Java code &lt;!-- Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ --&gt; //哈弗曼编码的实现类 public class HffmanCoding { privat...
java实例源码_求:java实例源代码
weixin_42166105的博客
02-12 111
展开全部import java.awt.*;import java.awt.event.*;import java.lang.*;import javax.swing.*;public class Counter extends Frame{//声明三个面板的布局GridLayout gl1,gl2,gl3;Panel p0,p1,p2,p3;JTextField tf1;TextField tf...
50个Java经典编程实例源代码
04-21
50个Java经典编程实例源代码
遗传算法(Genetic Algorithm)——基于Java实现
weixin_30819085的博客
04-18 1355
一、遗传算法原理介绍 　　遗传算法（Genetic Algorithm）是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。遗传算法是从代表问题可能潜在的解集的一个种群（population）开始的，而一个种群则由经过基因（gene）编码的一定数目的个体(individual)组成。每个个体实际上是染色体(chromosome)带有特...
1204 Java 遗传算法排课java sqlserver.rar_java排课算法_排课_排课系统java_遗传算法Java
07-14
Java遗传算法排课系统是一种利用遗传算法解决复杂优化问题的软件应用。在教育领域，排课是一个典型的组合优化问题，需要考虑多方面的约束条件，如教师时间冲突、教室容量限制、课程时间安排等。遗传算法作为一种启发...
深入理解Java遗传算法
09-02
Java遗传算法是一种基于生物进化理论的优化方法，它模拟了自然选择和遗传的过程来寻找问题的最优解。在Java中实现遗传算法时，通常会采用二进制编码的方式来表示基因，因为二进制编码简洁且易于操作。下面将详细介绍...
java_遗传算法_
09-29
Java遗传算法是一种应用了生物进化原理的优化技术，它通过模拟自然选择和遗传的过程来解决复杂问题。在Java中实现遗传算法，主要涉及到以下几个核心概念和技术： 1. **编码方式**：遗传算法中的个体通常被编码为二...
java遗传算法寻找最优路径
01-01
### Java遗传算法寻找最优路径 #### 一、遗传算法概览 遗传算法（Genetic Algorithm, GA）是一种基于自然选择和遗传学原理的全局优化技术。它通过模拟自然界中的生物进化过程来解决优化问题，包括搜索空间较大的...
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)个体适应...
遗传算法（GeneticAlgorithm）的Java实现源码工程
01-26
遗传算法（GeneticAlgorithm）的Java实现源码工程，可导入eclipse后可直接运行工程，main方法在类GeneticAlgorithmTest文件中。带有图形界面动态展示遗传算法的收敛过程。你可以在此基础上改动后运用于你的项目中。
分享111个Java源码，总有一款适合您
zy0412326的专栏
01-14 3703
java
【Java基础知识 54】Java BeanUtils用法详解，附源码分析
学Java，找哪吒
05-05 8027
目录一、org.apache.commons.beanutils.BeanUtils简介二、使用的前置条件三、添加pom四、代码实例1、为属性赋值2、拷贝对象，为对象赋值3、map转bean4、bean转map五、Apache的BeanUtils与Spring的BeanUtils 一、org.apache.commons.beanutils.BeanUtils简介 BeanUtils是Apache Commons组件的成员之一，主要用于简化JavaBean封装数据的操作。​ 简化反射封装参数的步骤，给对象封
Java实现的一个编译器源代码（Win11）
Alexabc3000的专栏
09-01 2225
Java实现的一个简单语言的编译器。
JAVA上百实例源码以及开源项目
836811384
06-28 4948
简介 笔者当初为了学习JAVA，收集了很多经典源码，源码难易程度分为初级、中级、高级等，详情看源码列表，需要的可以直接下载！ 这些源码反映了那时那景笔者对未来的盲目，对代码的热情、执着，对IT的憧憬、向往！此时此景，笔者只专注Android、Iphone等移动平台开发，看着这些源码心中有万分感慨，写此文章纪念那时那景！ Java 源码包 Applet钢琴模拟程序java源码 2...
JAVA小项目实例源码—学习娱乐小助手
findhappy117的博客
03-03 1万+
代码地址如下：http://www.demodashi.com/demo/11456.html 一、程序实现 项目目录： MyJFrame：实现项目界面样式； AppProcess：实现调用api或爬虫拿数据； NLIProcess：解析用户输入语句意图； lib中是程序开发需要用到的jar包列表。主要代码说明： 程序不同功能领域由选项卡JTabbedPane展示。用户输入哪个功能领域的问题
JAVA经典实例
weixin_34101229的博客
07-24 276
Java经典实例(第二版). 获取环境变量Java代码 .    System.getenv("PATH");  .    System.getenv("JAVA_HOME");  . 获取系统属性Java代码 .    System.getProperty("pencil color");  // 得到属性值  .    java -Dpencil color=green  .    Syste...
【吐血整理】Java项目源码分享
热门推荐
AUZKAY的博客
08-05 2万+
java servlet+jsp+bean开发开源宅商城系统，未用任何java开源框架 实例（七），电商书店，源码下载： jsp+servlet仿当当网电商图书系统 实例（八），源码下载： jsp+java bean+servlet开发的mvc简易鞋城在线商城系统 各种管理系统： ======= 实例（一）：学生信息管理系统，源码下载： GitHub - yirenyin/J2EE_practice: J2EE 学生信息管理系统初级版 实例（二）：图书馆管理系统，源码下载： 1、图书馆管理系统JSP+Ser
java程序_一个完整的Java程序示例
weixin_39689506的博客
10-21 255
(1)第一个程序HellowWorld：注：1.文件名必须和public修饰的类名一致，以.java作为文件后缀，如果定义的类不是public的，则文件名与类名可以不同。2.一个.java文件中可以有多个class，但是只有一个public修饰的类。3.java源代码文件编译后，一个类对应生成一个.class文件。4.一个java应用程序应该包含一个main()方法，而且其签名是固定的，它是应用程...
java遗传算法排课
最新发布
09-28
Java遗传算法排课是指使用Java编程语言来实现基于遗传算法的排课系统。遗传算法是一种模拟自然选择和遗传机制的优化算法，通过模拟自然界中的进化过程，不断迭代优化解决方案，最终得到最优或次优的解决方案。 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值