Je třeba zkontrolovat, zda pole je řazena pomocí funkce v C

Špatná logika

OP je kód selže kvůli

}else if (A[i]>=A[i+1]){
tempdcr++;

by měla být

}
if (A[i]>=A[i+1]) {
  tempdcr++;

Vezměme si případ, kdy A[i]==A[i+1]oba pulty by se měla zvyšovat.

Nezdravé Hodnoty

Chybí inicializace @kaylum.

// int tempcr, tempdcr;
int tempcr = 0;
int tempdcr = 0;

Alternativní přístup:

K dispozici jsou 4 možnosti

• Pole má stejnou hodnotu, hodnota, kde každý - nebo je délka 0.

• Pole je vzestupně. A[i] >= A[i-1] pro všechny i > 0 a délka je větší než 0.

• Pole sestupně. A[i] <= A[i-1] pro všechny i > 0 a délka je větší než 0.

• Žádný z výše uvedených.

Jednoduše smyčky a upravit dvě vlajky. int tempcr, tempdcr; pulty nejsou potřeba.

int Is_Sorted(const int* A, int n) {
  bool isAscending = true;
  bool isDescending = true;
  for (int i = 1; i<n; i++) { // start at 1
     if (A[i] < A[i-1]) isAscending = false;
     if (A[i] > A[i-1]) isDescending = false;
  }
  if (isAscending && isDescending) {
    return TBD; // Unsure what OP wants here
  }
  if (isAscending) {
    return 1;
  }
  if (isDescending) {
    return -1;
  }
  return 0;
}

Zjednodušení a některé micro optimalizace je to možné, ale něco objasnit, jasný přístup.

Příliš mnoho zábavy.

Pokud int a[] není konstantní, můžeme použít pouze 1 test za iteraci místo 3: test já, je méně, je více z výše uvedený kód.

První pohled na nerovnost od konce směrem k začátku. První prvek je upravena tak, aby být odlišný od poslední.

Pokud projdeme celý seznam, jsme hotovi, jinak první část seznamu se liší od poslední prvek.

Pokud poslední porovnání je vzestupně, nastavit první prvek na INT_MAX a hledat směrem k začátku pro non-vzestupně pár.

Jinak
Pokud poslední porovnání je sestupně, první prvek INT_MIN a hledat směrem k začátku pro non-sestupující dvojici.

Po nalezení porovnat dojde k selhání, a to buď pole je neuspořádané, nebo jsme na začátku. Pokud se na začátku, zvládnout to zvláštní případ.

V každém případě, pouze 1 porovnat na iteraci.

#define ASCENDING 1
#define DESCENDING -1
#define UNORDERED 0
#define ALLSAME 1 // Adjust as desired
#define SHORT_LENGTH 1 // Adjust as desired

int is_sorted(size_t n, int *a) {
  if (n <= 1) {
    return n ? ALLSAME : SHORT_LENGTH;
  }

  int last = a[--n];
  int first = a[0];
  a[0] = !last;
  while (last == a[--n]) {
    ;
  }
  a[0] = first; // restore
  if (n == 0) {
    if (a[0] < a[1]) {
      return ASCENDING;
    }
    if (a[0] > a[1]) {
      return DESCENDING;
    }
    return ALLSAME;
  }

  if (a[n - 1] < a[n]) {
    // Only ascending, unordered possible
    a[0] = INT_MAX;
    while (a[n - 1] <= a[n]) {
      n--;
    }
    a[0] = first; // restore
    if (a[n - 1] <= a[n]) {
      return ASCENDING;
    }
  } else {
    // Only descending, unordered possible
    a[0] = INT_MIN;
    while (a[n - 1] <= a[n]) {
      n--;
    }
    a[0] = first; // restore
    if (a[n - 1] <= a[n]) {
      return DESCENDING;
    }
  }
  return UNORDERED;
}

Budu dělat nějaké další testy později.

V případě, že pole je consttřeba 2 test na smyčku.

Pro začátek funkce by měla být deklarována jako

int Is_Sorted( const int* A, size_t n );

to je alespoň první parametr by měl mít kvalifikaci const protože prošel pole není měněn v rámci funkce.

Proměnné tempcr a tempdcr nebyly inicializovány a mají neurčité hodnoty. Takže funkce má nedefinované chování. Budete muset inicializovat, je jako

int tempcr = 0, tempdcr = 0;

Není tam žádný smysl, aby i nadále iterací smyčky, pokud je již známo, že pole je netříděný, protože to je neefektivní.

Navíc funkce má logické chyby.

Zvažte pole { 0, 0, -1 }

V tomto případě v první iteraci smyčky proměnná tempcr bude zvýšena v důsledku if prohlášení

if (A[i]<=A[i+1]){
    tempcr++;
}else if (A[i]>=A[i+1]){
tempdcr++;
}

Ale v druhé iteraci smyčky proměnná tempdcr bude zvýšena.

Takže funkce bude zpráva, že pole je netříděný i když to je řazena v sestupném pořadí.

Já bych definovat funkci následujícím způsobem

int is_sorted( const int a[], size_t n )
{
    size_t ascending = 0, descending = 0;

    for (size_t i = 1; ( ascending == 0 || descending == 0 ) && i < n; i++)
    {
        if ( a[i-1] < a[i] ) ++ascending;
        else if ( a[i] < a[i-1] ) ++descending;
    }

    return descending == 0 ? 1 : ( ascending == 0 ? -1 : 0 );
}

Pokud je předán pole má všechny prvky rovné navzájem, pak funkce domnívá se, že je jako řazeny ve vzestupném pořadí.

Jak uvedla @chux - Obnovit Monica se ve své odpovědi místo počítání prvků můžete použít odpovídající proměnné jako booleovské objekty. V tomto případě funkce může vypadat jako

int is_sorted1( const int a[], size_t n )
{
    int ascending = 0, descending = 0;

    for (size_t i = 1; ( ascending == 0 || descending == 0 ) && i < n; i++)
    {
        if ( a[i-1] < a[i] ) ascending = 1;
        else if ( a[i] < a[i-1] ) descending = 1;
    }

    return descending == 0 ? 1 : ( ascending == 0 ? -1 : 0 );
}