Swapping Columns/Rows of 1-Dimensional Arrays in C

Question

Trying to create two functions (one to swap columns and one to swap rows) of matrices in one-dimensional arrays. Obviously, they'd be structurally similar.

void col_swap(int a[], int col1, int col2, int colSize, int rowSize) {
  int d[size];
  int space = col2 - col1;
  for (int i = 0; i < rowSize; i++) {
    for (int j = 0; j < colSize; j++) {
      if (i == (col1 - 1) || i == (j * (col1-1))) {
        d[i+space] = a[i];
      } else if (i == (col2 - 1) || i == (j * (col2-1))) {
        d[i-space] = a[i];
      } else {
        d[i] = a[i];
      }
    }
    printf("%d  ", d[i]);
      if ((i+1) % colSize == 0) {
          printf("\n");
      }
  }
}

Yes, the matrix must be in a one-dimensional array. This doesn't work fully either.

EDIT: COL1 and COL2 are not "the first column of matrix" and "the second column of matrix", respectively. They are any two columns of a matrix that we want to switch.

void row_swap(int a[], int row1, int row2, int rowSize, int colSize) {
  for (int i = 0; i < colSize; i++) {
    int temp = a[i*rowSize+row1];
    a[i*rowSize+row1] = a[i*rowSize+row2];
    a[i*rowSize+row2] = temp;
  }
  for (int i = 0; i < size; i++) {
    if (i % colSize == 0) {
      printf("\n");
    }
    printf("%d ", a[i]);
  }
}

I have the row_swap function as above but when I give it a matrix

1, 4,
2, 3,
3, 2,
4, 1

It returns

1, 3
2, 4
3, 1
4, 2

Answer 1

This is much easier than you think it would be.

So you want to swap col1 and col2 and here the matrix has rowsize number of rows and colsize number of columns.

void col_swap(int a[], int col1, int col2, int colSize, int rowSize) {
  for(int i=0;i<rowSize;i++){
    int t=a[i*colSize+col1];
    a[i*colSize+col1]=a[i*colSize+col2];
    a[i*colSize+col2]=t; 
  }
}

Just think what is different here. We have just calculate the logic clearly for the position. Then everything is same as standard swapping.

More struturally you can do this:-

void swap(int *a,int*b)
{
    int t=*a;
    *a=*b;
    *b=t;
}
void col_swap(int a[], int col1, int col2, int colSize, int rowSize) {
  for(int i=0;i<rowSize;i++){
    swap(&a[i*colSize+col1],&a[i*colSize+col2]); 
  }
}

The rowswapping would be same. It is similar to column swapping if you consider row as columns and vice versa.

Secondly, why do you want to complicate things by making using a 2d array out of a 1d array?

This is hard to use in production level code or more specifically softwares. Why not use the 2d array itself? You should use that instead of doing this.

---

What was the approach?

After reading the question, I just used paper to get an idea of what is that I want to do and how it maps from 2d array to 1d array. That helps alot of time. And then first coded the first solution. I could see that I can reuse the swapping part in case of Row swapping too. So I take it out and put it in a different function swap.

Sample input output example:

int a[]={1,2,3,4,5,6,7,8,9,10,11,12};
    col_swap(a,1,2,3,4);

// 1 2 3 
// 4 5 6 
// 7 8 9 
// 10 11 12

// 1 3 2 
// 4 6 5 
// 7 9 8 
// 10 12 11

Again if you consider:

col_swap(a,0,2,3,4); on the same array results in

// 3 2 1
// 6 5 4
// 9 8 7
// 12 11 10

I have used 0-indexing in the code. So be careful when you give input columns.

Also the other function would be:-

void row_swap(int a[], int row1, int row2, int colSize, int rowSize) {
  for(int i=0;i<colSize;i++){
    swap(&a[colSize*row1+i],&a[row2*colSize+i]); 
  }
}

Answer 2

If you are using C99, then pointers to Variable Length Arrays can make the indexing much easier:

void col_swap(int a[], int col1, int col2, int colSize, int rowSize)
{
    // Cast 'a' to a pointer to a variable length array of size 'colSize'
    int (*a2d_matrix)[colSize] = (int (*)[colSize])a;

    // Now we can index into a (through a2d_matrix) as if it really is
    // a 2 dimensional matrix
    for(int r = 0; r < rowSize; r++)
    {
        int temp = a2d_matrix[r][col1];
        a2d_matrix[r][col1] = a2d_matrix[r][col2];
        a2d_matrix[r][col2] = temp; 
    }
}

I use this method often. Note that this probably works in C11 and greater, however Variable Length Arrays were made optional in the C11 standard. So check your compiler support of optional C11 features. All major vendors support VLAs in C11 as far as I know.