如何实现嵌套字符串数组的自定义排序及重复元素替换？

1. 自定义排序实现目标顺序 #

从目标结构反推排序规则：

• 子数组第一个元素优先按 'A' 在前、'B' 在后排序
• 当第一个元素相同时：
  • 若第一个元素是 'A'，第二个元素按 'A' → 'B' 排序
  • 若第一个元素是 'B'，第二个元素按 'B' → 'A' 排序

以下是两种常见语言的实现：

Python 排序代码 #

def custom_sort(arr):
    def sort_key(item):
        # 为每个子数组分配排序权重，权重越小越靠前
        if item[0] == 'A':
            return 0 if item[1] == 'A' else 1
        else:
            return 2 if item[1] == 'B' else 3
    return sorted(arr, key=sort_key)

JavaScript 排序代码 #

function customSort(arr) {
    return arr.sort((a, b) => {
        if (a[0] !== b[0]) {
            // 第一个元素A优先于B
            return a[0] === 'A' ? -1 : 1;
        }
        // 第一个元素相同的情况
        if (a[0] === 'A') {
            // A开头的子数组，第二个元素A在前
            return a[1] === 'A' ? -1 : 1;
        } else {
            // B开头的子数组，第二个元素B在前
            return a[1] === 'B' ? -1 : 1;
        }
    });
}

2. 折叠重复元素（替换为空字符串） #

遍历排序后的数组，从第二个子数组开始，将每个位置的元素与前一个子数组对应位置的元素比较，若相同则替换为空字符串。操作时使用数组副本，避免修改原数组。

Python 折叠代码 #

def collapse_duplicates(arr):
    if not arr:
        return []
    result = [arr[0].copy()]
    for i in range(1, len(arr)):
        current = arr[i].copy()
        prev = result[i-1]
        for j in range(len(current)):
            if current[j] == prev[j]:
                current[j] = ''
        result.append(current)
    return result

JavaScript 折叠代码 #

function collapseDuplicates(arr) {
    if (!arr.length) return [];
    const result = [arr[0].slice()];
    for (let i = 1; i < arr.length; i++) {
        const current = arr[i].slice();
        const prev = result[i-1];
        for (let j = 0; j < current.length; j++) {
            if (current[j] === prev[j]) {
                current[j] = '';
            }
        }
        result.push(current);
    }
    return result;
}

3. 组合使用示例 #

Python 完整流程 #

original = [['A', 'B'], ['B', 'A'], ['B', 'B'], ['A', 'A']]
sorted_arr = custom_sort(original)
final_arr = collapse_duplicates(sorted_arr)
print(final_arr)
# 输出：[['A', 'A'], ['', 'B'], ['B', 'B'], ['', 'A']]

JavaScript 完整流程 #

const original = [['A', 'B'], ['B', 'A'], ['B', 'B'], ['A', 'A']];
const sortedArr = customSort(original);
const finalArr = collapseDuplicates(sortedArr);
console.log(finalArr);
// 输出：[["A","A"], ["","B"], ["B","B"], ["","A"]]

上述代码兼容子数组包含多个元素的场景，因为折叠逻辑会遍历每个位置逐一比较。

内容的提问来源于stack exchange，提问作者gjonte