多源局部排名数据下的全局排序算法详解与Python实践

def _rank_list_to_scores(rank_list):
    """
    将局部排名列表转换为基于位置的分数字典。
    列表中的第一个元素（最佳）获得最高分，最后一个元素（最差）获得最低分。

    Args:
        rank_list (list): 一个裁判的局部排名列表。

    Returns:
        dict: 项目及其对应分数的字典。
    """
    list_length = len(rank_list)
    # 使用map和lambda函数简洁地创建得分字典
    # x是列表中的元素，rank_list.index(x)是其索引
    return dict(map(lambda x: (x, list_length - rank_list.index(x)), rank_list))

# 示例：
j1_rank = ['a', 'c', 'e']
j1_rank_scores = _rank_list_to_scores(j1_rank)
# j1_rank_scores 将是 {'a': 3, 'c': 2, 'e': 1}
print(f"裁判1的评分: {j1_rank_scores}")

from collections import defaultdict

def _aggregate_scores(all_items, judge_score_dicts):
    """
    聚合所有项目的分数。

    Args:
        all_items (list): 包含所有待排名项目的列表。
        judge_score_dicts (list of dict): 包含所有裁判评分字典的列表。

    Returns:
        defaultdict: 每个项目及其累加总分的字典。
    """
    aggregated_scores = defaultdict(int)
    for item in all_items:
        for judge_score_dict in judge_score_dicts:
            # 如果项目不在某个裁判的评分中，则其得分为0
            aggregated_scores[item] += judge_score_dict.get(item, 0)
    return aggregated_scores

# 假设已经有了所有裁判的评分字典
# j1_rank_scores = {'a': 3, 'c': 2, 'e': 1}
# j2_rank_scores = {'b': 3, 'd': 2, 'f': 1}
# j3_rank_scores = {'a': 3, 'b': 2, 'c': 1}
# j4_rank_scores = {'d': 3, 'e': 2, 'f': 1}

# all_judge_scores = [j1_rank_scores, j2_rank_scores, j3_rank_scores, j4_rank_scores]
# aggregated_result = _aggregate_scores(['a', 'b', 'c', 'd', 'e', 'f'], all_judge_scores)
# aggregated_result 将是 {'a': 6, 'b': 5, 'c': 3, 'd': 5, 'e': 3, 'f': 2}
# print(f"聚合后的分数: {aggregated_result}")

def _generate_global_rank(aggregated_scores):
    """
    根据聚合分数生成最终的全局排序列表。

    Args:
        aggregated_scores (defaultdict): 每个项目及其累加总分的字典。

    Returns:
        list: 重构后的全局排序列表。
    """
    # 根据累加的得分降序排列项目，得分最高的项目排在前面。
    # sorted函数返回一个元组列表，每个元组包含(项目, 总得分)。
    # lambda item: item[1] 指定按元组的第二个元素（即得分）进行排序。
    final_ranked_items_with_scores = sorted(aggregated_scores.items(), key=lambda item: item[1], reverse=True)

    # 提取排序后的项目名称作为最终的全局排名列表
    global_ranked_list = [item[0] for item in final_ranked_items_with_scores]
    return global_ranked_list

# 假设 aggregated_scores = {'a': 6, 'b': 5, 'c': 3, 'd': 5, 'e': 3, 'f': 2}
# global_rank = _generate_global_rank(aggregated_scores)
# global_rank 将是 ['a', 'b', 'd', 'c', 'e', 'f']
# print(f"最终全局排名: {global_rank}")

from collections import defaultdict

def reconstruct_global_rank(all_items, partial_ranks_by_judges):
    """
    从多个局部排名列表重构一个全局排序列表。

    Args:
        all_items (list): 包含所有待排名项目的列表。
        partial_ranks_by_judges (list of lists): 每个子列表代表一个裁判的局部排名。
                                                  列表中的顺序表示从最佳到最差。

    Returns:
        list: 重构后的全局排序列表。
    """

    # 步骤一：标准化局部排名为分数
    judge_score_dicts = []
    for rank_list in partial_ranks_by_judges:
        list_length = len(rank_list)
        score_dict = dict(map(lambda x: (x, list_length - rank_list.index(x)), rank_list))
        judge_score_dicts.append(score_dict)
    print(f"标准化后的裁判评分字典: {judge_score_dicts}")

    # 步骤二：聚合所有项目的分数
    aggregated_scores = defaultdict(int)