可以帮我找基于MATLAB的NSGA-II的代码吗

当然可以，以下是基于MATLAB的NSGA-II算法代码示例：

function [population, front] = NSGAII(fitfun, nvars, lb, ub, maxGen, popSize, pc, pm)

% fitfun:适应度函数
% nvars：变量个数
% lb：变量下界
% ub：变量上界
% maxGen:最大迭代次数
% popSize:种群大小
% pc：交叉概率
% pm：变异概率

% 初始化种群
population = initPopulation(popSize, nvars, lb, ub);

for gen = 1:maxGen
    % 计算适应度值
    [fitvalue, front] = nonDominationSort(population, fitfun);
    
    % 选择操作
    parent = selection(population, fitvalue);
    
    % 交叉操作
    offspring = crossover(parent, pc);
    
    % 变异操作
    offspring = mutation(offspring, pm, lb, ub);
    
    % 合并种群
    population = [population; offspring];
    
    % 非支配排序
    [fitvalue, front] = nonDominationSort(population, fitfun);
    
    % 处理拥挤度
    [population, front] = crowdingDistance(population, front);
    
    % 环境选择
    population = environmentalSelection(population, front, popSize);
end

end

% 初始化种群
function population = initPopulation(popSize, nvars, lb, ub)
population = repmat(struct('var', [], 'fit', [], 'rank', [], 'distance', []), popSize, 1);
for i = 1:popSize
    population(i).var = unifrnd(lb, ub, [1, nvars]);
end
end

% 计算适应度值
function [fitvalue, front] = nonDominationSort(population, fitfun)
n = length(population);
% 初始化
front = {};
fitvalue = zeros(n, 1);
S = cell(n, 1);
nfit = zeros(n, 1);
for i = 1:n
    S{i} = [];
    nfit(i) = 0;
    for j = 1:n
        if i ~= j
            if dominates(population(i), population(j))
                S{i} = [S{i}, j];
            elseif dominates(population(j), population(i))
                nfit(i) = nfit(i) + 1;
            end
        end
    end
    if nfit(i) == 0
        front{1} = [front{1}, i];
        fitvalue(i) = feval(fitfun, population(i).var);
    end
end
i = 1;
while ~isempty(front{i})
    Q = [];
    for j = 1:length(front{i})
        k = front{i}(j);
        for l = 1:length(S{k})
            nfit(S{k}(l)) = nfit(S{k}(l)) - 1;
            if nfit(S{k}(l)) == 0
                Q = [Q, S{k}(l)];
                fitvalue(S{k}(l)) = feval(fitfun, population(S{k}(l)).var);
            end
        end
    end
    i = i + 1;
    front{i} = Q;
end
end

% 选择操作
function parent = selection(population, fitvalue)
n = length(population);
parent = repmat(struct('var', [], 'fit', [], 'rank', [], 'distance', []), n, 1);
for i = 1:n
    % 锦标赛选择
    r1 = randi(n);
    r2 = randi(n);
    while r2 == r1
        r2 = randi(n);
    end
    if fitvalue(r1) < fitvalue(r2)
        parent(i) = population(r1);
    else
        parent(i) = population(r2);
    end
end
end

% 交叉操作
function offspring = crossover(parent, pc)
n = length(parent);
offspring = repmat(struct('var', [], 'fit', [], 'rank', [], 'distance', []), n/2, 2);
for i = 1:n/2
    % 随机选择两个个体进行交叉
    r1 = randi(n);
    r2 = randi(n);
    while r2 == r1
        r2 = randi(n);
    end
    p1 = parent(r1).var;
    p2 = parent(r2).var;
    % 模拟二进制交叉
    for j = 1:length(p1)
        if rand() <= pc
            beta = unifrnd(-0.5, 1.5);
            if rand() < 0.5
                beta = 1 / (2 - beta);
            else
                beta = 2 - 1 / beta;
            end
            y1 = 0.5 * ((1 + beta) * p1(j) + (1 - beta) * p2(j));
            y2 = 0.5 * ((1 - beta) * p1(j) + (1 + beta) * p2(j));
            % 检查边界
            if y1 < lb(j)
                y1 = lb(j);
            elseif y1 > ub(j)
                y1 = ub(j);
            end
            if y2 < lb(j)
                y2 = lb(j);
            elseif y2 > ub(j)
                y2 = ub(j);
            end
            offspring(i, 1).var(j) = y1;
            offspring(i, 2).var(j) = y2;
        else
            offspring(i, 1).var(j) = p1(j);
            offspring(i, 2).var(j) = p2(j);
        end
    end
end
end

% 变异操作
function offspring = mutation(offspring, pm, lb, ub)
n = size(offspring, 1) * 2;
for i = 1:n
    p = offspring(i).var;
    for j = 1:length(p)
        if rand() <= pm
            % 多项式变异
            u = rand();
            if u <= 0.5
                delta = (2 * u)^(1 / (1 + 20));
            else
                delta = (2 - 2 * u)^(-1 / (1 + 20));
            end
            y = p(j) + delta * (ub(j) - lb(j));
            % 检查边界
            if y < lb(j)
                y = lb(j);
            elseif y > ub(j)
                y = ub(j);
            end
            offspring(i).var(j) = y;
        end
    end
end
end

% 处理拥挤度
function [population, front] = crowdingDistance(population, front)
nfront = length(front);
for i = 1:nfront
    % 每个非支配层内的个体按拥挤度递减排序
    n = length(front{i});
    for j = 1:n
        population(front{i}(j)).distance = 0;
    end
    f = population(front{i});
    for j = 1:length(f(1).var)
        [~, idx] = sort([f.var]);
        f = f(idx);
        f(1).distance = Inf;
        f(end).distance = Inf;
        for k = 2:n-1
            f(k).distance = f(k).distance + (f(k+1).var(j) - f(k-1).var(j)) / (f(end).var(j) - f(1).var(j));
        end
    end
    [~, idx] = sort([f.distance], 'descend');
    front{i} = front{i}(idx);
end
end

% 环境选择
function population = environmentalSelection(population, front, popSize)
nfront = length(front);
n = 0;
i = 1;
while n + length(front{i}) <= popSize
    for j = 1:length(front{i})
        population(n+j) = population(front{i}(j));
    end
    n = n + length(front{i});
    i = i + 1;
end
if n < popSize
    [fitvalue, ~] = nonDominationSort(population, 'fitfun');
    [~, idx] = sort(fitvalue, 'descend');
    for j = 1:popSize-n
        population(n+j) = population(idx(j));
    end
end
end

% 判断支配关系
function r = dominates(p, q)
if all(p.fit <= q.fit) && any(p.fit < q.fit)
    r = true;
else
    r = false;
end
end

注意：以上代码仅供学习参考，请勿直接用于实际应用。