对称迭代一个数组

Question

Wasn't exactly sure how to title this, but I hope it makes sense. I want to iterate an array forwards and then backwards, x number of times. One option is to double the size of the array and then iterate based on mod length, thus iterating in a circular fashion. Assuming an extremely large sequence, that could consume a lot of unnecessary memory. Another option is this:

while(++i <= iterations) {
    for(j = 0; j < arrayLength; j++){
        //do something
    }
    for(j = arrayLength - 1; j >= 0; j--){
        //do something
    }
}

That just feels ugly though - I'm sort of repeating myself, just switching the ++/--. I'm looking for an elegant coding approach to this. The language should be C or C++. Just to be very clear, I'm looking for a different algorithm. Thanks.

Answer 1

boost::adaptors::reverse could come handy here:

#include <boost/range/adaptors.hpp>

while (i++ < iterations) {
    for (auto i : array) /* do something */ ;
    for (auto i : boost::adaptors::reverse(array)) /* do something */ ;
}

In C++14, we'll also have std::rbegin and std::rend , sou you could write something like:

auto rb = std::rbegin(array);
auto re = std::rend(array);
while (rb != re) {
    // do something
    ++rb;
}

That is if you're working with plain arrays. Most of standard containers already come with rbegin() and rend() methods that give you reverse iterators.

Answer 2

Well, here's a different approach. Not going to claim it's necessarily better by any particular criteria, though.

int dir = 1;
int start = 0, end = arrayLength - 1;

while (++i <= (iterations << 1))
{  int j = start;

   do
   { // something
     j += dir;
   } while (j != end);

   dir = -dir;
   int tmp = start; start = end; end = tmp;
}

I actually think that's a bit convoluted, and a maintenance nightmare waiting to happen, but at least you're not "repeating yourself". And it might be "elegant" in the "clever" sense... Not so much in the "simple" sense.

Answer 3

This gives elegance at the cost of some efficiency:

while(++i <= iterations) {
    for(j = 0; j < twiceArrayLength; ++j) {
        k = min(j, arrayLengthMinusOne) - max(0, j - arrayLength);
        doSomething(k);
    }
}

Example: When arrayLength is 5 , then j will run from 0 to 9 , and the corresponding value of k will run from 0 up to 4 and then from 4 down to 0 .

EDIT: As per your request, to start at a different point in the array, you can do this:

while(++i <= iterations) {
    endPoint = startPoint + twiceArrayLength;
    for(j = startPoint; j < endPoint; ++j) {
        jModTwiceArrayLength = j % twiceArrayLength;
        k = min(jModTwiceArrayLength, arrayLengthMinusOne) - max(0, jModTwiceArrayLength - arrayLength);
        doSomething(k);
    }
}

Answer 4

Perhaps slightly nicer?

j = -1;

while(++i <= iterations) {
    while(++j < arrayLength){
        //do something
    }
    while(--j >= 0){
        //do something
    }
}

Alternatively, can you operate on the elements in unison?

while(++i <= iterations) {
    for(j = 0; j < arrayLength; j++){
        //do something with array[j]
        //do something with array[arrayLength - j - 1]
    }
}

Answer 5

while(++i <= iterations)
{
   for(auto it = array.begin(); it!=array.end(); ++it)
   { //do something }

   for(auto it = array.rbegin(); it!=array.rend(); ++it)
   { //do something }

}