If you want to use your single array sorting algorithm (bubble sort) to sort the two dimensional array then you have to add the another for loop: An outer for loop which will take care of each row. Let's say m is number of row and n is number of column.

for(k=0; k< m; k++) {
   for (i = 0; i < n; i++) {
     for (j = i +1; j < n; ++j) {
       if (array2[k][i] > array2[k][j])  {
           int swap = array2[k][i];
           array2[k][i] = array2[k][j];
           array2[k][j] = swap;
       }
     }
   } 
}

But this is not an efficient approach to sort the array, it's time complexity will be O(mn^2)

Limited to stdio.h

If you are limited to using what is provided in stdio.h, then you simply have to write similar string handling functionality to what you would require from string.h. For sorting, unless you want to use a partitioning sort like quicksort or mergesort, you would be limited to a nested loop sort -- which are simpler to write -- but much much slower. (but for a 1000 or so strings, it doesn't matter, 100,000 - then there will be a perceivable difference)

To compare strings, you can write a simple strcmp() like function that requires no additional header, e.g.

/** string compare without string.h */
int strcmp_nohdr (const char *a, const char *b)
{
    if (!a && !b) return 0;
    if ( a && !b) return 1;
    if (!a &&  b) return -1;

    for (; *a && *a == *b; a++, b++) {}

    return (*a > *b) - (*a < *b);
}

If you are not declaring an additional set of pointers to sort, then you will need to copy strings between the rows (1D arrays) in your 2D array. You can write a simple strcpy() like function that needs no header as:

/** string copy wihout string.h */
char *strcpy_nohdr (char *dest, const char *src)
{
    char *p = dest;
    
    do {
        *p++ = *src;
    } while (*src++);
    
    return dest;
}

Finally, the only other thing you need is a sort function. (you will not be able to write a quick qsort() replacement) The meager Bubblesort will do. You can write a function to sort your 2D array of strings as:

#define NCHR 50

/** bubble sort of strings in 'a' (highly inefficient) */
void bubblesort2D (char (*a)[NCHR], size_t n)
{
    size_t i, j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < (n-1); j++) {
            if (strcmp_nohdr(a[j], a[j + 1]) > 0) {
                char temp[NCHR];
                strcpy_nohdr (temp, a[j + 1]);
                strcpy_nohdr  (a[j + 1], a[j]);
                strcpy_nohdr  (a[j], temp);
            }
        }
    }
}

If you put those altogether in a short example (the same used before with qsort(), you would have:

#include <stdio.h>

#define NCHR 50

/** string compare without string.h */
int strcmp_nohdr (const char *a, const char *b)
{
    if (!a && !b) return 0;
    if ( a && !b) return 1;
    if (!a &&  b) return -1;

    for (; *a && *a == *b; a++, b++) {}

    return (*a > *b) - (*a < *b);
}

/** string copy wihout string.h */
char *strcpy_nohdr (char *dest, const char *src)
{
    char *p = dest;
    
    do {
        *p++ = *src;
    } while (*src++);
    
    return dest;
}

/** bubble sort of strings in 'a' (highly inefficient) */
void bubblesort2D (char (*a)[NCHR], size_t n)
{
    size_t i, j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < (n-1); j++) {
            if (strcmp_nohdr(a[j], a[j + 1]) > 0) {
                char temp[NCHR];
                strcpy_nohdr (temp, a[j + 1]);
                strcpy_nohdr  (a[j + 1], a[j]);
                strcpy_nohdr  (a[j], temp);
            }
        }
    }
}

int main (void) {
    
    char strings[][NCHR] = { "zebra", "alligators", "frogs", "racoons", "opossums" };
    size_t n = sizeof strings / sizeof *strings;
    
    bubblesort2D (strings, n);
    
    for (size_t i = 0; i < n; i++)
        puts (strings[i]);
}

Example Use/Output

The results are the same as before:

$ ./bin/sort_2d_strings_stdio
alligators
frogs
opossums
racoons
zebra

Since I originally wrote the qsort() answer, I'll leave it below as the way you would want to handle sorting (whatever array you are sorting) in practice.

In Practice Use qsort()

C provides qsort() that will sort arrays of any object based on the compare function you write to tell qsort() how elements of the array are to be compares. With strings, you just want to return the result of strcmp(). Each argument to the compare function ia a Pointers to an element of your array. Since it is a void* pointer, you must cast the pointer back to the correct type.

Recall in C that a 2D array is simply an array of 1D arrays. In your case it is a array of 50-character arrays. A pointer to an array of 50-chars has the type char (*)[50], so your qsort() compare function can be written as follows:

int cmpstr50 (const void *a, const void *b)
{
    const char  *pa = *(char (*)[50])a,
                *pb = *(char (*)[50])b;
    
    return strcmp (pa, pb);
}

Where each of the parameters is a pointer to an array of char [50]. Nothing could be easier. Moreover the algorithm used by qsort() will be orders of magnitude faster than what you write with nested loops.

A complete example for your case would be:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int cmpstr50 (const void *a, const void *b)
{
    const char  *pa = *(char (*)[50])a,
                *pb = *(char (*)[50])b;
    
    return strcmp (pa, pb);
}

int main (void) {
    
    char strings[][50] = { "zebra", "alligators", "frogs", "racoons", "opossums" };
    size_t n = sizeof strings / sizeof *strings;
    
    qsort (strings, n, sizeof *strings, cmpstr50);
    
    for (size_t i = 0; i < n; i++)
        puts (strings[i]);
}

Where after writing your compare function, all it takes to sort the array of strings (or array of anything) is a single call to qsort():

    qsort (strings, n, sizeof *strings, cmpstr50);

Much simpler than trying to reinvent the wheel.

Example Use/Output

$ ./bin/qsort_2d_strings
alligators
frogs
opossums
racoons
zebra

Let me know if you have further questions.

Your code is clean except for the part that you use to exchange the two-element arrays. There are two ways to fix it:

• Use an alternative representation of the array - int *array[100] in which case you'll need to malloc and free individual elements, or
• Use memcpy to exchange two-element arrays in your swap code.
• With only two elements to swap, you can exchange two-element arrays one integer at a time without using memcpy

This is one way of doing it:

int temp[2];
memcpy(temp, list[i], sizeof(temp));
memcpy(list[i], list[j], sizeof(temp));
memcpy(list[j], temp, sizeof(temp));

Happily, there's qsort for that in the standard library. Really all you have to do is provide a comparison function for elements of the outer array. For example:

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

// lexicographical comparison.
// Returns -1 for lhs < rhs, 1 for lhs > rhs, 0 for lhs == rhs.
int compare_line(void const *p_lhs, void const *p_rhs) {
  // These point to the elements of the outer arrays (that is,
  // they point to the inner arrays)
  double const *lhs = (double const *) p_lhs;
  double const *rhs = (double const *) p_rhs;

  if(lhs[0] < rhs[0]) return -1;
  if(lhs[0] > rhs[0]) return  1;
  if(lhs[1] < rhs[1]) return -1;
  if(lhs[1] > rhs[1]) return  1;

  return 0;
}

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof*(arr))

int main(void) {
  double data[][2] = {
    { 105,  800 },
    { 105, 1300 },
    { 105, 2500 },
    { 110, 1200 },
    { 110, 1800 }
  };

  // Sorting here.
  qsort(data, ARRAY_SIZE(data), sizeof(data[0]), compare_line);

  for(size_t i = 0; i < ARRAY_SIZE(data); ++i) {
    printf("%lf %lf\n", data[i][0], data[i][1]);
  }
}

Try declaring the function as sort_double_array(double A[][2], int n);

Multidimensional array must have bounds for all dimensions except the first.

It looks like you are trying to sort the rows of the array in lexicographical order. If you treat the 2D array as an array of arrays, then you are just sorting the second-level arrays within the first-level array into ascending lexicographical order.

Depending on whether the number of columns in your array is fixed, you might be able to do this using the qsort function with a custom comparator. For example, if you know that there will always be exactly 3 elements in each column, you could write a comparator like this one:

static const size_t NUM_COLS = 3;

/* Lexicographically compare two arrays of size NUM_COLS. */
int CompareArrays(const void* arr1, const void* arr2) {
     /* Convert back to the proper type. */
     const int* one = (const int*) arr1;
     const int* two = (const int*) arr2;

     /* Do an element-by-element comparison.  If a mismatch is found, report how
      * the arrays compare against one another.
      */
     for (size_t i = 0; i < NUM_COLS; i++) {
         if (one[i] < two[i]) return -1;
         if (one[i] > two[i]) return +1;
     }

     /* If we get here, the arrays are equal to one another. */
     return 0;
}

/* Use qsort to sort the arrays */
qsort((const int*)&one, numRows, sizeof(int[NUM_COLS]), CompareArrays);

Hope this helps!

I'm offering this up only because it was one of the few things std::qsort does well that std::sort simply does not, namely sort multi-column fixed arrays: The comparator is a string of ternary statements, but should be clear enough if you stare at it long enough:

#include <iostream>
#include <random>
#include <algorithm>

int main()
{
    int ar[10][2];

    // populate with random data
    std::random_device rd;
    std::default_random_engine rng(rd());
    std::uniform_int_distribution<> dist(1,20);
    std::for_each(std::begin(ar), std::end(ar),
        &[2]){ ar[0] = dist(rng); ar[1] = dist(rng); });

    std::cout << "Before Sort..." << '\n';
    std::for_each(std::begin(ar), std::end(ar),
        [2]) { std::cout << ar[0] << ',' << ar[1] << '\n';});

    std::qsort(ar, 10, sizeof(*ar),
        ->int
        {
            int const *lhs = static_cast<int const*>(arg1);
            int const *rhs = static_cast<int const*>(arg2);
            return (lhs[0] < rhs[0]) ? -1
                :  ((rhs[0] < lhs[0]) ? 1
                :  (lhs[1] < rhs[1] ? -1
                :  ((rhs[1] < lhs[1] ? 1 : 0))));
        });

    std::cout << "After Sort..." << '\n';
    std::for_each(std::begin(ar), std::end(ar),
        [2]) { std::cout << ar[0] << ',' << ar[1] << '\n';});

    return 0;
}

Sample Run (yours will vary, obviously)

Before Sort...
2,11
18,4
20,20
14,6
8,10
17,8
14,14
3,10
20,14
19,19
After Sort...
2,11
3,10
8,10
14,6
14,14
17,8
18,4
19,19
20,14
20,20

Notes: this specifically uses strict-value comparison rather than subtraction short-cuts in the comparator so as to avoid potential underflow issues. If that is not a problem in your restricted data-space, you could easily make that comparator significantly simpler.