1. 项目概述：当咖啡遇上“凯文·贝肯”与MATLAB

作为一名常年与数据和算法打交道的工程师，我经常在深夜调试代码时，手边放着一杯咖啡。有一天，一个有趣的念头突然冒了出来：我们熟知的“六度空间理论”（或者说“凯文·贝肯游戏”）和MATLAB这个强大的计算环境能碰撞出什么火花？这个标题“Coffee and the 6 degrees of Kevin Bacon… Uh, I mean MATLAB.” 精准地捕捉到了这种跨界联想的状态——在咖啡因的催化下，将流行文化中的社交网络概念，用严谨的数学工具进行解构和再现。这不仅仅是一个编程练习，更是一种思维实验：我们如何用MATLAB来量化“世界很小”这个概念，并可视化人与人之间那看似复杂实则紧密的联系。

简单来说，这个“项目”的核心是使用MATLAB构建并分析一个社交网络图，模拟“六度空间理论”，并可能通过凯文·贝肯在好莱坞电影合作网络中的中心性来作为一个具体案例。它适合所有对社交网络分析、图论感兴趣，并且希望用MATLAB将理论付诸实践的工程师、数据科学爱好者和学生。你不需要是图论专家，但需要对MATLAB的基本操作和矩阵运算有初步了解。接下来，我将分享如何一步步实现这个想法，从数据模拟到算法实现，再到可视化分析，并穿插大量我在实操中踩过的坑和总结的技巧。

2. 核心思路与理论基础拆解

2.1 从“凯文·贝肯游戏”到图论模型

“凯文·贝肯游戏”是基于“六度空间理论”的一个娱乐化应用，其规则是：任意一位演员，都可以通过其参演的电影，在不超过六步（即通过五位中间演员）之内，与演员凯文·贝肯建立联系。这本质上是一个 无向图 的 最短路径 问题。

在这个图模型中：

• 节点 ：代表每一位演员。
• 边 ：代表两位演员共同出演过至少一部电影。边的权重通常为1（表示一次合作）。
• 核心问题 ：计算图中任意一个节点（演员）到特定目标节点（凯文·贝肯）的最短路径长度。

在MATLAB中，我们最自然的数据结构就是 邻接矩阵 。一个 N×N 的矩阵 A ，如果演员 i 和演员 j 合作过，则 A(i, j) = 1 ，否则为0。由于合作是相互的，这个矩阵是对称矩阵。我们的任务就是在这个稀疏的矩阵上，执行最短路径搜索。

注意 ：真实的好莱坞合作网络数据量巨大（数十万演员），我们初期可以用小规模的模拟数据或开源的小数据集（如MovieLens数据集衍生的演员关系子集）进行验证。直接从零构建全网数据爬取和处理，工程量巨大，不是本实验的核心。

2.2 MATLAB的天然优势与工具选择

为什么用MATLAB做这个？很多人第一反应可能是Python的NetworkX。的确，Python在数据抓取和快速原型上有优势，但MATLAB在矩阵运算、算法原型快速验证以及高质量可视化方面，有着独特的便利性。

1. 矩阵运算为核心 ：图算法的本质是矩阵运算。MATLAB从名字（MATrix LABoratory）就为此而生。计算邻接矩阵的幂（用于寻找多步连接）、实现稀疏矩阵运算，MATLAB的语法极其简洁高效。
2. 内置图与网络算法工具箱 ：从R2015b开始，MATLAB引入了 graph 和 digraph 对象，以及配套的算法函数（如 shortestpath , distances , centrality ）。这使得构建和分析图变得像操作普通数组一样简单。
3. 卓越的可视化能力 ： plot 函数可以直接绘制网络图，并且可以方便地调整节点颜色、大小（代表度中心性）、边的粗细，交互式图形窗口还能进行缩放和探查。这对于直观理解网络结构至关重要。
4. 原型开发速度快 ：在IDE中，可以分段执行代码，实时查看变量和图形结果，快速迭代算法思路，这比写脚本-运行-调试的循环要直观得多。

基于这些考虑，我们将主要依赖MATLAB的 基础矩阵功能 和 图与网络算法工具箱 。如果手头没有该工具箱，部分核心算法（如BFS用于无权图最短路径）也可以自己用矩阵操作实现。

3. 数据准备与网络构建实操

3.1 模拟数据生成：快速搭建实验舞台

在获取真实数据之前，我们可以先创建一个具有“小世界”特性的随机网络来模拟社交网络。Watts-Strogatz模型是一个很好的选择，它能生成具有高聚类系数和短平均路径长度的网络，这与“六度空间”的假设相符。

% 参数设置
numNodes = 100; % 模拟100个演员
K = 4; % 每个节点的初始最近邻连接数
beta = 0.1; % 重连概率

% 使用内置函数生成小世界网络
G_sw = wattsStrogatz(numNodes, K, beta);

% 查看网络基本信息
disp(G_sw);
fprintf('网络平均度: %.2f\n', mean(degree(G_sw)));
fprintf('网络平均路径长度: %.2f\n', averagePathLength(G_sw));
fprintf('网络聚类系数: %.2f\n', averageClustering(G_sw));

这里， wattsStrogatz 函数直接返回一个 graph 对象 G_sw 。我们指定一个节点（比如第50号节点）作为我们的“凯文·贝肯”。通过计算所有节点到该节点的最短路径距离，就可以验证“六度”是否成立。

% 指定目标节点（我们的“Kevin Bacon”）
kb_node = 50;
% 计算所有节点到目标节点的最短路径距离（无权图）
d = distances(G_sw, kb_node);
% 统计距离分布
dist_counts = histcounts(d(d~=inf), 0:max(d)+1);
disp('最短路径距离分布：');
for i = 1:length(dist_counts)
    fprintf('距离 %d: %d 个节点\n', i-1, dist_counts(i));
end

3.2 处理真实数据：以MovieLens为例

模拟数据好玩，但真实数据更有说服力。我们可以使用GroupLens提供的MovieLens数据集（如ml-latest-small）。这个数据集包含 movies.csv （电影信息）和 ratings.csv （评分），但没有直接的演员-演员关系。我们需要通过“共同出演同一部电影”来构建关系。

步骤一：数据读取与预处理

% 读取电影数据，假设电影标题中包含演员信息（如“Toy Story (1995)”）
% 注意：真实MovieLens不含演员表，此处为演示流程。更真实的演员关系数据可从IMDb数据集获取。
movies = readtable('movies.csv', 'TextType', 'string');
% 假设我们有一个自定义的‘actors.csv’，包含movieId和actorName
actors = readtable('actors.csv', 'TextType', 'string');

% 获取唯一演员列表
uniqueActors = unique(actors.actorName);
numActors = length(uniqueActors);
fprintf('找到 %d 位唯一演员。\n', numActors);

步骤二：构建演员-电影关联矩阵 这是一个“演员-电影”二部图。矩阵 M 的大小为 (numActors × numMovies) ，如果演员 i 出演了电影 j ，则 M(i, j) = 1 。

% 创建演员和电影的映射字典
[actorDict, ~, actorIdx] = unique(actors.actorName);
[movieDict, ~, movieIdx] = unique(actors.movieId);

% 构建稀疏的关联矩阵（节省内存）
M = sparse(actorIdx, movieIdx, 1, numActors, length(movieDict));

步骤三：推导演员合作网络（邻接矩阵） 演员 i 和 j 合作过，当且仅当存在至少一部电影 k ，使得 M(i, k) = 1 且 M(j, k) = 1 。这可以通过矩阵乘法优雅实现： A = M * M' 。结果矩阵 A 的对角线元素 A(i, i) 表示演员 i 参演的电影数量，非对角线元素 A(i, j) 表示演员 i 和 j 共同出演的电影数量。

% 计算合作强度矩阵（共同电影数）
A_cooccur = M * M';
% 将对角线置零，避免自己与自己连接
A_cooccur = A_cooccur - diag(diag(A_cooccur));
% 转换为二元邻接矩阵（只要合作过，边权重为1）
A_binary = A_cooccur > 0;
% 创建无向图对象
G = graph(A_binary, actorDict, 'omitselfloops');
fprintf('构建的演员合作网络包含 %d 个节点和 %d 条边。\n', numnodes(G), numedges(G));

实操心得 ：对于大型数据集， M 矩阵会非常稀疏。务必使用 sparse 矩阵格式存储和运算，否则内存会迅速耗尽。 M * M' 这个操作在稀疏矩阵下效率很高。另外， ‘omitselfloops’ 参数很重要，它能自动剔除自环（即演员与自己合作的无意义边）。

4. 核心算法实现与“贝肯数”计算

4.1 广度优先搜索：计算最短路径

对于无权图（边权重为1），计算一个源点到所有其他点最短路径的最经典算法是广度优先搜索。MATLAB的 distances 函数默认使用BFS处理无权图。

% 假设我们在网络中找到了凯文·贝肯的索引
% 这里假设他的名字在actorDict里是'Kevin Bacon'
kb_name = "Kevin Bacon";
kb_index = find(actorDict == kb_name);
if isempty(kb_index)
    error('在数据集中未找到凯文·贝肯。');
end

% 计算所有演员的“贝肯数”（到凯文·贝肯的最短距离）
bacon_numbers = distances(G, kb_index);
% 统计分布
max_bacon_num = max(bacon_numbers(bacon_numbers ~= inf));
histogram_data = histcounts(bacon_numbers(bacon_numbers~=inf), 0:max_bacon_num+1);

figure;
bar(0:max_bacon_num, histogram_data);
xlabel('贝肯数 (到Kevin Bacon的最短路径长度)');
ylabel('演员数量');
title('演员合作网络中“贝肯数”分布');
grid on;

如果 distances 返回 Inf ，表示该节点与目标节点不在同一个连通分量内，即网络中存在“孤岛”。在好莱坞合作网络中，几乎所有演员都在一个巨大的连通分量里。

4.2 深入分析：网络中心性度量

“凯文·贝肯游戏”之所以成立，不仅因为“六度”，更因为凯文·贝肯本人处于网络的中心位置。我们可以计算几种中心性指标来验证：

1. 度中心性 ：一个演员合作过的演员数量。这反映了他的直接影响力。

   deg_cent = centrality(G, 'degree');
   [sorted_deg, idx_deg] = sort(deg_cent, 'descend');
   fprintf('度中心性最高的前5位演员：\n');
   for i = 1:5
       fprintf('%s: %.0f\n', actorDict{idx_deg(i)}, sorted_deg(i));
   end
   

2. 接近中心性 ：一个节点到网络中所有其他节点平均最短距离的倒数。值越高，说明该节点越处于网络的中心，能快速到达其他节点。这直接关系到“贝肯数”是否普遍较小。

   close_cent = centrality(G, 'closeness');
   [sorted_close, idx_close] = sort(close_cent, 'descend');
   fprintf('\n接近中心性最高的前5位演员：\n');
   for i = 1:5
       fprintf('%s: %.4f\n', actorDict{idx_close(i)}, sorted_close(i));
   end
   % 查看凯文·贝肯的接近中心性排名
   kb_close_rank = find(idx_close == kb_index);
   fprintf('凯文·贝肯的接近中心性排名是: %d\n', kb_close_rank);
   

3. 介数中心性 ：衡量一个节点作为“桥梁”的重要性，即有多少条最短路径经过该节点。

   between_cent = centrality(G, 'betweenness');
   [sorted_bet, idx_bet] = sort(between_cent, 'descend');
   fprintf('\n介数中心性最高的前5位演员：\n');
   for i = 1:5
       fprintf('%s: %.0f\n', actorDict{idx_bet(i)}, sorted_bet(i));
   end
   

通过对比，你可能会发现凯文·贝肯的度中心性未必最高（合作者最多的可能是那些戏路极广的配角），但他的接近中心性很可能非常高，这意味着他确实是一个很好的网络“中心点”。

4.3 路径追溯与可视化

知道“贝肯数”是3还不够，我们还想知道具体是哪三位演员连接了你和凯文·贝肯。 shortestpath 函数可以返回路径节点序列。

% 随机选择一个起点演员，例如‘Tom Hanks’
start_name = "Tom Hanks";
start_index = find(actorDict == start_name);
if ~isempty(start_index) && bacon_numbers(start_index) ~= inf
    [path, path_len] = shortestpath(G, start_index, kb_index);
    fprintf('从 %s 到 Kevin Bacon 的路径（长度 %d）：\n', start_name, path_len);
    for i = 1:length(path)
        fprintf('%d. %s\n', i, actorDict{path(i)});
    end
else
    fprintf('演员 %s 未找到或与Kevin Bacon不连通。\n', start_name);
end

为了直观展示，我们可以绘制整个网络，并高亮显示这条最短路径。

figure;
p = plot(G, 'Layout', 'force3', 'NodeLabel', {}, 'MarkerSize', 3, 'EdgeAlpha', 0.1);
% 高亮起点、终点和路径
highlight(p, kb_index, 'NodeColor', 'r', 'MarkerSize', 10);
highlight(p, start_index, 'NodeColor', 'g', 'MarkerSize', 10);
highlight(p, path, 'NodeColor', 'b', 'MarkerSize', 6);
highlight(p, path(1:end-1), path(2:end), 'EdgeColor', 'b', 'LineWidth', 2);
title(sprintf('合作网络与路径示例: %s -> Kevin Bacon', start_name));

注意事项 ：绘制包含成千上万个节点的完整网络图会导致图形卡顿且难以辨认。通常有两种策略：1）只绘制一个包含目标路径的局部子图（使用 subgraph 函数）；2）使用力导向布局但隐藏大部分节点标签，只显示关键节点。 ‘force3’ 布局是三维力导向，在旋转视图时能更好地展示网络结构，但计算量较大。

5. 性能优化与大规模数据处理技巧

当演员数量上升到数万甚至数十万时，直接使用 graph 对象和内置函数可能会遇到内存和性能瓶颈。以下是一些实战优化技巧：

5.1 使用稀疏矩阵与底层函数

对于超大规模网络，我们可以直接操作稀疏邻接矩阵 A_sparse ，并使用图论中的矩阵算法。例如，计算从单个源点出发的最短路径（BFS），可以避免使用 distances(G, source) 这种可能为全图计算的高开销函数，而是自己实现一个轻量级BFS。

function dist = bfs_sparse(A_sparse, source)
    % A_sparse: 稀疏邻接矩阵 (N x N), 对称二元矩阵
    % source: 源点索引
    % dist: 从源点到所有点的距离，无法到达则为Inf
    N = size(A_sparse, 1);
    dist = inf(N, 1);
    dist(source) = 0;
    queue = source;
    current = 1;
    tail = 1;
    
    while current <= tail
        u = queue(current);
        current = current + 1;
        % 获取节点u的所有邻居（稀疏矩阵列操作）
        [~, neighbors] = find(A_sparse(:, u)); % 因为是无向图，取列或行均可
        for v = neighbors'
            if isinf(dist(v))
                dist(v) = dist(u) + 1;
                tail = tail + 1;
                queue(tail) = v;
            end
        end
    end
end

这个自定义的BFS只使用稀疏矩阵的 find 操作，内存效率高，对于计算单个源点的“贝肯数”分布足够快。

5.2 分块计算与并行处理

如果需要计算所有节点对之间的最短路径（例如计算网络直径或平均路径长度），直接计算 distances(G) 对于大图是不可行的。此时可以采用采样估计，或者利用MATLAB的并行计算工具箱进行分块计算。

% 假设我们只想计算平均路径长度的估计值，随机采样S个源点
S = 100;
N = numnodes(G);
sample_nodes = randperm(N, S);
avg_path_lengths = zeros(S, 1);

parfor i = 1:S % 使用parfor并行循环
    d = distances(G, sample_nodes(i));
    avg_path_lengths(i) = mean(d(d~=inf));
end

estimated_avg_path_length = mean(avg_path_lengths);
fprintf('基于 %d 个采样节点的估计平均路径长度: %.3f\n', S, estimated_avg_path_length);

踩坑记录 ：使用 parfor 时，确保循环体内部的 distances 调用是独立的，并且 G 是广播变量。对于极大的图，即使采样计算，每次 distances 调用开销也很大。此时，用前面自定义的 bfs_sparse 替换 distances 会获得更好的性能，因为我们可以直接传递稀疏矩阵 A_sparse 。

5.3 数据存储与增量构建

如果数据源是流式的或需要从多个文件构建，不要试图一次性将所有数据读入内存再构建关联矩阵 M 。应该采用增量构建稀疏矩阵的方式。

% 初始化空的稀疏矩阵列表
row_indices = [];
col_indices = [];
% 假设分批次读取actors数据
for batch = 1:numBatches
    actors_batch = readPart('actors.csv', batch);
    % 将演员名和电影ID映射为全局索引
    [~, actorIdx_batch] = ismember(actors_batch.actorName, actorDict);
    [~, movieIdx_batch] = ismember(actors_batch.movieId, movieDict);
    % 累积索引
    row_indices = [row_indices; actorIdx_batch];
    col_indices = [col_indices; movieIdx_batch];
end
% 一次性构建稀疏矩阵
M = sparse(row_indices, col_indices, 1, numActors, numMovies);

这种方法能有效控制内存峰值使用量。

6. 常见问题与调试技巧实录

在实现过程中，你几乎一定会遇到下面这些问题。这里是我的排查记录和解决方案。

6.1 内存不足错误

问题 ：构建 A = M * M' 时，MATLAB报错“Out of memory”。 原因 ：虽然 M 是稀疏的，但 A 的密度可能比 M 高很多（演员合作网络比演员-电影网络连接更稠密）。即使 A 也是稀疏的，但中间计算过程可能会产生巨大的临时稠密矩阵。 解决 ：

1. 确保 M 是 sparse 类型。
2. 使用专门为稀疏矩阵乘法优化的函数或分块计算。可以尝试逐行或逐列计算 A 的一部分。

   % 分块计算邻接矩阵的一行
   N = size(M, 1);
   blockSize = 1000;
   A = sparse(N, N);
   for i = 1:blockSize:N
       iEnd = min(i+blockSize-1, N);
       % 计算 M(i:iEnd, :) * M'，得到 A 的一个行块
       A_block = M(i:iEnd, :) * M';
       A(i:iEnd, :) = A_block;
   end
   

3. 考虑使用 spones 函数在乘法后立即将大于1的值转为1，并转换为逻辑稀疏矩阵以节省空间： A = spones(M * M') 。

6.2 最短路径计算返回大量 Inf

问题 ： bacon_numbers 中很多值是 Inf 。 原因 ：网络不是全连通的。存在多个连通分量，而你的“凯文·贝肯”只在他所在的连通分量中。 排查与解决 ：

% 检查图的连通分量
[bin, binsize] = conncomp(G);
fprintf('网络共有 %d 个连通分量。\n', max(bin));
% 查看各分量大小
tabulate(bin);
% 找出凯文·贝肯所在的连通分量
kb_component = bin(kb_index);
% 找出该分量中的所有节点
actors_in_kb_component = find(bin == kb_component);
fprintf('凯文·贝肯所在的连通分量包含 %d 名演员。\n', length(actors_in_kb_component));

如果“凯文·贝肯”所在的分量足够大（比如包含90%以上的节点），那么“六度空间”在这个分量内依然成立。你可以只分析这个最大连通分量： G_lcc = subgraph(G, actors_in_kb_component); 。

6.3 可视化图形一团乱麻

问题 ：调用 plot(G) 后，图形窗口显示为一团密集的点和线，无法辨识。 解决 ：

1. 简化图形 ：不显示节点标签 ‘NodeLabel’, {} ，减小节点大小 ‘MarkerSize’, 2 ，降低边透明度 ‘EdgeAlpha’, 0.05 。
2. 更换布局算法 ：尝试 ‘Layout’, ‘force’ (二维力导向)、 ‘subspace’ (适用于具有社区结构的网络)、或 ‘layered’ (有向无环图适用)。三维布局 ‘force3’ 有时在交互旋转后能提供更好的空间分离感。
3. 绘制子图 ：只绘制你关心的部分，例如“凯文·贝肯”的 ego-network（他及其一度邻居）。

   % 获取一度邻居
   neighbors = neighbors(G, kb_index);
   ego_nodes = [kb_index; neighbors];
   G_ego = subgraph(G, ego_nodes);
   plot(G_ego, ‘NodeLabel’, actorDict(ego_nodes), ‘Layout’, ‘circle’);
   

4. 使用专业工具 ：对于极其复杂的网络，MATLAB的绘图功能可能达到极限。可以考虑将网络数据（节点列表、边列表）导出为GEXF或GraphML格式，使用Gephi等专业网络可视化软件进行渲染和探索。

6.4 算法运行速度慢

问题 ：计算中心性或 distances 非常耗时。 解决 ：

1. 使用近似算法 ：对于接近中心性和介数中心性，在大图上计算精确值成本极高。可以使用基于随机采样的近似算法。MATLAB的 centrality 函数部分支持 ‘Importance’ 采样选项。
2. 降维分析 ：如果只关心排名最前的节点，可以不用计算所有节点的中心性。例如，度中心性很容易从邻接矩阵的行和获得。对于接近中心性，可以只从疑似处于网络中心的节点（如高度节点）开始计算。
3. 检查数据类型 ：确保邻接矩阵是数值逻辑型 logical 或单精度 single ，而不是默认的双精度 double ，这可以节省近一半内存并提升计算速度，尤其对于稀疏矩阵。

   A_binary_logical = logical(A_cooccur > 0);
   G = graph(A_binary_logical);
   

7. 项目扩展与深入探索方向

完成基础分析后，这个项目还有很多可以深挖和玩味的方向，让一杯咖啡的时间产生更多价值。

7.1 引入时间维度：网络演化分析

好莱坞合作网络不是静态的。我们可以给边加上时间戳（合作年份），研究网络如何随时间演变。例如，凯文·贝肯的“中心性”是随时间增强还是减弱？网络的平均路径长度（“六度”是否在缩小）随时间如何变化？

这需要有时间标记的数据。我们可以按年代切片网络，分别计算每个时间片段的网络属性和贝肯数。

% 假设actors表中有‘year’列
years = unique(actors.year);
for y = years'
    idx = actors.year == y;
    % 构建该年份的子图（需要重新构建该年份的关联矩阵）
    % ... 构建过程同上 ...
    G_year = graph(...);
    % 计算该年份的网络属性
    avg_path_length(y) = averagePathLength(G_year);
    % 计算该年份凯文·贝肯的接近中心性
    if ismember(kb_index, G_year.Nodes.Name)
        kb_close_cent_by_year(y) = centrality(G_year, 'closeness', 'Importance', G_year.Edges.Weight);
    end
end
% 绘制趋势图
figure;
yyaxis left; plot(years, avg_path_length); ylabel('平均路径长度');
yyaxis right; plot(years, kb_close_cent_by_year); ylabel('KB接近中心性');
xlabel('年份'); title('网络演化分析');

7.2 加权网络：合作强度与“亲密”距离

在基础模型中，边权重是1（合作过）。但合作多次与合作一次的关系强度显然不同。我们可以用共同出演的电影数量作为边的权重，并定义“距离”为合作强度的倒数（例如 距离 = 1 / 合作电影数 ）。这样，频繁合作的演员之间“距离”更短。此时的最短路径算法就需要使用Dijkstra算法（MATLAB的 distances 和 shortestpath 函数在边权重非负时自动使用）。

% 使用共同电影数作为权重，但转换为距离（合作越多，距离越近）
% 避免除零，先处理零值
collab_strength = A_cooccur;
collab_strength(collab_strength == 0) = 1; % 将无合作设为1，避免无穷大，实际计算时会忽略这些边
distance_matrix = 1 ./ collab_strength;
% 创建加权图
G_weighted = graph(A_cooccur > 0, distance_matrix, actorDict, 'omitselfloops');
% 计算加权最短路径（亲密距离）
weighted_bacon_numbers = distances(G_weighted, kb_index);

7.3 社区发现：好莱坞的“圈子”

网络中的社区结构是指内部连接紧密、外部连接稀疏的节点群。我们可以使用社区发现算法（如Louvain算法、标签传播算法）来识别好莱坞中的不同“圈子”（如喜剧圈、动作片圈、独立电影圈等）。MATLAB的 communitydetection 函数（需要R2021a及以上）或第三方工具箱可以实现。

% 使用Louvain算法进行社区发现（需安装合适的工具箱或自定义函数）
% 假设我们有一个实现好的my_louvain函数，返回社区标签
communities = my_louvain(adjacency(G));
numCommunities = max(communities);
% 可视化，按社区给节点上色
figure;
p = plot(G, 'Layout', 'force3', 'NodeCData', communities, 'MarkerSize', 5, 'EdgeAlpha', 0.1);
colormap(jet(numCommunities));
colorbar;
title('演员合作网络社区结构');
% 查看凯文·贝肯属于哪个社区
fprintf('凯文·贝肯属于社区 %d。\n', communities(kb_index));

这个分析可以揭示凯文·贝肯是固守某个圈子，还是跨多个圈子的“桥梁型”人物（这通常会赋予他较高的介数中心性）。

7.4 构建交互式查询工具

利用MATLAB的App Designer，可以快速构建一个图形化界面，让用户输入任意演员名字，自动计算并显示其到凯文·贝肯的最短路径、贝肯数，并在网络图中高亮显示。

这涉及到：

1. 使用 uieditfield 接收输入。
2. 使用 uibutton 触发查询。
3. 在 uiaxes 中绘制网络图并高亮路径。
4. 使用 uitable 或 uilabel 显示路径详情。

虽然代码量会增长，但App Designer的拖拽式界面设计和回调函数编写，使得创建这样一个兼具分析和展示功能的小工具变得非常直观。这能将这个项目从一个脚本提升为一个可交互的演示应用，非常适合用于教学或展示。

从一杯咖啡的奇思妙想，到用MATLAB构建并分析一个复杂的社交网络，这个过程充满了工程实现的乐趣和数据分析的洞察。关键在于从简单的模拟开始，逐步引入真实数据，并善用MATLAB强大的矩阵和图论工具箱。过程中遇到的性能、可视化问题，恰恰是提升你解决实际问题能力的契机。最后，别忘了分享你的发现——也许你会发现，某个看似不相关的演员，通过一条意想不到的路径，仅仅三步就连接到了凯文·贝肯，这或许就是“小世界”网络最迷人的地方。