Question

I am trying to implement left array rotation using the method described here: http://www.cs.bell-labs.com/cm/cs/pearls/s02b.pdf (under section Reversal algorithm)

I am having trouble reversing the array when the start index isn’t 0.

Here is what I have so far:

void reverse_arr(int *a, int start, int end)
{
    int i;
    int len = end - start;
    //printf("Len pre loop: %d\n", len);
    int swap;

    for(i = start; i < --len; i++)
    {
        //printf("start: %d\tlen: %d\n", start, len);
        swap   = a[i];
        a[i]   = a[len];
        a[len] = swap;
    }
}

This works great when the start index is 0, but when it is anything else it never reverses all of the elements.

ex:

int test[] = {1,2,3,4,5,6};
reverse_arr(test, 0, 2); //reverse the first 2 elements of the array

results in: {2,1,3,4,5,6} which is expected

int test[] = {1,2,3,4,5,6}; 
reverse_arr(test, 2, 6); //reverse the last 4 elements of the array

results in: {2,1,4,3,5,6} which is not expected, only the 3 and 4 were reversed.

Any help would be appreciated.

Answer 1

You need to adjust the other subscript in the swap:

void reverse_arr(int *a, int start, int end)
{
    int len = end - start;

    for (int i = start; i < --len; i++)
    {
        int swap = a[i];
        a[i]     = a[i+len];
        a[i+len] = swap;
    }
}

You could probably also use:

void reverse_arr(int *a, int start, int end)
{
    int len = end - start;

    end--;

    for (int i = start; i < --len; i++, end--)
    {
        int swap = a[i];
        a[i]     = a[end];
        a[end]   = swap;
    }
}

Working test code

#if defined(VERSION1)
static void reverse_arr(int *a, int start, int end)
{
    int i;
    int len = end - start;
    int swap;

    for (i = start; i < --len; i++)
    {
        swap     = a[i];
        a[i]     = a[i+len];
        a[i+len] = swap;
    }
}

#else

static void reverse_arr(int *a, int start, int end)
{
    int i;
    int len = end - start;

    end--;

    for (i = start; i < --len; i++, end--)
    {
        int swap   = a[i];
        a[i]   = a[end];
        a[end] = swap;
    }
}
#endif

#define DIM(x)  (sizeof(x)/sizeof(x[0]))

#include <stdio.h>

static void print_array(int *array, size_t size)
{
    for (size_t i = 0; i < size; i++)
        printf(" %d", array[i]);
    putchar('\n');
}


static void tester(int lo, int hi)
{
    int test[] = {1,2,3,4,5,6};
    printf("Before: (%d, %d)\n", lo, hi);
    print_array(test, DIM(test));
    reverse_arr(test, lo, hi); //reverse the first 2 elements of the array
    printf("After:  (%d, %d)\n", lo, hi);
    print_array(test, DIM(test));
    putchar('\n');
}

int main(void)
{
    tester(0, 2);
    tester(2, 6);
    return(0);
}

And the results from compiling with -DVERSION1 or not are the same:

Before: (0, 2)
 1 2 3 4 5 6
After:  (0, 2)
 2 1 3 4 5 6

Before: (2, 6)
 1 2 3 4 5 6
After:  (2, 6)
 1 2 6 4 5 3