移动数组中的元素 C++

Question

我为我的堆栈对象类开发了一种称为“旋转”的方法。我所做的是，如果堆栈包含元素：{0,2,3,4,5,6,7}，我需要前后旋转元素。

如果我需要向前旋转 2 个元素，那么我们将在数组中有 {3,4,5,6,7,0,2}。如果我需要向后旋转或 -3 个元素，那么，查看原始数组将是 {5,6,7,0,2,3,4}

所以我开发的方法工作正常。它只是非常低效的IMO。我想知道是否可以使用 mod 运算符来包装数组？或者如果它们是我还没有意识到的无用代码，等等。

我想我的问题是，我怎样才能简化这个方法？例如使用更少的代码。 :-)

void stack::rotate(int r)
{
    int i = 0;
    while ( r > 0 ) // rotate postively.
    {
        front.n = items[top+1].n;
        for ( int j = 0; j < bottom; j++ )
        {
            items[j] = items[j+1];                                  
        }
        items[count-1].n = front.n;
        r--;
    }

    while ( r < 0 )  // rotate negatively.
    {
        if ( i == top+1 )
        {
            front.n = items[top+1].n;  
            items[top+1].n = items[count-1].n; // switch last with first
        }

        back.n = items[++i].n; // second element is the new back
        items[i].n = front.n; 
        if ( i == bottom )
        {
            items[count-1].n = front.n; // last is first
            i = 0;  
            r++;   
            continue;
        }
        else
        {
            front.n = items[++i].n;
            items[i].n  = back.n;
            if ( i == bottom )
            {
                i = 0;
                r++; 
                continue;
            }
        }
    }
}

Answer 1

您可以更改“开始”的定义，而不是移动堆栈中的所有项目。有一个表示堆栈中第一项的索引，开始时为 0，当您想要旋转堆栈时，您可以使用模运算对其进行加减运算。

请注意，如果您采用这种方法，则不应让您的类的用户访问底层数组（不是您真的无论如何都应该...）。

Answer 2

好吧，由于这是对数组的抽象，您可以将“零”索引存储为抽象的成员，并根据第一个元素的这个抽象概念对数组进行索引。大概……

class WrappedArray
{
  int length;
  int first;
  T *array;

  T get(int index)
  {
    return array[(first + index) % length];
  }

  int rotateForwards()
  {
    first++;
    if (first == length)
      first = 0;
  }
}

Answer 3

你已经得到了几个合理的答案，但也许再有一个不会有什么坏处。我的第一反应是让你的堆栈成为一个 std::deque 的包装器，在这种情况下，将一个元素从一端移动到另一端很便宜 (O(1))。

Answer 4

您在此处所追求的是一个循环列表。
如果您坚持将项目存储在数组中，只需使用顶部偏移量和大小进行访问。这种方法使得在达到分配大小后插入元素变得昂贵（重新分配、复制）。这可以通过使用双向链表（ala std::list）和迭代器来解决，但是对堆栈的任意访问将是 O(n)。

Answer 5

下面的函数rotate是基于提醒的（你的意思是在'mod'操作下吗？）

效率也很高。

// Helper function.
// Finds GCD. 
// See http://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations
int gcd(int a, int b) {return b == 0 ? a : gcd(b, a % b);}

// Number of assignments of elements in algo is
// equal to (items.size() + gcd(items.size(),r)).
void rotate(std::vector<int>& items, int r) {
  int size = (int)items.size();
  if (size <= 1) return; // nothing to do
  r = (r % size + size) % size; // fits r into [0..size)
  int num_cycles = gcd(size, r);
  for (int first_index = 0; first_index < num_cycles; ++first_index) {
    int mem = items[first_index]; // assignment of items elements
    int index = (first_index + r) % size, index_prev = first_index;
    while (index != first_index) {
      items[index_prev] = items[index]; // assignment of items elements
      index_prev = index;
      index = (index + r) % size;
    };
    items[index_prev] = mem; // assignment of items elements
  }
}

当然，如果您可以按照其他答案中的描述更改数据结构，您可以获得更有效的解决方案。

Answer 6

现在，通常的“它已经在 Boost 中”回答：有一个 Boost.CircularBuffer

Answer 7

如果出于某种原因您希望对数组元素执行实际的物理旋转，您可能会在 Jon Bentley 的“Programming Pearls”中找到几个替代解决方案（第 2 列，2.3 原始的力量 ）。实际上，网络搜索Rotating Algorithms 'Programming Pearls' 会告诉你一切。您现在使用的文字方法几乎没有实际价值。

如果您想尝试自己解决问题，尝试以不同的方式看待问题可能会有所帮助。您会看到，“旋转数组”实际上与“交换数组的两个不相等部分”是一回事。用后者的术语思考这个问题可能会导致您找到新的解决方案:)

例如，

• 反转方法。反转整个数组中元素的顺序。然后将两个部分独立反转。你完成了。

例如，假设我们要将abcdefg 向右旋转 2

abcdefg -> 反转整体 -> gfedcba -> 反转两部分 -> fgabcde

附： Slides 用于“编程珍珠”的那一章。请注意，在 Bentley 的实验中，上述算法被证明是非常有效的（在三个测试中）。

Answer 8

我不明白变量 front 和 back 是什么意思，以及为什么需要 .n。无论如何，这是我所知道的用于旋转数组元素的最短代码，也可以在 Bentley 的书中找到。

#include <algorithm>

std::reverse(array    , array + r   );
std::reverse(array + r, array + size);
std::reverse(array    , array + size);