遗传算法求解函数最大值c语言

遗传算法是一种优化算法，可以用来求解函数的最大值。以下是一个简单的用C语言实现遗传算法求解函数最大值的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define POP_SIZE 100        // 种群大小
#define CHROM_LEN 20        // 染色体长度
#define MAX_GEN 1000        // 最大迭代次数
#define MUT_RATE 0.01       // 变异率
#define CROSS_RATE 0.6      // 交叉率
#define ELITIST 1           // 是否启用精英选择
#define PI 3.1415926535898

// 求解的目标函数
double func(double x) {
    return sin(x) * x + 2 * cos(x) * x + 3 * sin(2 * x) * x;
}

// 随机生成一个染色体
void create_chrom(int chrom[]) {
    for (int i = 0; i < CHROM_LEN; i++) {
        chrom[i] = rand() % 2;
    }
}

// 计算染色体对应的变量值
double decode_chrom(int chrom[]) {
    double x = 0.0;
    for (int i = 0; i < CHROM_LEN; i++) {
        x += chrom[i] * pow(2, i);
    }
    return x * 10 / (pow(2, CHROM_LEN) - 1);
}

// 计算适应度函数值
double fitness(int chrom[]) {
    double x = decode_chrom(chrom);
    return func(x);
}

// 选择操作
void selection(int pop[][CHROM_LEN], double fit[], int new_pop[][CHROM_LEN]) {
    // 计算适应度函数总和
    double sum_fit = 0.0;
    for (int i = 0; i < POP_SIZE; i++) {
        sum_fit += fit[i];
    }
    // 计算适应度函数概率
    double prob[POP_SIZE];
    for (int i = 0; i < POP_SIZE; i++) {
        prob[i] = fit[i] / sum_fit;
    }
    // 计算累计概率
    double accum_prob[POP_SIZE];
    accum_prob[0] = prob[0];
    for (int i = 1; i < POP_SIZE; i++) {
        accum_prob[i] = accum_prob[i - 1] + prob[i];
    }
    // 选择操作
    for (int i = 0; i < POP_SIZE; i++) {
        double r = (double)rand() / RAND_MAX;
        int j = 0;
        while (r > accum_prob[j]) {
            j++;
        }
        for (int k = 0; k < CHROM_LEN; k++) {
            new_pop[i][k] = pop[j][k];
        }
    }
}

// 交叉操作
void crossover(int pop[][CHROM_LEN], int new_pop[][CHROM_LEN]) {
    for (int i = 0; i < POP_SIZE; i += 2) {
        double r = (double)rand() / RAND_MAX;
        if (r < CROSS_RATE) {
            int point = rand() % CHROM_LEN;
            for (int j = point; j < CHROM_LEN; j++) {
                int temp = new_pop[i][j];
                new_pop[i][j] = new_pop[i + 1][j];
                new_pop[i + 1][j] = temp;
            }
        }
    }
}

// 变异操作
void mutation(int new_pop[][CHROM_LEN]) {
    for (int i = 0; i < POP_SIZE; i++) {
        for (int j = 0; j < CHROM_LEN; j++) {
            double r = (double)rand() / RAND_MAX;
            if (r < MUT_RATE) {
                new_pop[i][j] = 1 - new_pop[i][j];
            }
        }
    }
}

// 精英选择操作
void elitist(int pop[][CHROM_LEN], double fit[], int new_pop[][CHROM_LEN]) {
    double max_fit = fit[0];
    int max_index = 0;
    for (int i = 1; i < POP_SIZE; i++) {
        if (fit[i] > max_fit) {
            max_fit = fit[i];
            max_index = i;
        }
    }
    for (int i = 0; i < CHROM_LEN; i++) {
        new_pop[0][i] = pop[max_index][i];
    }
}

int main() {
    srand((unsigned int)time(NULL));
    int pop[POP_SIZE][CHROM_LEN];           // 种群
    int new_pop[POP_SIZE][CHROM_LEN];       // 新的种群
    double fit[POP_SIZE];                   // 适应度函数值
    int gen = 0;                            // 当前迭代次数
    // 初始化种群
    for (int i = 0; i < POP_SIZE; i++) {
        create_chrom(pop[i]);
    }
    // 迭代优化
    while (gen < MAX_GEN) {
        // 计算适应度函数值
        for (int i = 0; i < POP_SIZE; i++) {
            fit[i] = fitness(pop[i]);
        }
        // 选择操作
        selection(pop, fit, new_pop);
        // 交叉操作
        crossover(pop, new_pop);
        // 变异操作
        mutation(new_pop);
        // 精英选择操作
        if (ELITIST) {
            elitist(pop, fit, new_pop);
        }
        // 更新种群
        for (int i = 0; i < POP_SIZE; i++) {
            for (int j = 0; j < CHROM_LEN; j++) {
                pop[i][j] = new_pop[i][j];
            }
        }
        gen++;
    }
    // 输出结果
    double max_fit = fit[0];
    int max_index = 0;
    for (int i = 1; i < POP_SIZE; i++) {
        if (fit[i] > max_fit) {
            max_fit = fit[i];
            max_index = i;
        }
    }
    double x = decode_chrom(pop[max_index]);
    printf("x = %lf, f(x) = %lf\n", x, max_fit);
    return 0;
}

在这个示例代码中，我们使用遗传算法求解了一个函数的最大值。具体来说，我们随机生成一个长度为20的01串作为染色体，然后根据染色体编码计算出对应的变量值，再将变量值带入目标函数计算适应度函数值。然后，我们使用选择、交叉、变异等操作对种群进行优化，直到达到最大迭代次数为止。最后，我们输出适应度函数值最大的染色体对应的变量值和函数值作为最终结果。