Лишние значения в динамическом массиве Си. Сортировка четных и нечетных

Question

исходный массив пpеобpазуется по следующему алгоpитму: все нечетные элементы массива гpуппиpуются в поpядке возpастания в начале массива, а четные в поpядке убывания в конце. прототип: int* f( int* a, int n ) a - указатель исходного массива, n - pазмеp массива.

В массивах odd и even откуда-то берутся дополнительные значения, хоть память под них не выделяется.

При вводе 6 1 2 3 4 5 6

Выводится -33686019 2 4 5 3 1

Если пытаться выводить значения за массивом, будет ещё одно необходимое число и дальше случайные числа подряд

```
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

int* f(int* a, int n);

int main()
{
    int count;
    printf("count: ");
    scanf("%d", &count);

    int* array = malloc(sizeof(int) * count);
    for (int i = 0; i < count; i++) {
        printf("%d element: ", i + 1);
        scanf("%d", &array[i]);
    }

    f(array, count);
}

int* f(int* a, int n) {
    int evenCount = 0;  //четн
    int oddCount = 0;   //нечетн
    for (int i = 0; i < n; i++) {
        if (a[i] % 2 == 0) {
            evenCount++;
        }
        if (a[i] % 2 != 0) {
            oddCount++;
        }
    }

    int* even = (int)calloc(evenCount, sizeof(int));
    int* odd = (int)calloc(oddCount, sizeof(int));

    evenCount = 0;
    oddCount = 0;

    for (int i = 0; i < n; i++) {
        if (a[i] % 2 == 0) {
            even[evenCount] = a[i];
            evenCount++;
        }
        else {
            odd[oddCount] = a[i];
            oddCount++;
        }
    }

    for (int i = 0; i < evenCount; i++) {
        for (int j = 0; j < evenCount - i; j++) {
            if (even[j] > even[j + 1]) {
                char temp = even[j];
                even[j] = even[j + 1];
                even[j + 1] = temp;
            }
        }
    }
    for (int i = 0; i < oddCount; i++) {
        for (int j = 0; j < oddCount - i; j++) {
            if (odd[j] < odd[j + 1]) {
                char temp = odd[j];
                odd[j] = odd[j + 1];
                odd[j + 1] = temp;
            }
        }
    }

    for (int i = 0; i < evenCount; i++) {
        printf("%d\n", even[i]);
    }
    for (int i = 0; i < oddCount; i++) {
        printf("%d\n", odd[i]);
    }
}
```

Answer 1

Давайте вы сначала исправите хотя бы самые очевидные ошибки...

Почему

int* f(int* a, int n) {

если в функции даже нет return? Сделайте

void f(int* a, int n) {

Зачем тут приведение типов (к int с последующим присваиванием int*, которое в 64-разрядной архитектуре больше по размеру — т.е. будут некорректные адреса):

int* even = (int)calloc(evenCount, sizeof(int));
int* odd = (int)calloc(oddCount, sizeof(int));

Уберите эти (int).

Далее, вы работаете с int, но обмен пытаетесь делать через char?!

 char temp = even[j];
 char temp = odd[j];

Не хотите воспользоваться int'ом?

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

Answer 2

Можно все это делать на месте, написав подходящую функцию сравнени.

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

int comp(const void* a_, const void* b_) {
    int a = *(const int*)a_;
    int b = *(const int*)b_;

    if (abs(a % 2) > abs(b % 2)) return -1;

    if (abs(a % 2) < abs(b % 2)) return  1;

    if (a % 2) return a - b;
    else return b - a;
    }


int main() {
    int count;
    printf("count: ");
    scanf("%d", &count);
    int* array = malloc(sizeof(int) * count);

    for (int i = 0; i < count; i++) {
        printf("%d element: ", i + 1);
        scanf("%d", &array[i]);
        }

    qsort(array, count, sizeof(int), comp);

    for (int i = 0; i < count; i++) {
        printf("%d  ", array[i]);
        }
    }

Убедитесь сами: https://ideone.com/DmBdOH

БЛОГ НА HUSL

Лишние значения в динамическом массиве Си. Сортировка четных и нечетных

Ответы (2 шт):