Сортировка строк двухмерного динамического массива по возрастанию - C (СИ)

Узнай цену своей работы

Формулировка задачи:

Помогите,пожалуйста, написать программу так,чтобы программный код, выполняющий действия пунктов меню выполнялся в отдельных

функциях

. И

без использования глобальных функций

. А вот исходный код,если что, без функций.Вот этот
Листинг программы 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <locale.h>
  4. #include <time.h>
  5.  
  6. #define _CRTDBG_MAP_ALLOC
  7. #include <crtdbg.h>
  8.  
  9. int main()
  10. {
  11.     setlocale(0, "");
  12.  
  13.     srand(time(NULL));
  14.  
  15.     int height = 0;
  16.     int width = 0;
  17.     int numb = 0;
  18.     int numb2 = 0;
  19.     int t = 0;
  20.     int sort;
  21.     int **a = NULL;
  22.  
  23.     a = new int * [height];
  24.                 
  25.     for ( int i = 0; i < height; i ++ )
  26.     {
  27.         a[i] = new int [width];
  28.     }
  29.  
  30.     printf("Программа сортировки строк двухмерного динамического массива по возрастанию\n\n");
  31.  
  32.     do
  33.     {
  34.         fflush(stdin);
  35.         printf("1. Задать размерность двухмерного массива\n");
  36.         printf("2. Выбор заполнения массива\n");
  37.         printf("3. Вывод необработанного массива\n");
  38.         printf("4. Обработка массива\n");
  39.         printf("5. Вывод обработанного массива на экран\n");
  40.         printf("0. Выход и программы\n");
  41.         scanf_s("%d", &numb);
  42.         system("cls");
  43.  
  44.         switch(numb)
  45.         {
  46.         case 1:
  47.             {
  48.                 for ( int i = 0; i < height; i ++ )
  49.                 {
  50.                     delete [] a[i];
  51.                 }
  52.                 delete [] a;
  53.  
  54.                 height = 0;
  55.                 width = 0;
  56.  
  57.                 do
  58.                 {       
  59.                     fflush(stdin);
  60.                     printf("Введите размерность массива: ");
  61.                     printf("\nШирина:> ");
  62.                     scanf_s("%d", &width);
  63.                     printf("Высота:> ");
  64.                     scanf_s("%d", &height);
  65.                     system("cls");
  66.                 }
  67.                 while ( height <= 0 || width <= 0);
  68.                 
  69.                 a = new int * [height];
  70.                 
  71.                 for ( int i = 0; i < height; i ++ )
  72.                 {
  73.                     a[i] = new int [width];
  74.                 }
  75.  
  76.                 t = 1;
  77.                 break;
  78.             }
  79.         case 2:
  80.             {
  81.                 if ( t > 0 )
  82.                 {
  83.                     do
  84.                     {
  85.                         fflush(stdin);
  86.                         printf("Выберите:\n 1. С клавиатуры\n 2. Рандомно\n");
  87.                         scanf_s("%d", &numb2);
  88.                         system("cls");
  89.                     }
  90.                     while ( numb2 != 1 && numb2 != 2 );
  91.                     
  92.                     switch (numb2)
  93.                     {
  94.                     case 1:
  95.                         {
  96.                             printf("Заполните массив:\n");
  97.  
  98.                             for ( int i = 0; i < height; i ++ )
  99.                             {
  100.                                 for( int j = 0; j < width; j ++ )
  101.                                 {
  102.                                     printf("Введите элемент %d-ой строчки %d-ого столбца: ", i + 1, j + 1);
  103.                                     scanf_s("%d", &a[i][j]);
  104.                                 }
  105.                                 system("cls");
  106.                             }
  107.                             break;
  108.                         }
  109.                     case 2:
  110.                         {
  111.                             printf("Массив заполнен рандомно");
  112.                             getchar();
  113.                             getchar();
  114.                             system("cls");
  115.  
  116.                             for ( int i = 0; i < height; i ++ )
  117.                             {
  118.                                 for( int j = 0; j < width; j ++ )
  119.                                 {
  120.                                     a[i][j] = rand() % 50 - 25;
  121.                                 }
  122.                             }
  123.                             break;
  124.                         }
  125.                     }
  126.                     t = 2;
  127.                 }
  128.                 else
  129.                 {
  130.                     printf("Задайте размерность массива\n");
  131.                     getchar();
  132.                     getchar();
  133.                     system("cls");
  134.                 }
  135.                 break;
  136.             }
  137.         case 3:
  138.             {
  139.                 if ( t == 2 )
  140.                 {
  141.                     printf("Вот сам массив:\n");
  142.  
  143.                     for ( int i = 0; i < height; i ++ )
  144.                     {
  145.                         for( int j = 0; j < width; j ++ )
  146.                         {
  147.                             printf("%4d", a[i][j]);
  148.                         }
  149.                         printf("\n");
  150.                     }
  151.                     getchar();
  152.                     getchar();
  153.                     system("cls");
  154.                     break;
  155.                 }
  156.                 else
  157.                 {
  158.                     printf("Сделайте предыдущий шаг");
  159.                     getchar();
  160.                     getchar();
  161.                     system("cls");
  162.                     break;
  163.                 }
  164.                 break;
  165.             }
  166.         case 4:
  167.             {
  168.                 if ( t == 2 )
  169.                 {
  170.                     int * x = NULL;
  171.                     
  172.                     for( int i = 0; i < height; ++ i )
  173.                     {
  174.                         for( int j = i + 1; j < height; ++ j )
  175.                         {
  176.                             if( a[i][0] > a[j][0] )
  177.                             {
  178.                                 x = a[i];
  179.                                 a[i] = a[j];
  180.                                 a[j] = x;
  181.                             }
  182.                         }
  183.                     }
  184.                     
  185.                     printf("Массив обработан\n");
  186.                     getchar();
  187.                     getchar();
  188.                     system("cls");
  189.                     t = 4;
  190.                 }
  191.                 else
  192.                 {
  193.                     printf("Сделайте предыдущий шаг");
  194.                     getchar();
  195.                     getchar();
  196.                     system("cls");
  197.                 }
  198.                 break;
  199.             }
  200.         case 5:
  201.             {
  202.                 if ( t == 4 )
  203.                 {
  204.                     printf("Вот обработанный массив\n");
  205.  
  206.                     for ( int i = 0; i < height; i ++ )
  207.                     {
  208.                         for( int j = 0; j < width; j ++ )
  209.                         {
  210.                             printf("%4d", a[i][j]);
  211.                         }
  212.                         printf("\n");
  213.                     }
  214.                     getchar();
  215.                     getchar();
  216.                     system("cls");
  217.  
  218.                 }
  219.                 else
  220.                 {
  221.                     printf("Сделаете предыдущие шаги");
  222.                     getchar();
  223.                     getchar();
  224.                     system("cls");
  225.                 }
  226.                 break;
  227.             }
  228.         }
  229.  
  230.     }
  231.     while ( numb != 0 );
  232.     
  233.     for ( int i = 0; i < height; i ++ )
  234.     {
  235.         delete [] a[i];
  236.     }
  237.     
  238.     delete [] a;
  239.  
  240.     _CrtDumpMemoryLeaks();
  241.     return 0;
  242. }
Я тут наколякал,но я не профи пока в программировании.Так что это не верно немного)))
Листинг программы 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <locale.h>
  4. #include <time.h>
  5.  
  6. #define _CRTDBG_MAP_ALLOC
  7. #include <crtdbg.h>
  8.  
  9. void case1(int **a,int height,int width);
  10. void case1(int **a,int height,int width)
  11. {
  12.     for ( int i = 0; i < height; i ++ )
  13.     {
  14.         delete [] a[i];
  15.     }
  16.     delete [] a;
  17.  
  18.     height = 0;
  19.     width = 0;
  20.  
  21.     do
  22.     {       
  23.         fflush(stdin);
  24.         printf("Введите размерность массива: ");
  25.         printf("\nШирина:> ");
  26.         scanf_s("%d", &width);
  27.         printf("Высота:> ");
  28.         scanf_s("%d", &height);
  29.         system("cls");
  30.     }
  31.     while ( height <= 0 || width <= 0);
  32.                 
  33.     a = new int * [height];
  34.                 
  35.     for ( int i = 0; i < height; i ++ )
  36.     {
  37.         a[i] = new int [width];
  38.     }
  39. }
  40.  
  41. void case2(int **a,int height,int width,int numb2);
  42. void case2(int **a,int height,int width, int numb2)
  43. {
  44.     system("cls");
  45.     do
  46.     {
  47.         fflush(stdin);
  48.         printf("Выберите:\n 1. С клавиатуры\n 2. Рандомно\n");
  49.         scanf_s("%d", &numb2);
  50.         system("cls");
  51.     }
  52.     while ( numb2 != 1 && numb2 != 2 );
  53.                     
  54.     switch (numb2)
  55.     {
  56.     case 1:
  57.         {
  58.             printf("Заполните массив:\n");
  59.  
  60.             for ( int i = 0; i < height; i ++ )
  61.             {
  62.                 for( int j = 0; j < width; j ++ )
  63.                 {
  64.                     printf("Введите элемент %d-ой строчки %d-ого столбца: ", i + 1, j + 1);
  65.                     scanf_s("%d", &a[i][j]);
  66.                 }
  67.                 system("cls");
  68.             }
  69.             break;
  70.         }
  71.     case 2:
  72.         {
  73.             printf("Массив заполнен рандомно");
  74.             getchar();
  75.             system("cls");
  76.  
  77.             for ( int i = 0; i < height; i ++ )
  78.             {
  79.                 for( int j = 0; j < width; j ++ )
  80.                 {
  81.                     a[i][j] = rand() % 50 - 25;
  82.                 }
  83.             }
  84.             break;
  85.         }
  86.     }
  87. }
  88.  
  89. void case3(int **a,int height,int width);
  90. void case3(int **a,int height,int width)
  91. {
  92.     system("cls");
  93.     printf("Вот сам массив:\n");
  94.  
  95.     for ( int i = 0; i < height; i ++ )
  96.     {
  97.         for( int j = 0; j < width; j ++ )
  98.         {
  99.             printf("%4d", a[i][j]);
  100.         }
  101.         printf("\n");
  102.     }
  103.     getchar();
  104.     system("cls");
  105. }
  106.  
  107. void case4(int **a,int height,int width, int *x);
  108. void case4(int **a,int height,int width, int *x)
  109. {
  110.     system("cls");
  111.     for( int i = 0; i < height; ++ i )
  112.     {
  113.         for( int j = i + 1; j < height; ++ j )
  114.         {
  115.             if( a[i][0] > a[j][0] )
  116.             {
  117.                 x = a[i];
  118.                 a[i] = a[j];
  119.                 a[j] = x;
  120.             }
  121.         }
  122.     }
  123.                     
  124.     printf("Массив обработан\n");
  125.     getchar();
  126.     system("cls");
  127. }
  128.  
  129. void case5(int **a,int height,int width);
  130. void case5(int **a,int height,int width)
  131. {
  132.     system("cls");
  133.     printf("Вот обработанный массив\n");
  134.  
  135.     for ( int i = 0; i < height; i ++ )
  136.         {
  137.             for( int j = 0; j < width; j ++ )
  138.             {
  139.                 printf("%4d", a[i][j]);
  140.             }
  141.             printf("\n");
  142.         }
  143.         getchar();
  144.         system("cls");
  145. }
  146.  
  147. void del(int **a,int height);
  148. void del(int **a,int height)
  149. {
  150.     for ( int i = 0; i < height; i ++ )
  151.     {
  152.         delete [] a[i];
  153.     }
  154.     
  155.     delete [] a;
  156. }
  157.  
  158. int print( int n );
  159. int print( int n )
  160. {
  161.     if ( 1 == n )
  162.     {
  163.         fflush(stdin);
  164.         printf("1. Задать размерность двухмерного массива\n");
  165.         printf("2. Выбор заполнения массива\n");
  166.         printf("3. Вывод необработанного массива\n");
  167.         printf("4. Обработка массива\n");
  168.         printf("5. Вывод обработанного массива на экран\n");
  169.         printf("0. Выход и программы\n");
  170.     }
  171.     int m;
  172.     scanf_s("%d", &m);
  173.     getchar();
  174.  
  175.     return m;
  176. }
  177.  
  178. int main()
  179. {
  180.     setlocale(0, "");
  181.  
  182.     srand(time(NULL));
  183.  
  184.     int height = 0;
  185.     int width = 0;
  186.     int numb2 = 0;
  187.     int t = 0;
  188.     int sort;
  189.     int **a = NULL;
  190.     int *x = NULL;
  191.  
  192.     a = new int * [height];
  193.                 
  194.     for ( int i = 0; i < height; i ++ )
  195.     {
  196.         a[i] = new int [width];
  197.     }
  198.  
  199.     printf("Программа сортировки строк двухмерного динамического массива по возрастанию\n\n");
  200.  
  201.     int menu = 0;
  202.  
  203.     do
  204.     {
  205.         menu = print(1);
  206.  
  207.         switch(menu)
  208.         {
  209.         case 1:
  210.             {
  211.                 case1(a,height,width);
  212.  
  213.                 t = 1;
  214.                 break;
  215.             }
  216.         case 2:
  217.             {
  218.                 if ( t > 0 )
  219.                 {
  220.                     case2(a,height,width, numb2);
  221.                     t = 2;
  222.                 }
  223.                 else
  224.                 {
  225.                     printf("Задайте размерность массива\n");
  226.                     getchar();
  227.                     getchar();
  228.                     system("cls");
  229.                 }
  230.                 break;
  231.             }
  232.         case 3:
  233.             {
  234.                 if ( t == 2 )
  235.                 {
  236.                     case3(a,height,width);
  237.                     t = 3;
  238.                     break;
  239.                 }
  240.                 else
  241.                 {
  242.                     printf("Сделайте предыдущий шаг");
  243.                     getchar();
  244.                     getchar();
  245.                     system("cls");
  246.                     break;
  247.                 }
  248.                 break;
  249.             }
  250.         case 4:
  251.             {
  252.                 if ( t == 3 )
  253.                 {
  254.                     case4(a, height, width, x);
  255.                     t = 4;
  256.                 }
  257.                 else
  258.                 {
  259.                     printf("Сделайте предыдущий шаг");
  260.                     getchar();
  261.                     getchar();
  262.                     system("cls");
  263.                 }
  264.                 break;
  265.             }
  266.         case 5:
  267.             {
  268.                 if ( t == 4 )
  269.                 {
  270.                     case5(a,height,width);
  271.                 }
  272.                 else
  273.                 {
  274.                     printf("Сделаете предыдущие шаги");
  275.                     getchar();
  276.                     getchar();
  277.                     system("cls");
  278.                 }
  279.                 break;
  280.             }
  281.         }
  282.  
  283.     }
  284.     while ( menu != 0 );
  285.     
  286.     del(a,height);
  287.  
  288.     _CrtDumpMemoryLeaks();
  289.     return 0;
  290. }

Решение задачи: «Сортировка строк двухмерного динамического массива по возрастанию»

textual
Листинг программы 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <locale.h>
  4. #include <time.h>
  5.  
  6. void init() {
  7.     setlocale(0, "");
  8.     srand(time(NULL));
  9.     printf( "Программа сортировки строк двухмерного динамического массива по возрастанию\n\n");
  10.  
  11. }
  12.  
  13. int **alloc_array(int n_row, int n_col) {
  14.     int **a =(int**)malloc (n_row*sizeof(int*));
  15.     for (int i = 0; i < n_row; i++) {
  16.         a[i] = (int*)malloc(n_col*sizeof(int));
  17.     }
  18.     return a;
  19. }
  20. // int ***a, чтобы вернуть из функции адрес массива
  21. void case1(int ***a, int *n_col, int *n_row) {
  22.     do {
  23.         //1\fflush(stdin);
  24.         printf("Введите размерность массива: ");
  25.         printf("\nШирина:> ");
  26.         scanf("%d", n_col);
  27.         printf("Высота:> ");
  28.         scanf("%d", n_row);
  29.         //system("cls");
  30.     } while (*n_row <= 0 || *n_col <= 0);
  31.     //здесь отдаем адрес наружу
  32.     *a = alloc_array(*n_row, *n_col);
  33. }
  34.  
  35. void case2(int **a, int n_row, int n_col) {
  36.     int vybor;
  37.     if (a != NULL) {
  38.         do {
  39.             //fflush(stdin);
  40.             printf("Выберите:\n 1. С клавиатуры\n 2. Рандомно\n");
  41.             scanf("%d", &vybor);
  42.             system("cls");
  43.         } while (vybor != 1 && vybor != 2);
  44.         switch (vybor) {
  45.         case 1: {
  46.             printf("Заполните массив:\n");
  47.             for (int i = 0; i < n_row; i++) {
  48.                 for (int j = 0; j < n_col; j++) {
  49.                     printf("Введите элемент %d-ой строчки %d-ого столбца: ",
  50.                             i + 1, j + 1);
  51.                     scanf("%d", &a[i][j]);
  52.                 }
  53.                 system("cls");
  54.             }
  55.             break;
  56.         }
  57.         case 2: {
  58.             printf("Массив заполнен случайными числами");
  59.             getchar();
  60.             getchar();
  61.             system("cls");
  62.             for (int i = 0; i < n_row; i++) {
  63.                 for (int j = 0; j < n_col; j++) {
  64.                     a[i][j] = rand() % 50 - 25;
  65.                 }
  66.             }
  67.             break;
  68.         }
  69.         }
  70.     } else {
  71.         printf("Сделайте предыдущий шаг");
  72.         getchar();
  73.         getchar();
  74.         system("cls");
  75.     }
  76. }
  77.  
  78. void case3(int **a, int n_row, int n_col) {
  79.     if (a != NULL) {
  80.         printf("Вот сам массив:\n");
  81.         for (int i = 0; i < n_row; i++) {
  82.             for (int j = 0; j < n_col; j++) {
  83.                 printf("%4d", a[i][j]);
  84.             }
  85.             printf("\n");
  86.         }
  87.         getchar();
  88.         getchar();
  89.         system("cls");
  90.     } else {
  91.         printf("Сделайте предыдущий шаг");
  92.         getchar();
  93.         getchar();
  94.         system("cls");
  95.     }
  96. }
  97.  
  98. void case4(int **a, int n_row, int n_col) {
  99.     if (a != NULL) {
  100.         int x = 0;
  101.         for (int i = 0; i < n_row; ++i) {
  102.             for (int j = 0; j < n_col; ++j) {
  103.                 {
  104.                     // тут разобраться в вашем коде
  105.                     a[i][i] = 0;
  106.                 }
  107.             }
  108.         }
  109.         printf("Массив обработан\n");
  110.         getchar();
  111.         getchar();
  112.         //system("cls");
  113.     } else {
  114.         printf("Сделайте предыдущий шаг");
  115.         getchar();
  116.         getchar();
  117.         system("cls");
  118.     }
  119. }
  120.  
  121. void case5(int **a, int n_row, int n_col) {
  122.     if (a != NULL) {
  123.         printf("Вот обработанный массив\n");
  124.         for (int i = 0; i < n_row; i++) {
  125.             for (int j = 0; j < n_col; j++) {
  126.                 printf("%4d", a[i][j]);
  127.             }
  128.             printf("\n");
  129.         }
  130.         getchar();
  131.         getchar();
  132.         system("cls");
  133.  
  134.     } else {
  135.         printf("Сделаете предыдущие шаги");
  136.         getchar();
  137.         getchar();
  138.         system("cls");
  139.     }
  140. }
  141.  
  142. void destroy(int **a, int n_row) {
  143.     for (int i = 0; i < n_row; i++) {
  144.         free(a[i]);
  145.     }
  146.     free(a);
  147. }
  148. void menu() {
  149.     int n_row = 0;
  150.     int n_col = 0;
  151.     int **a = NULL;
  152.     init();
  153.     int vybor = 0;
  154.     do {
  155.         //fflush(stdin);
  156.         printf("1. Задать размерность двухмерного массива\n");
  157.         printf("2. Выбор заполнения массива\n");
  158.         printf("3. Вывод необработанного массива\n");
  159.         printf("4. Обработка массива\n");
  160.         printf("5. Вывод обработанного массива на экран\n");
  161.         printf("0. Выход и программы\n");
  162.         scanf("%d", &vybor);
  163.         system("cls");
  164.         switch (vybor) {
  165.         case 1: {
  166.             case1(&a, &n_row, &n_col);
  167.             break;
  168.         }
  169.         case 2: {
  170.             case2(a, n_row, n_col);
  171.             break;
  172.         }
  173.         case 3: {
  174.             case3(a, n_row, n_col);
  175.             break;
  176.         }
  177.         case 4: {
  178.             case4(a, n_row, n_col);
  179.             break;
  180.         }
  181.         case 5: {
  182.             case5(a, n_row, n_col);
  183.             break;
  184.         }
  185.         }
  186.     } while (vybor != 0);
  187.     destroy(a, n_row);
  188. }
  189.  
  190. int main() {
  191.     menu();
  192.     return 0;
  193. }

ИИ поможет Вам:

  • решить любую задачу по программированию
  • объяснить код
  • расставить комментарии в коде
  • и т.д
Попробуйте бесплатно

Оцени полезность:

10   голосов , оценка 3.9 из 5

Нужна аналогичная работа?

Оформи быстрый заказ и узнай стоимость

Бесплатно
Оформите заказ и авторы начнут откликаться уже через 10 минут
Похожие ответы