Lua中BWT的快速实现 本地函数fShallowCopy（tData） 本地tOutput={} 对于ipairs（tData）中的k，v，do tOutput[k]=v 结束 回程票 结束 本地功能fLexTblSort（tA，tB）--表格分拣机 对于i=1，#tA do 如果tA[i]~=tB[i]，那么 返回tA[i]

如果我看对了，那么如果排序是快速排序，则您的算法具有复杂性

O（n^2 log n）

。比较器函数

fLexTblSort

为比较的每对值取

O（n）

自身

当我检查几年前的实现时，我看到了可能的改进空间。您可以创建

tData

的所有可能的旋转，这也需要很多时间。我只使用单个数据块，并且只存储特定旋转的起始位置。您还使用了许多可以收缩为更小的循环

Mine的实现是用C实现的，但是这个概念也可以用在Lua中。这是Lua和C之间的一些混合伪代码中的想法

local function fShallowCopy(tData)
    local tOutput = {}
    for k,v in ipairs(tData) do
        tOutput[k] = v
    end
    return tOutput
end

local function fLexTblSort(tA,tB) --sorter for tables
    for i=1,#tA do 
        if tA[i]~=tB[i] then 
            return tA[i]<tB[i]
        end
    end 
    return false 
end

function fBWT(tData)

    --setup--
    local iSize = #tData
    local tSolution = {}
    local tSolved = {}


    --key table--
    for n=1,iSize do 
        tData[iSize] = fRemove(tData,1)
        tSolution[n] = fShallowCopy(tData)
    end
    table.sort(tSolution,fLexTblSort)


    --encode output--
    for i=1,iSize do
        tSolved[i] = tSolution[i][iSize]
    end


    --finalize--
    for i=1,iSize do
        if fIsEqual(tSolution[i],tData) then
            return i,tSolved
        end
    end
    return false
end

函数fBWT（tData）
本地n=#tData
局部tSolution={}
对于（i=0；i

您还需要自己的排序函数，因为标准没有提供足够的灵活性。快速排序是一个好主意（您可能会避免一些参数，但我只粘贴了我使用的C版本）：

void交换（int数组[]，int左，int右）{
int tmp=数组[右]；
数组[右]=数组[左]；
数组[左]=tmp；
}
void快速排序（uint8_t data[]，int length，int array[]，int left，int right）{
如果（左<右）{
int边界=左；
对于（inti=left+1；i

最后一步是您自己的比较器函数（与原始函数类似，但仍在处理旋转，同样在C中）：

/**
*比较具有不同旋转的一个字符串（固定长度）。
*/
int offset_compare（uint8_t*数据、int长度、int*数组、int first、int second）{
国际关系；
for（int i=0；i

---

这是我几年前提出的基本想法，对我来说很有用。如果有什么不清楚或错误，请告诉我。

虽然这是一个非常出色的解决方案，但遗憾的是，它似乎无法解决问题。您的快速排序和比较函数的运行时间与我的旧函数相同。还是谢谢你的帮助！我想它也不能移植到Lua，是的。Lua比C慢一点。如果您想提高性能，可以尝试在C中实现压缩并将函数导出到Lua。它可能会更快。也取决于您的Lua实现，如果它确实一遍又一遍地复制表，或者使用单一引用作为C版本。不幸的是，在这个项目中不允许使用其他语言。我可能只需要将BWT编码从我的压缩中去掉，并在压缩过程中遭受较小的损失

function fBWT(tData)

  local n = #tData
  local tSolution = {}
  for(i = 0; i < n; i++)
    tSolution[i] = i;

  --table.sort(tSolution, fLexTblSort)
  quicksort(tData, n, tSolution, 0, n)

  for(i = 0; i < n; i++){
    tSolved[i] = tData[(tSolution[i]+n-1)%n];
    if( tSolution[i] == 0 )
        I = i;
  }

  return I, tSolved
end

void swap(int array[], int left, int right){
    int tmp = array[right]; 
    array[right] = array[left];
    array[left] = tmp;         
}

void quicksort(uint8_t data[], int length, int array[], int left, int right){
    if(left < right){ 
        int boundary = left;
        for(int i = left + 1; i < right; i++){ 
            if( offset_compare(data, length, array, i, left) < 0 ){
                swap(array, i, ++boundary);
            }
        }
        swap(array, left, boundary);
        quicksort(data, length, array, left, boundary);
        quicksort(data, length, array, boundary + 1, right);
    }     
}

/**
 *  compare one string (fixed length) with different rotations.
 */
int offset_compare(uint8_t *data, int length, int *array, int first, int second){
    int res;
    for(int i = 0; i < length; i++){
        res = data[(array[first]+i)%length] - data[(array[second]+i)%length];
        if( res != 0 ){
            return res;
        }
    }
    return 0;
}