Question

我在实现一个必须偶尔对齐的循环缓冲区时遇到了一个问题。

假设我有两个数组，leftArr和rightArr。我想将右侧数组移动到byteArr，将左侧数组移动到byteArr +右侧数组的长度。 leftArr和rightArr都大于byteArr，rightArr大于leftArr。（这与rotating a circular buffer不完全相同，因为左侧数组不需要从byteArr开始。虽然左侧和右侧阵列不重叠，但byteArr处存储的组合数组可能不一致与当前数组重叠，存储在leftArr和rightArr。从byteArr到rightArr + rightArrLen的所有内存都可以安全地写入。一种可能的实现方式是：

void align(char* byteArr, char* leftArr, int leftArrLen, char* rightArr, int rightArrLen) {
  char *t = malloc(rightArrLen + leftArrLen);

  // form concatenated data
  memcpy(t, right, rightArrLen);
  memcpy(t + rightArrLen, left, leftArrLen);

  // now replace
  memcpy(byteArr, t, rightArrLen + leftArrLen);
  free(t);
}

但是，我必须以持续的内存复杂性来实现这一点。

到目前为止我的样子是这样的：

void align(char* byteArr, char* leftArr, int leftArrLen, char* rightArr, int rightArrLen)
{
    // first I check to see if some combination of memmove and memcpy will suffice, if not:
    unsigned int lStart = leftArr - byteArr;
    unsigned int lEnd = lStart + leftArrLen;
    unsigned int rStart = rightArr - byteArr;
    unsigned int rEnd = rStart + rightArrLen;
    unsigned int lShift = rEnd - rStart - lStart;
    unsigned int rShift = -rStart;
    char temp1;
    char temp2;
    unsigned int nextIndex;
    bool alreadyMoved;

    // move the right array
    for( unsigned int i = 0; i < rEnd - rStart; i++ )
    {
        alreadyMoved = false;

        for( unsigned int j = i; j < rEnd - rStart; j-= rShift )
        {
            if(    lStart <= j + rStart - lShift
                && j + rStart - lShift < lEnd
                && lStart <= (j + rStart) % lShift
                && (j + rStart) % lShift < lEnd
                && (j + rStart) % lShift < i )
            {
                alreadyMoved = true;
            }
        }

        if(alreadyMoved)
        {
            // byte has already been moved
            continue;
        }

        nextIndex = i - rShift;
        temp1 = byteArr[nextIndex];
        while( rStart <= nextIndex && nextIndex < rEnd )
        {
            nextIndex += rShift;
            temp2 = byteArr[nextIndex];
            byteArr[nextIndex] = temp1;
            temp1 = temp2;
            while( lStart <= nextIndex && nextIndex < lEnd )
            {
                nextIndex += lShift;
                temp2 = byteArr[nextIndex];
                byteArr[nextIndex] = temp1;
                temp1 = temp2;
            }
            if( nextIndex <= i - rShift )
            {
                // byte has already been moved
                break;
            }
        }
    }

    // move the left array
    for( unsigned int i = lStart; i < lShift && i < lEnd; i++ )
    {
        if( i >= rEnd - rStart )
        {
            nextIndex = i + lShift;
            temp1 = byteArr[nextIndex];
            byteArr[nextIndex] = byteArr[i];
            while( nextIndex < lEnd )
            {
                nextIndex += lShift;
                temp2 = byteArr[nextIndex];
                byteArr[nextIndex] = temp1;
                temp1 = temp2;
            }
        }
    }
}

此代码适用于案例lStart = 0, lLength = 11, rStart = 26, rLength = 70，但在案例lStart = 0, lLength = 46, rStart = 47, rLength = 53中失败。我能看到的解决方案是添加逻辑以确定何时已经移动了右数组中的字节。虽然这对我来说是可能的，但我想知道是否有一个更简单的解决方案来解决这个问题，这个问题在内存复杂性不变且没有额外的读写操作的情况下运行？

这是一个测试实现的程序：

bool testAlign(int lStart, int lLength, int rStart, int rLength)
{
    char* byteArr = (char*) malloc(100 * sizeof(char));
    char* leftArr = byteArr + lStart;
    char* rightArr = byteArr + rStart;
    for(int i = 0; i < rLength; i++)
    {
        rightArr[i] = i;
    }
    for(int i = 0; i < lLength; i++)
    {
        leftArr[i] = i + rLength;
    }
    align(byteArr, leftArr, lLength, rightArr, rLength);
    for(int i = 0; i < lLength + rLength; i++)
    {
        if(byteArr[i] != i) return false;
    }
    return true;
}

Answer 1

想象一下将byteArr划分为区域（不一定按比例）：

 X1    Left   X2  Right
|---|--------|---|------|

X1和X2是在左数组开始之前和两个数组之间的byteArr中的间隙。在一般情况下，这四个区域中的任何一个或全部可能没有长度。

然后你可以这样继续：

首先部分或全部填写byteArr中的前导空格
- 如果Left的长度为零，则通过memmove()向右移动到前面（如有必要）。完成。
- 否则，如果X1与右侧阵列的长度相同或更大，则通过memcpy()将右侧阵列移动到该空间中，并可能向上移动左侧阵列以通过memmove()与其对齐。完成。
- 否则，将Right数组的前导部分移动到该空间中，产生以下布局。如果X1的长度为零，那么R1也有零长度，X2＆＃39; == X2，R2 ==右。

       R1    Left     X2'  R2
      |---|--------|------|---|

现在有两种选择
- 如果R2的长度与Left相同或更长，则将左侧与R2的初始部分交换以产生（仍未按比例）：

       R1'    X2''  Left    R2'
      |------|-----|-------|--|

否则，将Left的初始部分与所有R2交换以产生（仍然不按比例）：

       R1'    L2  X2''    L1
      |------|---|-------|----|

现在认识到，在任何一种情况下，你都有一个与原版相同形式的严格小问题，其中新byteArr是原始的尾部，在区域R1＆＃39;之后立即开始。在第一种情况下，新leftArr是（最终）左区域，新rightArr是区域R2＆＃39;。在另一种情况下，新的leftArr是区域L2，而新的rightArr是区域L1。重置参数以反映此新问题，并循环回到步骤（1）。

请注意，我说 loop 回到第1步。当然，您可以递归地实现此算法（tail-），但是为了实现恒定的空间使用，您需要依赖于编译器优化尾递归，否则消耗辅助空间与两个子阵列中较大的子阵列的长度比成比例。

将数组连接到位

1 个答案: