给出SaDE和DE代码，并可视化对比两者的区别

以下是 SaDE 算法的 Python 代码：

import numpy as np

def SaDE(F, bounds, popsize=100, maxiter=1000, p=0.1, c=0.5, seed=None):
    """
    Scalable Distributed Evolutionary Algorithm (SaDE)
    
    Parameters
    ----------
    F : function
        The objective function to be minimized. It should take a 1-D numpy array
        as input and return a scalar value.
    bounds : array_like
        The bounds of the search space. It should be a list of tuples, where
        each tuple corresponds to the lower and upper bounds of a dimension.
    popsize : int, optional
        The population size. Default is 100.
    maxiter : int, optional
        The maximum number of iterations. Default is 1000.
    p : float, optional
        The probability of selecting the best solution as the base vector.
        Default is 0.1.
    c : float, optional
        The probability of selecting each component of the donor vector from
        the corresponding component of the base vector. Default is 0.5.
    seed : int, optional
        The random seed. Default is None.
        
    Returns
    -------
    x : array_like
        The best solution found by the algorithm.
    f : float
        The corresponding function value.
    """
    # Set random seed
    if seed is not None:
        np.random.seed(seed)
    
    # Initialize population
    D = len(bounds)
    pop = np.random.rand(popsize, D) * (bounds[:, 1] - bounds[:, 0]) + bounds[:, 0]
    fitness = np.array([F(x) for x in pop])
    best_idx = np.argmin(fitness)
    best_x, best_f = pop[best_idx], fitness[best_idx]
    
    # Main loop
    for t in range(maxiter):
        # Select the best solution as the base vector
        base_idx = np.argmin(fitness)
        base_x = pop[base_idx]
        
        # Generate the donor vector
        donor_x = np.copy(base_x)
        for i in range(D):
            if np.random.rand() < c:
                idxs = np.random.choice(popsize, 3, replace=False)
                diff = pop[idxs[0]] - pop[idxs[1]]
                donor_x[i] += p * diff[i]
                donor_x[i] += (1 - p) * (pop[idxs[2], i] - base_x[i])
        
        # Evaluate the donor vector
        donor_f = F(donor_x)
        
        # Update the population
        if donor_f < fitness[base_idx]:
            pop[base_idx] = donor_x
            fitness[base_idx] = donor_f
        
        # Update the best solution
        best_idx = np.argmin(fitness)
        if fitness[best_idx] < best_f:
            best_x, best_f = pop[best_idx], fitness[best_idx]
    
    return best_x, best_f

以下是标准差分进化算法（DE）的 Python 代码：

import numpy as np

def DE(F, bounds, popsize=100, maxiter=1000, F=0.5, CR=0.9, seed=None):
    """
    Differential Evolution (DE)
    
    Parameters
    ----------
    F : function
        The objective function to be minimized. It should take a 1-D numpy array
        as input and return a scalar value.
    bounds : array_like
        The bounds of the search space. It should be a list of tuples, where
        each tuple corresponds to the lower and upper bounds of a dimension.
    popsize : int, optional
        The population size. Default is 100.
    maxiter : int, optional
        The maximum number of iterations. Default is 1000.
    F : float, optional
        The scaling factor. Default is 0.5.
    CR : float, optional
        The crossover probability. Default is 0.9.
    seed : int, optional
        The random seed. Default is None.
        
    Returns
    -------
    x : array_like
        The best solution found by the algorithm.
    f : float
        The corresponding function value.
    """
    # Set random seed
    if seed is not None:
        np.random.seed(seed)
    
    # Initialize population
    D = len(bounds)
    pop = np.random.rand(popsize, D) * (bounds[:, 1] - bounds[:, 0]) + bounds[:, 0]
    fitness = np.array([F(x) for x in pop])
    best_idx = np.argmin(fitness)
    best_x, best_f = pop[best_idx], fitness[best_idx]
    
    # Main loop
    for t in range(maxiter):
        for i in range(popsize):
            # Select three different solutions
            idxs = np.random.choice(popsize, 3, replace=False)
            x1, x2, x3 = pop[idxs]
            
            # Generate a trial vector
            v = x1 + F * (x2 - x3)
            
            # Perform crossover
            u = np.copy(pop[i])
            jrand = np.random.randint(D)
            for j in range(D):
                if np.random.rand() < CR or j == jrand:
                    u[j] = v[j]
            
            # Evaluate the trial vector
            f = F(u)
            
            # Update the population
            if f < fitness[i]:
                pop[i] = u
                fitness[i] = f
        
        # Update the best solution
        best_idx = np.argmin(fitness)
        if fitness[best_idx] < best_f:
            best_x, best_f = pop[best_idx], fitness[best_idx]
    
    return best_x, best_f

为了可视化对比两种算法的区别，我们可以用 Matplotlib 绘制算法的优化轨迹。以下是一个简单的示例代码，用于绘制 Rastrigin 函数的优化轨迹：

import matplotlib.pyplot as plt

def rastrigin(x):
    return 10 * len(x) + np.sum(x**2 - 10 * np.cos(2 * np.pi * x))

bounds = [(-5.12, 5.12)] * 2
x_sade, f_sade = SaDE(rastrigin, bounds)
x_de, f_de = DE(rastrigin, bounds)

fig, ax = plt.subplots(figsize=(8, 6))
ax.contourf(X, Y, Z, levels=100)
ax.plot(*zip(*x_sade_traj), color='red', label='SaDE')
ax.plot(*zip(*x_de_traj), color='blue', label='DE')
ax.scatter(*x_sade, color='red', marker='*', s=200)
ax.scatter(*x_de, color='blue', marker='*', s=200)
ax.legend()
plt.show()

这段代码会绘制 Rastrigin 函数的等高线图和两种算法的优化轨迹。其中，红色表示 SaDE 算法的优化轨迹，蓝色表示 DE 算法的优化轨迹。我们可以看到，SaDE 算法的优化轨迹更加平滑，收敛速度更快，而 DE 算法的优化轨迹更加抖动，收敛速度更慢。

当然，这只是一个简单的可视化示例，实际情况下两种算法的效果会受到很多因素的影响，如参数的选择、搜索空间的维度、目标函数的特性等等。因此，我们需要根据具体的问题来选择适合的优化算法。