Мой массив получает ошибку, потому что он определяется как единственное целое число

Question

Цель этой программы - вывести, отсортирована ли серия цифр (число неопределяемых цифр) или нет (от наибольшей к наименьшей или от наименьшей к наибольшей).
Я определил свой массив в параметре своей функции, и я пытаюсь использовать для l oop для хранения ввода пользователя, если он выше 0, в указанном массиве.
Однако я получаю ошибку argument of type int is incompatible with parameter of type int*.
Точная ошибка это the argument of type int is incompatible with parameter of type int*.
Это относится к строкам 22 и 23, этим двум;
isSorted(list[2000]); и
bool is = isSorted(list[2000]);.
Я знаю, это означает, что мой для l oop назначает одно значение моей переменной неоднократно от чтения аналогичных вопросов, однако я не могу понять, как это исправить.

#include <iostream>
using namespace std;

bool isSorted(int list[]);

int main()
{    
    int i;
    int list[2000];
    int k = 0;
    for (i = 0; i < 2000; i++)
    {
        int j;
        while (j > 0)
        {
            cin >> j;
            list[i] = j;
        }
    }
    isSorted(list[2000]);
    bool is = isSorted(list[2000]);
    if (is == true)
        cout << "sorted";
    else
        cout << "unsorted";

    return 0;
}

bool isSorted(int list[])
{
    int i = 0;
    for (i = 0; i < 2000; i++)
    {
        if (list[i] > list[i + 1] || list[i] < list[i - 1])
        {
            return false;
        }
        else
            return true;
    }
}

Answer 1

• Я удалил неиспользуемую переменную k.
• Сделано 2000 параметризовано (и установлено на 5 для тестирования).
• В isSorted вам не разрешено возвращать true в else, как если бы ваш первый тестовый элемент завершился, иначе вы бы вернули true немедленно, не проверяя другие элементы. Но эти более поздние элементы также могут быть не отсортированы.

• В isSorted вам не разрешено запускать l oop как for(i = 0; i < 2000; i++), потому что вы добавляете внутрь для l oop 1 на i и в итоге запросим i == 1999 list[2000], который является номером элемента 2001, а не внутри вашего массива. Вместо этого это правильно: for (i = 0; i < 1999; i++). Вам также не нужно проверять оба направления.

• Вы не можете вызвать isSorted(list[2000]), так как этот вызов сортируется с массивом int, а не массивом int в качестве параметра.

• Вы пишете int j без его инициализации, а затем запрашиваете while j > 0 перед вами cin << j. Это неопределенное поведение, хотя, скорее всего, j будет равно нулю, гарантии нет. Но, скорее всего, вы никогда не введете while l oop и никогда не введете cin

• Я переименовал isSorted, как вы просто отметили в своем примере в порядке возрастания. Если вы хотите проверить порядок убывания, вы можете потренировать свои навыки программирования и реализовать это самостоятельно.

Вот код с исправлениями:

#include <iostream>
using namespace std;

bool isSortedInAscendingOrder(int list[]);

const int size = 5; // Set this to 2000 again if you want

int main()
{
    int i;
    int list[size];
    for (i = 0; i < size; i++)
    {
        int j = 0;
        while(j <= 0)
        {
            cin >> j;
            if(j <= 0)
                cout << "rejected as equal or smaller zero" << endl;
        }
        list[i] = j;
    }
    if (isSortedInAscendingOrder(list))
        cout << "sorted" << endl;
    else
        cout << "unsorted" << endl;

    return 0;
}

bool isSortedInAscendingOrder(int list[])
{
    for (int i = 0; i < size -1; i++)
    {
        if (list[i] > list[i + 1])
        {
            return false;
        }
    }
    return true;
}

Answer 2

Это определение массива из 2000 целых чисел.

int list[2000];

Это чтение 2000-й записи в этом массиве и неопределенное, потому что самый высокий юридический индекс для доступа - 1999. Помните, что первый юридический индекс индекс равен 0.

list[2000]

Так что да, с точки зрения компилятора, следующее дает только одно целое число поверх неопределенного поведения (то есть "зло").

isSorted(list[2000]);

Вы, вероятно, должны изменить это, чтобы решить непосредственную проблему - и приблизиться к тому, что вы, вероятно, хотите. Он называет весь массив в качестве параметра. Он будет уменьшаться до указателя на int (среди прочего, теряется информация о размере, но вы жестко закодировали это внутри функции; лучше изменить это между прочим).

isSorted(list);

Удалите пропущенный первый вхождение ( один в строке), оставьте второй (тот, который присваивается переменной bool).

С другой стороны, лог c вашей проверки сортировки имеет недостатки, он часто будет иметь доступ за пределами массив для индексов 0 и 1999. Т.е. в начале и в конце вашего l oop. Вам нужно l oop немного меньше, чем весь массив, и использовать только одно из двух условий.

Т.е. сделать

for (i = 1; i < 2000; i++)
{
    if (list[i] < list[i - 1])
/* ... */

Лог c для проверки восходящего или нисходящего сортировка должна быть более сложной. Вопрос не в том, чтобы исправить эту логику c, поэтому я придерживаюсь решения проблем в соответствии с исходной версией (в которой не упоминалась двусторонняя сортировка).
Вы на самом деле не спрашивали о исправлении логи c за это. Но вот подсказка:
Либо используйте две петли, которые вы можете разорвать, как только обнаружите конфликт, но не сразу вернетесь из функции.
Или используйте одну l oop и оставьте флажок о том, был ли нарушен восходящий или нисходящий порядок. Затем верните true, если либо флаг все еще не активен (или оба, в случае всех идентичных значений), либо верните false, если оба установлены.