找出后缀数组的两种算法中哪一种更快，为啥？

Posted 2023-02-22

【中文标题】找出后缀数组的两种算法中哪一种更快，为啥？

【英文标题】：Which of the two algorithms for finding out the suffix array is faster and why?找出后缀数组的两种算法中哪一种更快，为什么？

【发布时间】：2015-07-24 13:49:21

【问题描述】：

我是算法复杂性的新手，因此无法弄清楚以下两种算法的复杂性。两者都找出给定字符串的后缀数组。第一个是我自己创建的，第二个是我在网上找到的。我想知道哪一个更快，为什么？

第一个算法

#include<iostream>
#include<string>
using namespace std;
struct suffix
    string str;
    int pos;
;
int main()

    string input;
    suffix arr[100];
    getline(cin,input,'\n');
    for(int i=0;i<input.length();i++)
    
        for(int j=i;j<input.length();j++)
        
            arr[i].str+=input[j];
        
            arr[i].pos=i;

        for(int j=0;j<i;j++)
        
            if(arr[i].str.compare(arr[j].str)<0)    
            
                string temp=arr[i].str;
                arr[i].str=arr[j].str;
                arr[j].str=temp;
                int tem=arr[i].pos;
                arr[i].pos=arr[j].pos;
                arr[j].pos=tem;
                break;
            

        
    
    for(int i=0;i<input.length();i++)
        cout<<arr[i].pos<<",";
    return 0;
 

第二种算法

#include bits/stdc++.h  
using namespace std;

// suffixRank is table hold the rank of each string on each iteration  
// suffixRank[i][j] denotes rank of jth suffix at ith iteration  

int suffixRank[20][int(1E6)];

// Example "abaab"  
// Suffix Array for this (2, 3, 0, 4, 1)  
// Create a tuple to store rank for each suffix  

struct myTuple   
    int originalIndex;   // stores original index of suffix  
    int firstHalf;       // store rank for first half of suffix  
    int secondHalf;      // store rank for second half of suffix  
;


// function to compare two suffix in O(1)  
// first it checks whether first half chars of 'a' are equal to first half chars of b  
// if they compare second half  
// else compare decide on rank of first half  

int cmp(myTuple a, myTuple b)   
    if(a.firstHalf == b.firstHalf) return a.secondHalf < b.secondHalf;  
    else return a.firstHalf < b.firstHalf;  


int main() 

    // Take input string
    // initialize size of string as N

    string s; cin >> s;
    int N = s.size();

    // Initialize suffix ranking on the basis of only single character
    // for single character ranks will be 'a' = 0, 'b' = 1, 'c' = 2 ... 'z' = 25

    for(int i = 0; i < N; ++i)
        suffixRank[0][i] = s[i] - 'a';

    // Create a tuple array for each suffix

    myTuple L[N];

    // Iterate log(n) times i.e. till when all the suffixes are sorted
    // 'stp' keeps the track of number of iteration
    // 'cnt' store length of suffix which is going to be compared

    // On each iteration we initialize tuple for each suffix array
    // with values computed from previous iteration

    for(int cnt = 1, stp = 1; cnt < N; cnt *= 2, ++stp) 

        for(int i = 0; i < N; ++i) 
            L[i].firstHalf = suffixRank[stp - 1][i];
            L[i].secondHalf = i + cnt < N ? suffixRank[stp - 1][i + cnt] : -1;
            L[i].originalIndex = i;
        

        // On the basis of tuples obtained sort the tuple array

        sort(L, L + N, cmp);

        // Initialize rank for rank 0 suffix after sorting to its original index
        // in suffixRank array

        suffixRank[stp][L[0].originalIndex] = 0;

        for(int i = 1, currRank = 0; i < N; ++i) 

            // compare ith ranked suffix ( after sorting ) to (i - 1)th ranked suffix
            // if they are equal till now assign same rank to ith as that of (i - 1)th
            // else rank for ith will be currRank ( i.e. rank of (i - 1)th ) plus 1, i.e ( currRank + 1 )

            if(L[i - 1].firstHalf != L[i].firstHalf || L[i - 1].secondHalf != L[i].secondHalf)
                ++currRank;

            suffixRank[stp][L[i].originalIndex] = currRank;
        

    

    // Print suffix array

    for(int i = 0; i < N; ++i) cout << L[i].originalIndex << endl;

    return 0;
 

【问题讨论】：

两个都运行看看？

两者都在打印相同的答案。如何判断哪一个更快？

你用足够大的输入运行它们并测量它们需要多长时间才能完成。时间越短越快。

给他们计时？这是您可以用来计时代码的std::chrono 库。您还可以运行像 Valgrind

这样的分析器

@NathanOliver Valgrind 可以介绍吗？我不知道。

【参考方案1】：

要确定对于给定的N，哪个运行得更快，您需要同时运行它们并查看。不过，为了确定哪一个会更好地扩展，您可以简单地查看您的循环。

在您的第一个算法中，您有嵌套循环，它们都从 0 到 input.size()，增量为 1，即 O(N^2)（如果 input.size() 为 1，则两个循环运行一次，总共运行一次运行，如果input.size()为2，则外循环运行两次，内循环运行两次，每次外循环运行一共4次迭代，以此类推）。

不过，第二种算法有一个从0 到N 的外部循环，并在每次迭代时乘以2。这增长为log(N) 而不是N。因此，它是O(N*log(N))，小于O(N^2)，并且可能会更好地扩展。