在Python中实现遗传算法:使用适应度对列表进行排序

import numpy as np

# 定义适应度函数，计算列表的逆序数
def fitness_function(individual):
    fitness = 0
    for i in range(len(individual)):
        for j in range(i+1, len(individual)):
            if individual[i] > individual[j]:
                fitness += 1
    return fitness

# 初始化种群
def initialize_population(population_size, individual_size):
    population = []
    for _ in range(population_size):
        individual = np.random.permutation(individual_size)
        population.append(individual)
    return population

# 选择操作，使用轮盘赌选择
def selection(population, fitness_values, num_parents):
    parents = []
    fitness_sum = np.sum(fitness_values)
    probabilities = fitness_values / fitness_sum
    for _ in range(num_parents):
        parent_index = np.random.choice(len(population), p=probabilities)
        parents.append(population[parent_index])
    return parents

# 交叉操作，使用单点交叉
def crossover(parents, offspring_size):
    offspring = []
    for _ in range(offspring_size):
        parent1, parent2 = np.random.choice(parents, size=2, replace=False)
        crossover_point = np.random.randint(1, len(parent1))
        child = np.concatenate((parent1[:crossover_point], parent2[crossover_point:]))
        offspring.append(child)
    return offspring

# 变异操作，随机交换两个位置的基因
def mutation(offspring):
    for i in range(len(offspring)):
        if np.random.random() < mutation_rate:
            mutation_point1, mutation_point2 = np.random.choice(len(offspring[i]), size=2, replace=False)
            offspring[i][mutation_point1], offspring[i][mutation_point2] = offspring[i][mutation_point2], offspring[i][mutation_point1]
    return offspring

# 更新种群，使用精英保留策略
def update_population(population, offspring):
    population.extend(offspring)
    population.sort(key=lambda x: fitness_function(x))
    population = population[:population_size]
    return population

# 遗传算法主函数
def genetic_algorithm(population_size, individual_size, num_generations):
    population = initialize_population(population_size, individual_size)
    for _ in range(num_generations):
        fitness_values = np.array([fitness_function(individual) for individual in population])
        parents = selection(population, fitness_values, num_parents)
        offspring = crossover(parents, population_size - num_parents)
        offspring = mutation(offspring)
        population = update_population(population, offspring)
    best_individual = population[0]
    return best_individual

# 参数设置
population_size = 100
individual_size = 10
num_parents = 20
mutation_rate = 0.01
num_generations = 100

# 运行遗传算法
best_individual = genetic_algorithm(population_size, individual_size, num_generations)

# 输出结果
print("Best individual:", best_individual)