遗传算法最全交叉函数的MATLAB代码_matlab中offspring

遗传算法中的交叉（crossover）函数是用来创建新的解决方案（即 offspring 或 children）的方法，以下是五种常见的交叉函数的 MATLAB 实现：

1. 单点交叉 (Single-Point Crossover)

在单点交叉中，我们随机选择一个切割点，然后交换两个父代染色体在切割点之后的部分。

function [child1, child2] = singlePointCrossover(parent1, parent2)

    crossover_point = randi([1 length(parent1)], 1, 1);

    child1 = [parent1(1:crossover_point) parent2(crossover_point+1:end)];

    child2 = [parent2(1:crossover_point) parent1(crossover_point+1:end)];

end

2. 两点交叉 (Two-Point Crossover)

在两点交叉中，我们随机选择两个切割点，然后交换两个父代染色体在这两个点之间的部分。

function [child1, child2] = twoPointCrossover(parent1, parent2)

    crossover_points = sort(randi([1 length(parent1)], 1, 2));

    child1 = [parent1(1:crossover_points(1)) parent2(crossover_points(1)+1:crossover_points(2)) parent1(crossover_points(2)+1:end)];

    child2 = [parent2(1:crossover_points(1)) parent1(crossover_points(1)+1:crossover_points(2)) parent2(crossover_points(2)+1:end)];

end

3. 均匀交叉 (Uniform Crossover)

在均匀交叉中，我们对每个位进行决策，随机决定该位来自于哪个父代染色体。

function [child1, child2] = uniformCrossover(parent1, parent2, crossoverRate)

    child1 = parent1;

    child2 = parent2;

    for i = 1:length(parent1)

        if rand < crossoverRate

            child1(i) = parent2(i);

            child2(i) = parent1(i);

        end

    end

end

4. 算术交叉 (Arithmetic Crossover)

在算术交叉中，我们根据一个随机权重对两个父代染色体进行线性组合。

function [child1, child2] = arithmeticCrossover(parent1, parent2)

    alpha = rand;

    child1 = alpha*parent1 + (1-alpha)*parent2;

    child2 = alpha*parent2 + (1-alpha)*parent1;

end

5. 部分匹配交叉 (Partially Matched Crossover, PMX)

部分匹配交叉主要用于排列问题，它保证了交叉后的染色体仍然是一个有效的排列。

function [child1, child2] = pmxCrossover(parent1, parent2)

    length_p = length(parent1);

    crossover_points = sort(randi([1 length_p], 1, 2));

    segment1 = parent1(crossover_points(1):crossover_points(2));

    segment2 = parent2(crossover_points(1):crossover_points(2));

    child1 = mapOrder(parent1, segment2, segment1, crossover_points);

    child2 = mapOrder(parent2, segment1, segment2, crossover_points);

end

function child = mapOrder(parent, segment1, segment2, crossover_points)

    child = parent;

    child(crossover_points(1):crossover_points(2)) = segment1;

    for i = [1:crossover_points(1)-1, crossover_points(2)+1:length(parent)]

        if ismember(child(i), segment1)

            index = find(segment2 == child(i));

            while ismember(segment1(index), child)

                index = find(segment2 == segment1(index));

            end

            child(i) = segment1(index);

        end

    end

end

6. 循环交叉 (Cycle Crossover, CX)

循环交叉是一种主要用于处理排列编码问题的交叉方法。它能够保持基因的绝对位置不变。

function [child1, child2] = cycleCrossover(parent1, parent2)

    length_p = length(parent1);

    cycleStart = 1;

    cycleIndex = cycleStart;

    child1 = zeros(1, length_p);

    child2 = zeros(1, length_p);

    while any(child1 == 0)

        child1(cycleIndex) = parent1(cycleIndex);

        child2(cycleIndex) = parent2(cycleIndex);

        cycleVal = parent2(cycleIndex);

        cycleIndex = find(parent1 == cycleVal);

        if parent1(cycleStart) == parent2(cycleIndex)

            cycleStart = find(child1 == 0, 1, 'first');

            cycleIndex = cycleStart;

        end

    end

end

7. 顺序交叉 (Order Crossover, OX)

顺序交叉也是一种主要用于处理排列编码问题的交叉方法。它能够保持基因的相对顺序不变。

function [child1, child2] = orderCrossover(parent1, parent2)

    length_p = length(parent1);

    crossover_points = sort(randi([1 length_p], 1, 2));

    segment1 = parent1(crossover_points(1):crossover_points(2));

    segment2 = parent2(crossover_points(1):crossover_points(2));

    child1 = fillOrder(parent1, segment2, crossover_points);

    child2 = fillOrder(parent2, segment1, crossover_points);

end

function child = fillOrder(parent, segment, crossover_points)

    child = zeros(1, length(parent));

    child(crossover_points(1):crossover_points(2)) = segment;

    j = 1;

    for i = 1:length(parent)

        if ~ismember(parent(i), child)

            while child(j) ~= 0

                j = j + 1;

            end

            child(j) = parent(i);

        end

    end

end

8. 位置交叉 (Position Based Crossover, POS)

位置交叉是另一种主要用于处理排列编码问题的交叉方法。它从一个父代继承一组基因的位置，从另一个父代继承这些位置上的基因。

function [child1, child2] = positionCrossover(parent1, parent2)

    length_p = length(parent1);

    positions = randi([0 1], 1, length_p);

    child1 = fillPosition(parent1, parent2, positions);

    child2 = fillPosition(parent2, parent1, positions);

end

function child = fillPosition(parent1, parent2, positions)

    child = zeros(1, length(parent1));

    child(positions == 1) = parent1(positions == 1);

    j = 1;

    for i = 1:length(parent1)

        if ~ismember(parent2(i), child)

            while child(j) ~= 0

                j = j + 1;

            end

            child(j) = parent2(i);

        end

    end

end

9. 模拟二进制交叉 (Simulated Binary Crossover, SBX)

模拟二进制交叉是一种用于处理实数编码问题的交叉方法。它通过模仿二进制编码的单点交叉来生成子代。

function [child1, child2] = simulatedBinaryCrossover(parent1, parent2, eta)

    length_p = length(parent1);

    child1 = zeros(1, length_p);

    child2 = zeros(1, length_p);

    for i = 1:length_p

        r = rand;

        if r <= 0.5

            beta = (2*r)^(1/(eta+1));

        else

            beta = (1/(2*(1-r)))^(1/(eta+1));

        end

        child1(i) = 0.5*(((1+beta)*parent1(i)) + (1-beta)*parent2(i));

        child2(i) = 0.5*(((1-beta)*parent1(i)) + (1+beta)*parent2(i));

    end

end

10. 模板交叉 (Template Crossover)

模板交叉使用一个模板来决定每个基因应该来自哪个父代。模板是一串和染色体一样长的二进制串。

function [child1, child2] = templateCrossover(parent1, parent2, template)

    child1 = parent1;

    child2 = parent2;

    child1(template == 1) = parent2(template == 1);

    child2(template == 1) = parent1(template == 1);

end

11. 最大最小交叉 (Max-min Arithmetic Recombination)

在最大最小交叉中，我们用两个父代染色体的最大值和最小值来创建子代染色体。

function [child1, child2] = maxminCrossover(parent1, parent2)

    child1 = max(parent1, parent2);

    child2 = min(parent1, parent2);

end

12. 混合交叉 (Blend Crossover, BLX-alpha)

混合交叉是一种用于实数编码问题的交叉方法。这种方法生成的子代在每个维度上都位于父代的中心附近。

function [child1, child2] = blendCrossover(parent1, parent2, alpha)

    child1 = (1 - alpha)*parent1 + alpha*parent2;

    child2 = alpha*parent1 + (1 - alpha)*parent2;

end

13. 中间交叉 (Intermediate Crossover)

中间交叉是一种用于实数编码问题的交叉方法。这种方法生成的子代在每个维度上都位于父代的中间。

function [child1, child2] = intermediateCrossover(parent1, parent2)

    child1 = 0.5*(parent1 + parent2);

    child2 = 0.5*(parent1 + parent2);

end

14. 线性组合交叉 (Linear Combination Crossover)

线性组合交叉是一种用于实数编码问题的交叉方法。这种方法根据随机权重对父代进行线性组合，生成子代。

function [child1, child2] = linearCombinationCrossover(parent1, parent2)

    alpha = rand;

    beta = rand;

    child1 = alpha*parent1 + (1 - alpha)*parent2;

    child2 = beta*parent1 + (1 - beta)*parent2;

end

15. 一致交叉 (Heuristic Crossover)

一致交叉是一种用于实数编码问题的交叉方法。这种方法考虑了父代的适应度，生成一个更好的子代。

function child = heuristicCrossover(parent1, parent2, fitness1, fitness2)

    if fitness1 > fitness2

        best = parent1;

        worst = parent2;

    else

        best = parent2;

        worst = parent1;

    end

    beta = rand;

    child = best + beta*(best - worst);

end