java中使用遺傳演算法（遺傳演算法的基本操作）

本文目錄一覽：

• 1、求《Java遺傳演算法編程》全文免費下載百度網盤資源,謝謝~
• 2、java實驗 遺傳演算法
• 3、遺傳演算法
• 4、如何用Java實現遺傳演算法？
• 5、使用java來實現在智能組卷中的遺傳演算法（急急急）

求《Java遺傳演算法編程》全文免費下載百度網盤資源,謝謝~

《Java遺傳演算法編程》百度網盤pdf最新全集下載:

鏈接:

?pwd=xv3v 提取碼: xv3v

簡介：本書簡單、直接地介紹了遺傳演算法，並且針對所討論的示例問題，給出了Java代碼的演算法實現。全書分為6章。第1章簡單介紹了人工智慧和生物進化的知識背景，這也是遺傳演算法的歷史知識背景。第2章給出了一個基本遺傳演算法的實現；第4章和第5章，分別針對機器人控制器、旅行商問題、排課問題展開分析和討論，並給出了演算法實現。在這些章的末尾，還給出了一些練習供讀者深入學習和實踐。第6章專門討論了各種演算法的優化問題。  

java實驗 遺傳演算法

你好，我以前從csdn上下過一個源代碼，不過沒試過怎麼用，給你參考一下：

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.JTextField;

/**

* 編寫者: 賴志環

* 標準遺傳演算法求解函數

* 編寫日期: 2007-12-2

*/

class Best {

public int generations; //最佳適應值代號

public String str; //最佳染色體

public double fitness; //最佳適應值

}

public class SGAFrame extends JFrame {

private JTextArea textArea;

private String str = “”;

private Best best = null; //最佳染色體

private String[] ipop = new String[10]; //染色體

private int gernation = 0; //染色體代號

public static final int GENE = 22; //基因數

/**

* Launch the application

* @param args

*/

public static void main(String args[]) {

try {

SGAFrame frame = new SGAFrame();

frame.setVisible(true);

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* Create the frame

*/

public SGAFrame() {

super();

this.ipop = inialPops();

getContentPane().setLayout(null);

setBounds(100, 100, 461, 277);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JLabel label = new JLabel();

label.setText(“X的區間:”);

label.setBounds(23, 10, 88, 15);

getContentPane().add(label);

final JLabel label_1 = new JLabel();

label_1.setText(“[-255,255]”);

label_1.setBounds(92, 10, 84, 15);

getContentPane().add(label_1);

final JButton button = new JButton();

button.addActionListener(new ActionListener() {

public void actionPerformed(final ActionEvent e) {

SGAFrame s = new SGAFrame();

str = str + s.process() + “\n”;

textArea.setText(str);

}

});

button.setText(“求最小值”);

button.setBounds(323, 27, 99, 23);

getContentPane().add(button);

final JLabel label_2 = new JLabel();

label_2.setText(“利用標準遺傳演算法求解函數f(x)=(x-5)*(x-5)的最小值:”);

label_2.setBounds(23, 31, 318, 15);

getContentPane().add(label_2);

final JPanel panel = new JPanel();

panel.setLayout(new BorderLayout());

panel.setBounds(23, 65, 399, 164);

getContentPane().add(panel);

final JScrollPane scrollPane = new JScrollPane();

panel.add(scrollPane, BorderLayout.CENTER);

textArea = new JTextArea();

scrollPane.setViewportView(textArea);

//

}

/**

* 初始化一條染色體（用二進位字元串表示）

* @return 一條染色體

*/

private String inialPop() {

String res = “”;

for (int i = 0; i GENE; i++) {

if (Math.random() 0.5) {

res += “0”;

} else {

res += “1”;

}

}

return res;

}

/**

* 初始化一組染色體

* @return 染色體組

*/

private String[] inialPops() {

String[] ipop = new String[10];

for (int i = 0; i 10; i++) {

ipop[i] = inialPop();

}

return ipop;

}

/**

* 將染色體轉換成x的值

* @param str 染色體

* @return 染色體的適應值

*/

private double calculatefitnessvalue(String str) {

int b = Integer.parseInt(str, 2);

//String str1 = “” + “/n”;

double x = -255 + b * (255 – (-255)) / (Math.pow(2, GENE) – 1);

//System.out.println(“X = ” + x);

double fitness = -(x – 5) * (x – 5);

//System.out.println(“f(x)=” + fitness);

//str1 = str1 + “X=” + x + “/n”

//+ “f(x)=” + “fitness” + “/n”;

//textArea.setText(str1);

return fitness;

}

/**

* 計算群體上每個個體的適應度值;

* 按由個體適應度值所決定的某個規則選擇將進入下一代的個體;

*/

private void select() {

double evals[] = new double[10]; // 所有染色體適應值

double p[] = new double[10]; // 各染色體選擇概率

double q[] = new double[10]; // 累計概率

double F = 0; // 累計適應值總和

for (int i = 0; i 10; i++) {

evals[i] = calculatefitnessvalue(ipop[i]);

if (best == null) {

best = new Best();

best.fitness = evals[i];

best.generations = 0;

best.str = ipop[i];

} else {

if (evals[i] best.fitness) // 最好的記錄下來

{

best.fitness = evals[i];

best.generations = gernation;

best.str = ipop[i];

}

}

F = F + evals[i]; // 所有染色體適應值總和

}

for (int i = 0; i 10; i++) {

p[i] = evals[i] / F;

if (i == 0)

q[i] = p[i];

else {

q[i] = q[i – 1] + p[i];

}

}

for (int i = 0; i 10; i++) {

double r = Math.random();

if (r = q[0]) {

ipop[i] = ipop[0];

} else {

for (int j = 1; j 10; j++) {

if (r q[j]) {

ipop[i] = ipop[j];

break;

}

}

}

}

}

/**

* 交叉操作

* 交叉率為25%，平均為25%的染色體進行交叉

*/

private void cross() {

String temp1, temp2;

for (int i = 0; i 10; i++) {

if (Math.random() 0.25) {

double r = Math.random();

int pos = (int) (Math.round(r * 1000)) % GENE;

if (pos == 0) {

pos = 1;

}

temp1 = ipop[i].substring(0, pos)

+ ipop[(i + 1) % 10].substring(pos);

temp2 = ipop[(i + 1) % 10].substring(0, pos)

+ ipop[i].substring(pos);

ipop[i] = temp1;

ipop[(i + 1) / 10] = temp2;

}

}

}

/**

* 基因突變操作

* 1%基因變異m*pop_size 共180個基因，為了使每個基因都有相同機會發生變異,

* 需要產生[1–180]上均勻分布的

*/

private void mutation() {

for (int i = 0; i 4; i++) {

int num = (int) (Math.random() * GENE * 10 + 1);

int chromosomeNum = (int) (num / GENE) + 1; // 染色體號

int mutationNum = num – (chromosomeNum – 1) * GENE; // 基因號

if (mutationNum == 0)

mutationNum = 1;

chromosomeNum = chromosomeNum – 1;

if (chromosomeNum = 10)

chromosomeNum = 9;

//System.out.println(“變異前” + ipop[chromosomeNum]);

String temp;

if (ipop[chromosomeNum].charAt(mutationNum – 1) == ‘0’) {

if (mutationNum == 1) {

temp = “1” + ipop[chromosomeNum].substring

(mutationNum);

} else {

if (mutationNum != GENE) {

temp = ipop[chromosomeNum].substring(0, mutationNum –

1) + “1” + ipop

[chromosomeNum].substring(mutationNum);

} else {

temp = ipop[chromosomeNum].substring(0, mutationNum –

1) + “1”;

}

}

} else {

if (mutationNum == 1) {

temp = “0” + ipop[chromosomeNum].substring

(mutationNum);

} else {

if (mutationNum != GENE) {

temp = ipop[chromosomeNum].substring(0, mutationNum –

1) + “0” + ipop

[chromosomeNum].substring(mutationNum);

} else {

temp = ipop[chromosomeNum].substring(0, mutationNum –

1) + “1”;

}

}

}

ipop[chromosomeNum] = temp;

//System.out.println(“變異後” + ipop[chromosomeNum]);

}

}

/**

* 執行遺傳演算法

*/

public String process() {

String str = “”;

for (int i = 0; i 10000; i++) {

this.select();

this.cross();

this.mutation();

gernation = i;

}

str = “最小值” + best.fitness + “,第” + best.generations + “個染色體”;

return str;

}

}

遺傳演算法

例如：[1,2,3]，[1,3,2]，[3,2,1]均是函數 3x+4y+5z100 的可行解（代進去成立即為可行解），那麼這些可行解在遺傳演算法中均稱為「染色體」。可行解由 3 個元素構成，每個元素都稱為染色體的一個基因。

遺傳演算法在運行過程中會進行 N 次迭代，每次迭代都會生成若干條染色體。適應度函數會給本次迭代中生成的所有染色體打個分，來評判這些染色體的適應度，然後將適應度低的染色體淘汰，只保留適應度高的染色體，從而講過若干次迭代後染色體的質量將越來越好。

遺傳演算法每次迭代會生成 N 條染色體，在遺傳演算法中一次迭代被稱為一次進化。每次進化新的染色體生成的方法——交叉。

每一次進化完成後，都要計算每一條染色體的適應度+適應度概率。在交叉過程中就需要根據這個概率來選擇父母染色體。適應度高的染色體被選中的概率越高。（這就是遺傳演算法能夠保留優良基因的原因）

交叉能保證每次進化留下優良的基因，但它僅僅是對原有的結果集進行選擇，基因還是那麼幾個，只不過交換了它們的順序。這隻能保證 N 次進化後，計算結果更接近於局部最優解，而永遠沒辦法達到全局最優解（？？？？？），為了解決這個問題，需引入變異。

假設每次進化都需要生成 N 條染色體，那麼每次進化中，通過交叉方式需要生成 N-M 條，剩餘的 M 條染色體通過複製上一代適應度最高的 M 條染色體而來。

本文的目標是使所有任務的總處理時間最少，時間越短適應度越大。適應度 = 1 / 所有任務的總處理時間

將任務從 0 開始編號，用一個一維數組存儲每個任務的時長

tasks[i] ：表第 i 個任務的長度。

第 0 個任務的長度為 2；

第 1 個任務的長度為 4；

第 2 個任務的長度為 6；

第 3 個任務的長度為 8；

將處理器節點從 0 開始編號，用一個一維數組存儲每個處理器的處理速度（單位時間內可處理的長度）

nodes[i] 表第 i 個節點的處理速度。

第 0 個節點的處理速度為 2；

第 1 個節點的處理速度為 1。

timeMatrix[i][j] 表第 i 個任務在第 j 個節點上處理的話，所需處理時間。

一個可行解就是一個染色體，就是一個一維數組

chromosome[i]=j 表將第 i 個任務分配到節點 j 上處理（任務編號從 0 開始；節點編號從 0 開始）

將任務 0 分配給 3 號節點處理；

將任務 1 分配給 2 號節點處理；

將任務 2 分配給 1 號節點處理；

將任務 3 分配給 0 號節點處理。

記錄本次進化生成的 N 條染色體的適應度，將染色體從 0 開始編號。

adaptablility[i] 表第 i 個染色體的適應度

selectionProbability[i] 表第 i 個染色體的適應度概率，所有染色體的適應度概率和為 1 。

java中PriorityQueue優先順序隊列使用方法

第 2 次迭代結果

第 100 次迭代結果

如何用Java實現遺傳演算法？

通過遺傳演算法走迷宮。雖然圖1和圖2均成功走出迷宮，但是圖1比圖2的路徑長的多，且複雜，遺傳演算法可以計算出有多少種可能性，並選擇其中最簡潔的作為運算結果。

示例圖1：

示例圖2：

實現代碼：

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Random;

/**

* 用遺傳演算法走迷宮

*

* @author Orisun

*

*/

public class GA {

int gene_len; // 基因長度

int chrom_len; // 染色體長度

int population; // 種群大小

double cross_ratio; // 交叉率

double muta_ratio; // 變異率

int iter_limit; // 最多進化的代數

Listboolean[] individuals; // 存儲當代種群的染色體

Labyrinth labyrinth;

int width;      //迷宮一行有多少個格子

int height;     //迷宮有多少行

public class BI {

double fitness;

boolean[] indv;

public BI(double f, boolean[] ind) {

fitness = f;

indv = ind;

}

public double getFitness() {

return fitness;

}

public boolean[] getIndv() {

return indv;

}

}

ListBI best_individual; // 存儲每一代中最優秀的個體

public GA(Labyrinth labyrinth) {

this.labyrinth=labyrinth;

this.width = labyrinth.map[0].length;

this.height = labyrinth.map.length;

chrom_len = 4 * (width+height);

gene_len = 2;

population = 20;

cross_ratio = 0.83;

muta_ratio = 0.002;

iter_limit = 300;

individuals = new ArrayListboolean[](population);

best_individual = new ArrayListBI(iter_limit);

}

public int getWidth() {

return width;

}

public void setWidth(int width) {

this.width = width;

}

public double getCross_ratio() {

return cross_ratio;

}

public ListBI getBest_individual() {

return best_individual;

}

public Labyrinth getLabyrinth() {

return labyrinth;

}

public void setLabyrinth(Labyrinth labyrinth) {

this.labyrinth = labyrinth;

}

public void setChrom_len(int chrom_len) {

this.chrom_len = chrom_len;

}

public void setPopulation(int population) {

this.population = population;

}

public void setCross_ratio(double cross_ratio) {

this.cross_ratio = cross_ratio;

}

public void setMuta_ratio(double muta_ratio) {

this.muta_ratio = muta_ratio;

}

public void setIter_limit(int iter_limit) {

this.iter_limit = iter_limit;

}

// 初始化種群

public void initPopulation() {

Random r = new Random(System.currentTimeMillis());

for (int i = 0; i population; i++) {

int len = gene_len * chrom_len;

boolean[] ind = new boolean[len];

for (int j = 0; j len; j++)

ind[j] = r.nextBoolean();

individuals.add(ind);

}

}

// 交叉

public void cross(boolean[] arr1, boolean[] arr2) {

Random r = new Random(System.currentTimeMillis());

int length = arr1.length;

int slice = 0;

do {

slice = r.nextInt(length);

} while (slice == 0);

if (slice length / 2) {

for (int i = 0; i slice; i++) {

boolean tmp = arr1[i];

arr1[i] = arr2[i];

arr2[i] = tmp;

}

} else {

for (int i = slice; i length; i++) {

boolean tmp = arr1[i];

arr1[i] = arr2[i];

arr2[i] = tmp;

}

}

}

// 變異

public void mutation(boolean[] individual) {

int length = individual.length;

Random r = new Random(System.currentTimeMillis());

individual[r.nextInt(length)] ^= false;

}

// 輪盤法選擇下一代,並返回當代最高的適應度值

public double selection() {

boolean[][] next_generation = new boolean[population][]; // 下一代

int length = gene_len * chrom_len;

for (int i = 0; i population; i++)

next_generation[i] = new boolean[length];

double[] cumulation = new double[population];

int best_index = 0;

double max_fitness = getFitness(individuals.get(best_index));

cumulation[0] = max_fitness;

for (int i = 1; i population; i++) {

double fit = getFitness(individuals.get(i));

cumulation[i] = cumulation[i – 1] + fit;

// 尋找當代的最優個體

if (fit max_fitness) {

best_index = i;

max_fitness = fit;

}

}

Random rand = new Random(System.currentTimeMillis());

for (int i = 0; i population; i++)

next_generation[i] = individuals.get(findByHalf(cumulation,

rand.nextDouble() * cumulation[population – 1]));

// 把當代的最優個體及其適應度放到best_individual中

BI bi = new BI(max_fitness, individuals.get(best_index));

// printPath(individuals.get(best_index));

//System.out.println(max_fitness);

best_individual.add(bi);

// 新一代作為當前代

for (int i = 0; i population; i++)

individuals.set(i, next_generation[i]);

return max_fitness;

}

// 折半查找

public int findByHalf(double[] arr, double find) {

if (find  0 || find == 0 || find arr[arr.length – 1])

return -1;

int min = 0;

int max = arr.length – 1;

int medium = min;

do {

if (medium == (min + max) / 2)

break;

medium = (min + max) / 2;

if (arr[medium] find)

min = medium;

else if (arr[medium] find)

max = medium;

else

return medium;

} while (min max);

return max;

}

// 計算適應度

public double getFitness(boolean[] individual) {

int length = individual.length;

// 記錄當前的位置,入口點是（1,0）

int x = 1;

int y = 0;

// 根據染色體中基因的指導向前走

for (int i = 0; i length; i++) {

boolean b1 = individual[i];

boolean b2 = individual[++i];

// 00向左走

if (b1 == false  b2 == false) {

if (x  0  labyrinth.map[y][x – 1] == true) {

x–;

}

}

// 01向右走

else if (b1 == false  b2 == true) {

if (x + 1  width labyrinth.map[y][x + 1] == true) {

x++;

}

}

// 10向上走

else if (b1 == true  b2 == false) {

if (y  0  labyrinth.map[y – 1][x] == true) {

y–;

}

}

// 11向下走

else if (b1 == true  b2 == true) {

if (y + 1  height labyrinth.map[y + 1][x] == true) {

y++;

}

}

}

int n = Math.abs(x – labyrinth.x_end) + Math.abs(y -labyrinth.y_end) + 1;

//      if(n==1)

//          printPath(individual);

return 1.0 / n;

}

// 運行遺傳演算法

public boolean run() {

// 初始化種群

initPopulation();

Random rand = new Random(System.currentTimeMillis());

boolean success = false;

while (iter_limit–  0) {

// 打亂種群的順序

Collections.shuffle(individuals);

for (int i = 0; i population – 1; i += 2) {

// 交叉

if (rand.nextDouble() cross_ratio) {

cross(individuals.get(i), individuals.get(i + 1));

}

// 變異

if (rand.nextDouble() muta_ratio) {

mutation(individuals.get(i));

}

}

// 種群更替

if (selection() == 1) {

success = true;

break;

}

}

return success;

}

//  public static void main(String[] args) {

//      GA ga = new GA(8, 8);

//      if (!ga.run()) {

//          System.out.println(“沒有找到走出迷宮的路徑.”);

//      } else {

//          int gen = ga.best_individual.size();

//          boolean[] individual = ga.best_individual.get(gen – 1).indv;

//          System.out.println(ga.getPath(individual));

//      }

//  }

// 根據染色體列印走法

public String getPath(boolean[] individual) {

int length = individual.length;

int x = 1;

int y = 0;

LinkedListString stack=new LinkedListString();

for (int i = 0; i length; i++) {

boolean b1 = individual[i];

boolean b2 = individual[++i];

if (b1 == false  b2 == false) {

if (x  0  labyrinth.map[y][x – 1] == true) {

x–;

if(!stack.isEmpty() stack.peek()==”右”)

stack.poll();

else

stack.push(“左”);

}

} else if (b1 == false  b2 == true) {

if (x + 1  width labyrinth.map[y][x + 1] == true) {

x++;

if(!stack.isEmpty() stack.peek()==”左”)

stack.poll();

else

stack.push(“右”);

}

} else if (b1 == true  b2 == false) {

if (y  0  labyrinth.map[y – 1][x] == true) {

y–;

if(!stack.isEmpty() stack.peek()==”下”)

stack.poll();

else

stack.push(“上”);

}

} else if (b1 == true  b2 == true) {

if (y + 1  height labyrinth.map[y + 1][x] == true) {

y++;

if(!stack.isEmpty() stack.peek()==”上”)

stack.poll();

else

stack.push(“下”);

}

}

}

StringBuilder sb=new StringBuilder(length/4);

IteratorString iter=stack.descendingIterator();

while(iter.hasNext())

sb.append(iter.next());

return sb.toString();

}

}

使用java來實現在智能組卷中的遺傳演算法（急急急）

題目好像是讓你做個增強版的List ，簡單的都實現了 程序架子大概是這樣，排序查找什麼的百度搜下 演算法很多，套著每樣寫個方法就行了，測試就在main『方法里寫

public class MyList {

    private String[] arr;

    private int count ;

    public MyList (int count){

        arr = new String[count];

        this.count = count;

    }

    public MyList (int[] intArr){

        arr = new String[intArr.length];

        this.count = intArr.length;

        for(int i=0;iintArr.length;i++){

            arr[i] = intArr[i]+””;

        }

    }

    public MyList (String[] stringArr){

        arr = stringArr;

        this.count = stringArr.length;

    }

    public int getLength(){

        return count;

    }

//清空容器內的數組。

    public void clearAll(){

        arr = new String[count];

    }

//通過給定元素下標來刪除某一元素

    public void removeBySeqn(int seqn){

        if(seqn = 0  seqncount){

                    arr[seqn] = null;

        }

    }

public static void main(String[] args){

    MyList  list = new MyList (40);

    MyList  list1 = new MyList ({3,2,125,56,123});

    MyList  list2 = new MyList ({“123”,””ad});

    list2.removeBySeqn(0);

    list1.clearAll();

}

}