Блог

 #include <stdio.h>
#include <iostream>
using namespace std;
#define MAX 10
int main()
{
    //code
    int n,i=0,arr[MAX];
    cin>>n;
    for(int i =0;i<n;i  )
    {
        cin>>arr[i];
    }
    int j=1;
    while(i<namp;amp;j<=n)
    {
        if(arr[i]>0)
        {   
            i  ;
            j  ;
        }
    else if(arr[i]<0 amp;amp; arr[j]>0)
    {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
        i  ;
    }
    else if(arr[i]<0 amp;amp; arr[j]<0)
    {
        j  ;
    }
    else 
    {
        i  ;
    }
    }
    for(i=0;i<n;i  )
    {
        cout<<arr[i]<<" ";
    }
    return 0;
}
 

вход

     4
    -8
    -6
    7
    8
 

выход

     7 8 4196864 -6
 

Как я могу это решить?

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

Этот ответ опубликован для всех, кто ищет решение на C с использованием функций алгоритма. Функция, которая выполняет эту работу, — это std::раздел:

 #include <iostream>
#include <algorithm>

#define MAX 10
int main()
{
    int n = 4;
    int arr[MAX] = {-8, -6, 7, 8};
    std::partition(arr, arr   n, [amp;](int val) { return val >= 0;});
    for (int i = 0; i < n;   i)
       std::cout << arr[i] << " ";
}
 

Выход:

 8 7 -6 -8
 

Если вы хотите сохранить исходный относительный порядок элементов, вы можете использовать std::stable_partition:

 #include <iostream>
#include <algorithm>

#define MAX 10
int main()
{
    int n = 4;
    int arr[MAX] = {-8, -6, 7, 8};
    std::stable_partition(arr, arr   n, [amp;](int val) { return val >= 0;});
    for (int i = 0; i < n;   i)
       std::cout << arr[i] << " ";
}
 

Выход:

 7 8 -8 -6
 

Судя по опубликованному вами коду, похоже, что вы используете C, но с cout использованием и cin заимствованием из C .

Поскольку Полмкензи уже опубликовал однострочное решение на C , вот как бы вы написали его по-своему (путь C):

 #include <stdio.h>

void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void move_neg_to_end(int *arr, int n)
{
    int start, end = n-1;
    for (start = 0; start <= end; start  ) {
        if (arr[start] >= 0)
            continue;

        while (start < end amp;amp; arr[end] < 0)
            end--;

        if (start >= end)
            break;
        
        swap(amp;arr[start], amp;arr[end]);
        end--;
    }
}
 

Используйте его, как:

 int main()
{
    int arr[] = {4, -8, -6, 7, 8, -3, 2};
    int n = sizeof(arr) / sizeof(*arr);

    move_neg_to_end(arr, n);

    for (int i = 0; i < n; i  )
        printf("%d ", arr[i]);
}
 

ИЗМЕНИТЬ: Вот что не так с вашим кодом:

1 — Не смешивайте <stdio> и <iostream> . Вы используете либо C, либо C , а не оба. Так что просто выберите один из них. Если вы используете C (ваш случай), тогда перейдите к <iostream> .

2 — Избегайте using namespace std , потому что это загрязняет глобальное пространство имен. std:: Вместо этого используйте префикс или, если хотите, «ярлыки» using std::cin .

3 — Избегайте макросов «нравится #define MAX 10 » и используйте const int max = 10 их вместо этого. Макросы делают отладку болезненной.

4 — В C используйте std::array или std::vector . Избегайте необработанных массивов.

5- cin >> n … что, если n превысит MAX ?

6 — j <= n приводит к переполнению вашего массива.

7 — Логика вашего кода неверна. j следует начинать с n-1 , а не с 0 . Вот как вы можете это сделать:

1. Если arr[i] >= 0 перейти к следующему элементу.
2. Если arr[i] < 0 , а arr[j] < 0 затем продолжайте j уменьшаться, пока не найдете положительный элемент или не будет меньше или равно i .
3. Если arr[i] < 0 , а arr[j] >= 0 затем поменяйтесь arr[i] местами и arr[j] .
4. Перейти к шагу 1, если i <= j .