如何快速移动矩阵行内元素？无需将行元素存入数组的高效实现方法问询

我目前的操作逻辑是把矩阵的行元素收集到数组中，再对数组执行移动操作，但想知道不将行元素收集到数组的前提下，怎么常规且高效地实现矩阵行内元素的移动？以下是我当前的相关实现代码：

static void initRow(int[] array, Cannon[, ] cn, int i, int size) { 
  for (int j = 0; j < size; j++) { 
    cn[i, j].A = array[j]; 
  } 
}
static void ShiftLeftForK(int[] arr, int k) { 
  for (int i = 0; i < k; i++) { 
    ShiftLeft(arr); 
  } 
}
static void moveForB(Cannon[,] cn, int size) { 
  int[] temp = new int[size]; 
  for (int i = 1; i < size; i++) { 
    for (int j = 0; j < size; j++) { 
      temp[j] = cn[j, i].B; 
    } 
    ShiftLeftForK(temp, i); 
    initColumn(temp, cn, i, size); 
  } 
}

好问题！提取元素到临时数组确实会带来额外的空间开销，尤其是当矩阵规模很大的时候。我们可以用原地移位算法来解决这个问题，不需要额外的数组存储，时间复杂度保持O(n)，空间复杂度直接降到O(1)，同时代码也更简洁。

核心思路：原地移位的两种高效实现 #

针对行内元素左移k位的场景，最常用的两种原地实现方式如下：

方法一：三次反转法（推荐，通用高效） #

这是业界处理数组移位最常用的高效技巧，原理通过三次局部反转完成整体移位，完全不需要额外存储空间：

• 步骤1：反转行内前k个元素
• 步骤2：反转行内剩余的size-k个元素
• 步骤3：反转整个行的所有元素

针对你的Cannon矩阵，我们可以写出对应的原地行左移方法：

// 原地将矩阵第row行的A属性左移k位
static void ShiftRowLeftInPlace(Cannon[,] cn, int row, int size, int k)
{
    k = k % size; // 处理k大于矩阵尺寸的情况，避免无效移位
    if (k == 0) return; // 移位位数为0时直接返回

    // 反转前k个元素
    ReverseRowSegment(cn, row, 0, k - 1);
    // 反转剩余的size-k个元素
    ReverseRowSegment(cn, row, k, size - 1);
    // 反转整个行
    ReverseRowSegment(cn, row, 0, size - 1);
}

// 辅助方法：反转矩阵某一行的指定区间元素（操作A属性）
static void ReverseRowSegment(Cannon[,] cn, int row, int startIdx, int endIdx)
{
    while (startIdx < endIdx)
    {
        // 交换两个位置的A属性值
        int temp = cn[row, startIdx].A;
        cn[row, startIdx].A = cn[row, endIdx].A;
        cn[row, endIdx].A = temp;
        
        startIdx++;
        endIdx--;
    }
}

方法二：循环移位法（适合k远小于size的场景） #

如果你的业务场景中，移位位数k总是远小于矩阵的尺寸size，循环移位法的实际执行效率可能更高。原理是每次左移一位，重复k次：

// 原地将矩阵第row行的A属性左移k位（循环移位版）
static void ShiftRowLeftInPlaceLoop(Cannon[,] cn, int row, int size, int k)
{
    k = k % size;
    if (k == 0) return;

    for (int shiftCount = 0; shiftCount < k; shiftCount++)
    {
        // 保存行首元素
        int firstElement = cn[row, 0].A;
        // 从左到右依次将元素左移一位
        for (int j = 0; j < size - 1; j++)
        {
            cn[row, j].A = cn[row, j + 1].A;
        }
        // 将行首元素放到行尾
        cn[row, size - 1].A = firstElement;
    }
}

针对你现有代码的优化（处理列移位场景） #

看你的moveForB方法实际是处理矩阵第i列的B属性左移i位，同样可以用原地反转法改造，完全去掉临时数组temp：

// 优化后的moveForB，无额外数组开销
static void moveForBInPlace(Cannon[,] cn, int size)
{
    for (int i = 1; i < size; i++)
    {
        // 原地将第i列的B属性左移i位
        ShiftColumnLeftInPlace(cn, i, size, i);
    }
}

// 原地将矩阵第col列的B属性左移k位
static void ShiftColumnLeftInPlace(Cannon[,] cn, int col, int size, int k)
{
    k = k % size;
    if (k == 0) return;

    ReverseColumnSegment(cn, col, 0, k - 1);
    ReverseColumnSegment(cn, col, k, size - 1);
    ReverseColumnSegment(cn, col, 0, size - 1);
}

// 辅助方法：反转矩阵某一列的指定区间元素（操作B属性）
static void ReverseColumnSegment(Cannon[,] cn, int col, int startIdx, int endIdx)
{
    while (startIdx < endIdx)
    {
        int temp = cn[startIdx, col].B;
        cn[startIdx, col].B = cn[endIdx, col].B;
        cn[endIdx, col].B = temp;
        
        startIdx++;
        endIdx--;
    }
}

为什么这样更高效？ #

• 空间优化：从原来的O(n)空间开销降到O(1)，完全不需要临时数组，尤其适合超大矩阵场景，节省内存资源。
• 时间效率：三次反转法的时间复杂度还是O(n)，和原来的方法一致，但避免了数组拷贝、初始化等额外操作，实际运行速度更快。
• 代码简洁：去掉了initRow、ShiftLeftForK这类依赖数组的辅助方法，逻辑更直接，维护成本更低。

内容的提问来源于stack exchange，提问作者QRUSH