C 中有数组的“位移”操作吗？

编程问答 2022-09-07

问题描述

在 C 中，我们可以使用左移将数字的二进制表示的每个数字向左移动一个空格，这被认为是 O(1) 时间。例如，0010 << 1 = 0100

C 中是否有类似的函数/操作可以在 O(1) 时间内对数组执行此操作？例如，[1,2,3,4,5] 移动一个空格得到 [2,5,0]。

我想到的一种方法是像这样使用 memcpy()：

int arr1[] = {1,5};
memcpy(arr1,arr1+1,4*sizeof(int));

for(int i=0 ; i<5 ; i++)
{
        printf("%d ",arr1[i]);
}

输出：2、3、4、5、5

唯一的问题是，我猜 memcpy() 不完全是 O(1)。我希望这可能是 C 中的一些低级函数/方法，可以快速操作内存来实现这一点，但到目前为止我在谷歌搜索时找不到任何东西。

编辑： 在搜索中，我发现位移位使用 special circuit 可能允许移位操作比 memcpy 之类的操作快得多。这引出了我的问题，是否有办法将数组表示为位串并对该位串执行传统位移？

编辑 2：我知道我想要实现的目标无法在 O(1) 时间内完成。我会对任何建议我如何提高移动数组的速度的答案感到满意，以便它看起来有点像 O(1) 操作（即使它实际上不是）。

解决方法

C 中是否有类似的函数/操作可以在 O(1) 时间内对数组执行此操作？例如，[1,2,3,4,5] 移动一个空格得到 [2,5,0]。

没有。但是您可以通过仅存储偏移量并使用模访问来产生相同的结果

struct array {
  int offset;
  int size;
  int elems[];
};

struct array* alloc_array(int size)
{
  struct array *a = malloc(sizeof(struct array) + sizeof(int)*size);
  a->offset = 0;
  a->size = size;
  return a;
}

/* Constant-time shift!
   Just use shiftleft with a negative distance to shift right */
void shiftleft(struct array *a,int distance)
{
  a->offset += distance;
}

/* Note we actually made each of our N element accesses slightly more expensive.
   However,that was already linear (ie,when you print all elements)
   so we still have the desired asymptotic complexity.
*/
int elem(struct array *a,int idx)
{
  return a->elems[(idx + a->offset) % a->size];
}

注意。这是完全未经测试的，它只是一个草图，所以你明白了。另外，我假设您实际上想要一个 element 转变，因为这就是您所展示的。如果你想将一个数组向左移动 N bits，那就有点复杂了。

我发现位移位使用了一个特殊的电路

附注。这个“特殊电路”是 CPU 的内置操作之一，它在固定大小的寄存器上以恒定时间运行。寄存器大小已融入 CPU 硬件。选择 C ​​int 的大小以匹配 CPU 寄存器大小。

没有办法对 N 个寄存器大小的整数（例如）执行不花费 N 倍时间的常数时间（每个寄存器）操作，因此显然它具有线性复杂度。

我知道我想要实现的目标无法在 O(1) 时间内完成。

嗯，渐近复杂性仅在元素数量变化时才相关。如果您总是对固定大小的数组进行操作，那么即使是与元素数量成线性关系的操作也是每个数组的常数时间。

  • 编辑 - 请不要再说了

    整数中的位移被认为是 O(1) 时间，因为它们非常快，即使它们实际上不是 O(1)

    1. 我说它是恒定时间，因为它是，假设现代 ALU 带有 barrel shifter

    2. 如果它不是恒定时间，则没有“如此快”的价值会促使我称其为恒定时间除非它总是占用相同数量的时钟实践中的循环（包括互惠吞吐量）。由于没有实用的方法来衡量它在单个时钟周期内何时完成，因此这是一个没有实际区别的区别。

    同样，速度和渐近复杂度是正交的。对于 O(N) 运算来说，没有足够小的系数被视为 O(1)。当然有一个足够小的 N 值，我在下面提到过（但你拒绝在你的问题中绑定 N）。

如果您总是对可变但有界大小的数组进行操作，您可以做出同样的声明，尽管如果您的有效数组大小涵盖多个数量级，则不会很有说服力。

我会对任何建议我如何提高移动数组速度的答案感到满意，以便它看起来有点像 O(1) 操作（即使它实际上不是）。

这完全没有意义。渐近复杂度不是速度的衡量标准，优化速度对渐近复杂度没有影响。

,

正如评论中所说，您应该使用 memmove 而不是 memcpy 作为源和目标重叠。

您的代码中的另一个问题是您假设在您可以自由使用的初始化数组之后会有一个“0”。

memmove 和 memcpy 可能需要 O(n) 时间，这样的代码会更快：

int arr1[] = {1,0};
int *arr2 = &arr1[1];

for(int i=0 ; i<5 ; i++)
{
        printf("%d ",arr2[i]);
}
,

廉价的方法是不移动大量内存，而只是操作索引。

#include <stdio.h>

int main(void)
{
int arr1[] = {1,5};
int ii,jj;

for(ii=0 ; ii<5 ; ii++)
        {
        jj = (ii<4) ? ii+1 : ii;

        printf("%d ",arr1[jj] );
        }

printf("\n" );
return 0;
}
arraysarraysarraysbitbitbit-shiftc