Nevoie pentru a verifica dacă o matrice este sortate folosind o funcție în C

Greșit logica

OP codul lui eșuează din cauza

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

ar trebui să fie

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

Luați în considerare cazul când A[i]==A[i+1], ambele contoare ar trebui să crească.

Junk Valori

Lipsă de inițializare @kaylum.

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

Abordare alternativă:

Există 4 posibilități

• Matrice are aceeași valoare valoare fiecare de unde - sau este de lungime 0.

• Matrice este ascendentă. A[i] >= A[i-1] pentru toate i > 0 și lungime este mai mare de 0.

• Matrice este descrescătoare. A[i] <= A[i-1] pentru toate i > 0 și lungime este mai mare de 0.

• Nici unul dintre cele de mai sus.

Pur și simplu buclă și ajusta două steaguri. int tempcr, tempdcr; contoare nu sunt necesare.

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

Simplificări și unele micro optimizare posibil, dar ceva pentru a clarifica o abordare clară.

Prea multă distracție.

Dacă int a[] nu este constantă, putem folosi doar 1 test pe iterație în loc de 3: testare eu, este mai puțin, este mai mult de codul de mai sus.

Uite mai întâi pentru inegalitatea de la sfârșitul spre începutul. Primul element este ajustat pentru a fi diferit de trecut.

Dacă am mers pe jos întreaga listă, am terminat-o, de altfel prima parte a listei diferă de la ultimul element.

Dacă ultima compara este ascendentă, setați primul element pentru a INT_MAX si cauta spre începutul pentru un non-ascendent pereche.

Altfel
Dacă ultima compara este descrescătoare, stabilite primul element pentru a INT_MIN si cauta spre începutul pentru un non-descendent pereche.

La găsirea unui compara apare eșecul, fie matrice este neordonate sau suntem la început. Dacă la început, se ocupe de acel caz special.

În orice caz, numai 1 compara pe iterație.

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

Voi face mai multe teste mai târziu.

Dacă matricea este constnevoie de 2 test pe buclă.

Pentru început funcția ar trebui să fie declarate ca

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

care este de cel puțin primul parametru trebuie să aibă calificare const pentru că a trecut matrice nu este schimbat în funcție.

Variabilele tempcr și tempdcr nu au fost inițializate și nedeterminată valori. Deci funcția are comportament nedefinit. Aveți pentru a inițializa le place

int tempcr = 0, tempdcr = 0;

Nu există nici un sens pentru a continua iterații a buclei dacă este deja cunoscut faptul că matricea este nesortate, pentru că este ineficient.

Mai mult decât atât funcția are o eroare logică.

Ia în considerare matrice { 0, 0, -1 }

În acest caz, în prima iterație a buclei variabila tempcr va fi crescut ca urmare a if

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

Dar în cea de-a doua iterație a buclei variabila tempdcr va fi majorat.

Astfel încât funcția va raporta că matricea este nesortate deși este sortate în ordine descrescătoare.

Aș defini funcția felul următor

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

Dacă a trecut matrice are toate elementele egale cu fiecare alte atunci funcția consideră ca sortate în ordine crescătoare.

După cum a arătat @chux - Restabilirea Monica în răspunsul său în loc de numărare elemente, puteți utiliza variabilele corespunzătoare ca boolean obiecte. În acest caz, funcția poate arata ca

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