基于遗传算法的最优化仿真（Java）

    //pointNum是位置数（本题中是5），realPointNum是每个位置上实际的测量点数
    class GARandom {
    private int pointNum,realPointNum;
    
    public GARandom(int pointNum,int realPointNum) {
        this.pointNum = pointNum;
        this.realPointNum = realPointNum;
    }
    
    public double[][] randomInitPopulation(){
        double[][] x = new double[pointNum][realPointNum];
        for (int i = 0; i < x.length; i++) {
            for (int j = 0; j < x[0].length; j++) {
                if(i == j){
                    x[i][j] = i * 10;//将一组收敛值放入其中，用以后面测试算法的性能
                }else{
                    x[i][j] = i * 10 + (i + 1)*Math.random();
                }
            }
        }
    
        return x;
    }
    }

      //求得每两个位置，所有点之间的距离
        distance = new double[pointNum - 1][realPointNum][realPointNum];
        for (int i = 0; i < pointNum - 1; i++) {
            for (int j = 0; j < realPointNum; j++) {
                for (int k = 0; k < realPointNum; k++) {
                    distance[i][j][k] = Math.abs(x[i + 1][k] - x[i][j] - L);
                }
            }
        }　　      

    //根据先验条件求得个体适应度，并根据适应度求得单个个体的概率以及个体的累积概率
    //以便选择阶段使用
    private void evaluate(int[][] chromosome) {
        int k = 0;
        double len = 0;
        double sumFitness = 0;
        double[] tempFitness = new double[scale];
    
        //根据距离数组求得每条路径的适应度，也就是和固定距离L的偏差的和
        while (k < chromosome.length) {
            for (int i = 0; i < chromosome[k].length - 1; i++) {
                len += distance[i][chromosome[k][i]][chromosome[k][i + 1]];
            }
            fitness[k] = len;
            len = 0;
            k++;
        }
    
        //求总的适应度
        for (int i = 0; i < scale; i++) {
            tempFitness[i] = 10.0 / (fitness[i] + 1);//计算适应度，这里距离越小适应度越大，因此采用倒数的方式表示
            sumFitness += tempFitness[i];
        }
    
        //根据适应度，转化成相应的单个个体概率和个体的累积概率，用于后面的轮盘赌选择策略
        double tempP = 0;
        for (int i = 0; i < scale; i++) {
            ps[i] = tempFitness[i] / sumFitness;//单个个体概率
            tempP += ps[i];
            pc[i] = tempP;//个体累积概率
        }
    }

    //生成父代种群的“染色体”，也就是随机选取每个位置上的点组成一个网络
    //scale是种群规模，pointNum是位置数（x1-x5）
        oldPopulation = new int[scale][pointNum];
        for (int i = 0; i < scale; i++) {
            for (int j = 0; j < pointNum; j++) {
                if (i < realPointNum){
                    oldPopulation[i][j] = i;
                }else{
                    oldPopulation[i][j] = rand.nextInt(realPointNum);
                }
            }
        }

    //精英选择（选择上一代中fitness最好的个体，然后直接保存到下一代中）
    private void selectMaxFitness() {
    
        int maxId = 0;
        double tempFitness = fitness[0];
    
        //
        for (int i = 1; i < scale; i++) {
            if (tempFitness > fitness[i]) {
                tempFitness = fitness[i];
                maxId = i;
            }
        }
    
        if (bestLength > tempFitness) {
            bestLength = tempFitness;
            bestGen = t;
            System.arraycopy(oldPopulation[maxId], 0, bestChoice, 0, pointNum);
    
        }
    
        copyPopulation(0, maxId);
    }
    
    //轮盘赌选择策略
    private void select() {
    
        int j, selectId;
        double r;
    
        selectMaxFitness();//精英选择，保留上一代fitness最好的个体
        for (int i = 1; i < scale; i++) {
            r = rand.nextDouble();
            for (j = 0; j < scale; j++) {
                if (r <= pc[j]) {
                    break;
                }
            }
            if (j < scale) {
                selectId = j;
                copyPopulation(i, selectId);
            }
        }
    }

    //单点交叉
    private void crossover() {
        for (int k = 1; k < scale/2; k += 2) {
            double pCrossoverTemp = rand.nextDouble();
            //小于交叉概率时进行“染色体”交叉,将交叉索引(包括交叉索引处的元素)后的元素进行互换
            if (pCrossoverTemp <= pCrossover) {
                int tempCrossover;
                int indexCrossover = 1 + rand.nextInt(pointNum - 1);//排除索引值为0的情况，整体交换没有意义
                for (int i = indexCrossover; i < pointNum; i++) {
                    tempCrossover = newPopulation[k][i];
                    newPopulation[k][i] = newPopulation[k + 1][i];
                    newPopulation[k + 1][i] = tempCrossover;
                }
            }
        }
    }

    private void mutation() {
        for (int i = 1; i < scale; i++) {
            double pMutationTemp = rand.nextDouble();
            if (pMutationTemp < pMutation) {
                //随机选择变异位置
                int mutationIndex = rand.nextInt(pointNum);
                //将变异位置的值保存下来
                int temp = newPopulation[i][mutationIndex];
                //获得变异值
                int mutationTemp = rand.nextInt(realPointNum);
                //确保变异值和之前的值不一样
                while (mutationTemp == temp) {
                    mutationTemp = rand.nextInt(realPointNum);
                }
                newPopulation[i][mutationIndex] = mutationTemp;
            }
        }
    }