Je potrebné skontrolovať, či pole je utriedené pomocou funkcie v C

Nesprávne logika

OP je kód zlyhá v dôsledku

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

by mal byť

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

Posúdiť prípad, keď A[i]==A[i+1]obe počítadlá by prírastok.

Nevyžiadané Hodnoty

Chýba inicializácia @kaylum.

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

Alternatívny prístup:

Existujú 4 možnosti

• Pole má rovnakú hodnotu hodnotu každej kde - alebo je na dĺžku 0.

• Pole je vzostupne. A[i] >= A[i-1] pre všetkých i > 0 a dĺžka je viac ako 0.

• Pole je zoradený zostupne. A[i] <= A[i-1] pre všetkých i > 0 a dĺžka je viac ako 0.

• Žiadna z vyššie.

Jednoducho slučky a nastaviť dve vlajky. int tempcr, tempdcr; počítadlá nie je potrebné.

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šenia a niektoré micro optimalizácia je to možné, ale niečo objasniť jasný prístup.

Príliš veľa zábavy.

Ak int a[] nie je konštantné, môžeme použiť len 1 test na iterácia namiesto 3: test som, je menej, je viac uvedeného kódu.

Prvý pohľad na nerovnosti od konca k začiatku. Prvým prvkom je upravená tak, aby sa líši od poslednej.

Ak budeme chodiť celý zoznam, sme urobili, inak prvú časť zoznamu, sa líši od posledného prvku.

Ak posledný porovnajte sa vzostupne, nastavte prvý prvok INT_MAX a hľadať smerom k začiatku pre non-vzostupne pár.

Inak
Ak posledný porovnajte je klesajúca, nastavte prvý prvok INT_MIN a hľadať smerom k začiatku pre non-zostupne pár.

Po nájsť a porovnať dôjde k poruche, buď pole je neusporiadaný, alebo sme na začiatku. Ak na začiatku, rukoväť, že špeciálny prípad.

V každom prípade, len 1 porovnať na iteráciu.

#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;
}

Budem robiť niektoré ďalšie testovanie neskôr.

Ak je pole const, potrebné 2 test na slučky.

Pre začiatok funkcie by mali byť deklarované ako

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

že je to aspoň prvý parameter by mal mať qualifier const pretože prešiel pole nie je zmenou vo funkcii.

Premenné tempcr a tempdcr neboli inicializovaný a majú nerozhodné hodnoty. Tak funkcia má definované správanie. Musíte inicializovat ' ich ako

int tempcr = 0, tempdcr = 0;

Nemá zmysel pokračovať iterácie slučkou, ak je už známe, že pole je neusporiadane, pretože je to neefektívne.

Navyše funkcia má logickú chybu.

Zvážte pole { 0, 0, -1 }

V tomto prípade v prvej iterácii slučky premennej tempcr bude zvýšená, ak vyhlásenie

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

Ale v druhej iterácii slučky premennej tempdcr bude zvýšená.

Takže funkcia sa správa, že pole je netriedený keď je to zoradené v zostupnom poradí.

Ja by som definovať funkciu nasledujúcim spôsobom

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 );
}

Ak prešiel pole má všetky prvky rovnaké navzájom potom funkcia sa domnieva, ako sú zoradené v zostupnom poradí.

Ako povedal @chux - Uviesť Monica v jeho odpoveď namiesto počítania prvky môžete použiť príslušné premenné ako boolean objekty. V tomto prípade funkcia môže vyzerať,

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 );
}