Сформировать из массива другой массив, содержащий цифры, расположенные по возрастанию - C (СИ)

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

Здравствуйте! Дан массив чисел

a=[1,4,0,3,7,3,5,8,10,6,2,7,8]

Сформировать из этого массива другой массив, содержащий цифры, расположенные по возрастанию, т.е. получится

a=1,4,3,7,3,5,8,10,2,7,8

Я анализировал методы сортировки, но видимо опыта не хватает на реализацию данной задачи. Заранее спасибо!

#include <stdio.h>
#include <locale.h> 
void input_keyboard(int s)
{
    int a[s];
 
    printf("Введите элементы матрицы А: \n");
    for (int i=0; i<s; i++)
    scanf ("%d", &a[i]);
}
void sort(int s)
{ 
int a[s],i,j,tmp;
for(i = 0 ; i < s - 1; i++) { 
       for(j = 0 ; j < s - i - 1 ; j++) {  
           if(a[j] > a[j+1]) {           
              tmp = a[j]; 
              a[j] = a[j+1]; 
              a[j+1] = tmp; 
           }
        }
    }
    printf("\n Результат Матрица:  \n");
    for (i=0; i<s; i++)
    printf ("%d ", a[i]);
}
void vyvod (int s)
{
    int a[s];
    printf("\n Матрица:  \n");
    for (int i=0; i<s; i++)
 
    printf ("%d ", a[i]);   
}
int main() {
    int n;
setlocale (LC_ALL, "Russian");
printf("Введите размерность матрицы:  \n");
scanf("%d",&n);
input_keyboard(n);
vyvod(n);
sort(n);
}

Решение задачи: «Сформировать из массива другой массив, содержащий цифры, расположенные по возрастанию»

Листинг программы

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int* GetAscendingSequences(const int* const arr, const int n, int* const resArrLength)
{
  int* res = NULL;
  int* temp = NULL;
 
  int newLength = 0;
  int i = 0;
  int flag = 0;
 
  res = malloc(n * sizeof(*res));
 
  if (res != NULL)
  {
    memset(res, 0, n * sizeof(*res));
 
    i = 0;
    flag = 0;
    while (i < n)
    {
      if (flag && (i == (n - 1)))
      {
        /* there can be a not closed sequence at the end */
        res[newLength] = arr[i];
        newLength++;
        flag = 0;
      }
      else
      {
        if (arr[i] < arr[i+1])
        {
          /* we have a sequence */
          flag = 1;
          res[newLength] = arr[i];
          newLength++;
        }
        else
        {
          if (flag)
          {
            /* ending sequence */
            res[newLength] = arr[i];
            newLength++;
            flag = 0;
          }
        }
      }
      i++;
    }
 
    if (newLength < n)
    {
      temp = realloc(res, newLength * sizeof(temp));
 
      if (temp == NULL)
      {
        free(res);
        res = NULL;
      }
      else
      {
        res = temp;
        temp = NULL;
      }
    }
 
    (*resArrLength) = newLength;
  }
 
  return res;
}
 
int main(void)
{
  int a[13] = {1,4,0,3,7,3,5,8,10,6,2,7,8};
  int* b = NULL;
 
  int N = 0;
  int i = 0;
 
  b = GetAscendingSequences(a, 13, &N);
 
  if (b != NULL)
  {
    for(i = 0; i < N; i++) printf("%d ", b[i]);
  }
 
  return 0;
}

Объяснение кода листинга программы

В данном коде представлен алгоритм, который получает на вход массив чисел и формирует из него массив, содержащий цифры, расположенные по возрастанию. Алгоритм работает следующим образом:

Инициализируем новый массив res нулями.
Проходим по исходному массиву arr.
Если текущий элемент arr[i] меньше следующего элемента arr[i+1], то мы нашли последовательность чисел, которая убывает. Добавляем текущий элемент в конец нового массива и помечаем флаг=1.
Если текущий элемент arr[i] больше следующего элемента arr[i+1], то мы нашли конец предыдущей последовательности. Добавляем текущий элемент в начало нового массива и помечаем флаг=0.
Если мы уже прошли весь исходный массив и длина нового массива меньше, чем количество элементов в исходном массиве, значит, в конце исходного массива есть не законченная последовательность. Добавляем последний элемент в новый массив и помечаем флаг=0.
Если длина нового массива равна количеству элементов в исходном массиве, то мы нашли все возможные последовательности.
Возвращаем новый массив. Пример работы алгоритма: Входные данные: a = [1, 4, 0, 3, 7, 3, 5, 8, 10, 6, 2, 7, 8] Результат работы алгоритма: [0, 1, 2, 3, 3, 4, 5, 6, 7, 7, 8, 8] Пояснение к коду:
В функции GetAscendingSequences используется динамическое выделение памяти под массив res с помощью malloc. При этом, если память не может быть выделена, то выделяется нулевой указатель.
В функции main создается массив a, инициализированный значениями [1, 4, 0, 3, 7, 3, 5, 8, 10, 6, 2, 7, 8].
Затем вызывается функция GetAscendingSequences, передавая ей массив a и его размер, а также указатель на переменную N, в которую будет записана длина полученного массива.
Результат работы функции GetAscendingSequences сохраняется в переменной b.
Затем происходит вывод полученного массива на экран с помощью цикла for и функции printf.