Qt中使用QRegularExpression实现智能字符串排序

1. 项目背景与需求解析

在数据处理和文件管理场景中，我们经常遇到需要按照特定规则对字符串进行排序的需求。比如处理混合了数字、字母和汉字的文件名时，简单的字典序排序往往无法满足实际业务需求。举个典型例子：当我们需要对"文件1"、"文件10"、"文件2"、"A文件"、"B文件"、"测试文件"这样的序列进行排序时，默认的排序结果会是：

code复制A文件
B文件
test文件
文件1
文件10
文件2

这显然不符合人类的自然认知顺序。理想的排序结果应该是：

code复制文件1
文件2
文件10
A文件
B文件
test文件

要实现这种符合直觉的排序，我们需要解决三个核心问题：

1. 如何识别并提取字符串中的数字部分进行数值排序
2. 如何处理字母和汉字的混合排序
3. 如何实现多级排序（先数字、再字母、最后汉字）

2. 技术选型：为什么选择QRegularExpression

在Qt框架中，QRegularExpression是处理正则表达式的最新一代工具，相比旧的QRegExp类具有以下优势：

1. 性能更优：采用PCRE（Perl Compatible Regular Expressions）引擎，匹配速度更快
2. 功能更全：支持命名捕获组、lookahead/lookbehind等高级特性
3. Unicode支持：完美处理多语言文本，特别是对汉字的支持
4. API更现代：与C++11及后续标准兼容性更好

对于我们的排序需求，QRegularExpression能够：

• 精确识别字符串中的数字序列（包括前导零的情况）
• 区分ASCII字母和汉字字符
• 通过捕获组提取关键排序要素

3. 核心实现方案设计

3.1 正则表达式设计

我们需要设计三个层级的正则表达式来提取排序要素：

1. 数字提取：(\d+) 匹配连续数字
2. 字母提取：([a-zA-Z]+) 匹配ASCII字母
3. 汉字提取：([\u4e00-\u9fa5]+) 匹配Unicode汉字范围

考虑到字符串可能包含混合内容，最终的正则表达式组合为：
^(?:(\d+)|([a-zA-Z]+)|([\u4e00-\u9fa5]+))

3.2 排序算法设计

采用三级排序策略：

1. 优先比较数字部分的数值大小
2. 数字相同则比较字母部分的字典序
3. 前两者都相同则比较汉字部分的Unicode码位

cpp复制struct StringComparer {
    bool operator()(const QString &a, const QString &b) const {
        auto partsA = extractSortParts(a);
        auto partsB = extractSortParts(b);
        
        // 第一优先级：数字比较
        if (partsA.number != partsB.number) {
            return partsA.number < partsB.number;
        }
        
        // 第二优先级：字母比较
        if (partsA.letters != partsB.letters) {
            return partsA.letters < partsB.letters;
        }
        
        // 第三优先级：汉字比较
        return partsA.chinese < partsB.chinese;
    }
    
private:
    struct SortParts {
        int number = 0;
        QString letters;
        QString chinese;
    };
    
    SortParts extractSortParts(const QString &str) const {
        // 实现细节见3.3节
    }
};

3.3 关键实现代码

cpp复制SortParts extractSortParts(const QString &str) const {
    SortParts parts;
    QRegularExpression re("^(?:(\d+)|([a-zA-Z]+)|([\u4e00-\u9fa5]+))");
    
    int pos = 0;
    while (pos < str.length()) {
        auto match = re.match(str, pos);
        if (!match.hasMatch()) {
            pos++;
            continue;
        }
        
        if (match.capturedLength(1) > 0) {  // 数字部分
            parts.number = match.captured(1).toInt();
        } 
        else if (match.capturedLength(2) > 0) {  // 字母部分
            parts.letters = match.captured(2);
        }
        else if (match.capturedLength(3) > 0) {  // 汉字部分
            parts.chinese = match.captured(3);
        }
        
        pos += match.capturedLength();
    }
    
    return parts;
}

4. 性能优化与边界处理

4.1 正则表达式预编译

频繁创建QRegularExpression对象会有性能开销，应该预编译：

cpp复制class Sorter {
public:
    Sorter() {
        numberRe.setPattern("(\d+)");
        letterRe.setPattern("([a-zA-Z]+)");
        chineseRe.setPattern("([\u4e00-\u9fa5]+)");
    }
    
private:
    QRegularExpression numberRe;
    QRegularExpression letterRe;
    QRegularExpression chineseRe;
};

4.2 特殊字符处理

实际字符串可能包含标点符号、空格等非排序要素字符，需要调整正则表达式：

cpp复制// 匹配数字、字母、汉字以外的字符作为分隔符
QRegularExpression separatorRe("[^\d\w\u4e00-\u9fa5]");

4.3 大小写敏感处理

如果需要不区分大小写的字母排序：

cpp复制letterRe.setPatternOptions(QRegularExpression::CaseInsensitiveOption);

5. 完整实现示例

cpp复制#include <QRegularExpression>
#include <QString>
#include <algorithm>
#include <vector>

class AdvancedStringSorter {
public:
    AdvancedStringSorter() {
        mainRe.setPattern("(?:(\d+)|([a-zA-Z]+)|([\u4e00-\u9fa5]+))");
    }

    void sort(QStringList &strings) {
        std::sort(strings.begin(), strings.end(), [this](const QString &a, const QString &b) {
            return compareStrings(a, b);
        });
    }

private:
    struct StringParts {
        std::vector<int> numbers;
        std::vector<QString> letters;
        std::vector<QString> chinese;
    };

    bool compareStrings(const QString &a, const QString &b) const {
        auto partsA = extractParts(a);
        auto partsB = extractParts(b);

        // 比较数字部分
        for (size_t i = 0; i < std::min(partsA.numbers.size(), partsB.numbers.size()); ++i) {
            if (partsA.numbers[i] != partsB.numbers[i]) {
                return partsA.numbers[i] < partsB.numbers[i];
            }
        }

        // 比较字母部分
        for (size_t i = 0; i < std::min(partsA.letters.size(), partsB.letters.size()); ++i) {
            if (partsA.letters[i] != partsB.letters[i]) {
                return partsA.letters[i] < partsB.letters[i];
            }
        }

        // 比较汉字部分
        for (size_t i = 0; i < std::min(partsA.chinese.size(), partsB.chinese.size()); ++i) {
            if (partsA.chinese[i] != partsB.chinese[i]) {
                return partsA.chinese[i] < partsB.chinese[i];
            }
        }

        // 所有可比较部分都相同，按原始字符串长度排序
        return a.length() < b.length();
    }

    StringParts extractParts(const QString &str) const {
        StringParts parts;
        int pos = 0;

        while (pos < str.length()) {
            auto match = mainRe.match(str, pos);
            if (!match.hasMatch()) {
                pos++;
                continue;
            }

            if (match.capturedLength(1) > 0) {
                parts.numbers.push_back(match.captured(1).toInt());
            } else if (match.capturedLength(2) > 0) {
                parts.letters.push_back(match.captured(2));
            } else if (match.capturedLength(3) > 0) {
                parts.chinese.push_back(match.captured(3));
            }

            pos += match.capturedLength();
        }

        return parts;
    }

    QRegularExpression mainRe;
};

6. 实际应用案例

6.1 文件管理器排序

cpp复制QStringList fileNames = {
    "1报告", "10总结", "2计划", "A项目", "B方案", "测试文档"
};

AdvancedStringSorter sorter;
sorter.sort(fileNames);

// 结果将是: ["1报告", "2计划", "10总结", "A项目", "B方案", "测试文档"]

6.2 数据库记录排序

cpp复制QList<Record> records = database.queryAllRecords();
std::sort(records.begin(), records.end(), 
    [&sorter](const Record &a, const Record &b) {
        return sorter.compareStrings(a.name(), b.name());
    });

7. 性能对比测试

我们对三种实现方式进行了性能测试（排序1000个混合字符串）：

测试结果表明：

1. 正则表达式确实带来额外开销
2. 通过预编译和优化，可以显著降低性能损耗
3. 对于大多数应用场景，38ms的性能完全可以接受

8. 常见问题与解决方案

8.1 数字前导零处理

问题：如何让"001"排在"01"前面？

解决方案：修改数字提取逻辑，保留原始字符串形式：

cpp复制if (match.capturedLength(1) > 0) {
    parts.numbers.push_back(match.captured(1));  // 存储为QString
    parts.hasLeadingZero = match.captured(1).startsWith('0');
}

然后在比较时特殊处理前导零情况。

8.2 混合内容排序

问题：如何处理像"测试1A"这样的混合内容？

解决方案：改进正则表达式，支持更复杂的模式匹配：

cpp复制QRegularExpression re("(\d+)|([a-zA-Z]+)|([\u4e00-\u9fa5]+)");

然后按出现顺序比较各部分。

8.3 性能瓶颈

问题：处理大量数据时速度变慢？

优化建议：

1. 预编译所有正则表达式
2. 缓存提取结果（如果字符串重复出现）
3. 使用多线程分段处理

cpp复制// 并行排序示例
QFuture<void> future = QtConcurrent::run([&](){
    std::sort(strings.begin(), strings.end(), comparer);
});
future.waitForFinished();

9. 扩展应用场景

9.1 表格数据排序

cpp复制void TableModel::sort(int column, Qt::SortOrder order) {
    if (column == NAME_COLUMN) {
        AdvancedStringSorter sorter;
        sorter.sort(m_data);
    } else {
        // 其他列使用默认排序
    }
    emit layoutChanged();
}

9.2 文件系统浏览器

cpp复制QDir dir(path);
QStringList files = dir.entryList(QDir::Files);
AdvancedStringSorter sorter;
sorter.sort(files);

9.3 日志文件分析

cpp复制// 对日志条目按时间+类型排序
QRegularExpression logRe("\[(\d+)\]\s+(\w+):(.+)");
AdvancedStringSorter sorter;
sorter.setCustomPattern(logRe);
sorter.sort(logEntries);

10. 替代方案比较

当不需要Qt环境时，可以考虑以下替代方案：

对于大多数Qt项目，QRegularExpression仍然是最平衡的选择。