Besoin de vérifier si le tableau est trié en utilisant une fonction en C

Fausse logique

OP du code échoue en raison de

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

devrait être

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

Considérer le cas où A[i]==A[i+1], les deux compteurs doit augmenter.

Junk Valeurs

Manquant d'initialisation @kaylum.

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

Autre approche:

Il y a 4 possibilités

• Tableau a la même valeur en tous lieux - ou est de longueur 0.

• Tableau est croissant. A[i] >= A[i-1] pour tous i > 0 et la longueur est de plus de 0.

• Tableau est décroissant. A[i] <= A[i-1] pour tous i > 0 et la longueur est de plus de 0.

• Aucun de ceux-ci.

Tout simplement en boucle et d'ajuster les deux drapeaux. int tempcr, tempdcr; les compteurs ne sont pas nécessaires.

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

Simplifications et certains micro-optimisation possible, mais quelque chose de clarifier une approche claire.

Trop de plaisir.

Si int a[] n'est pas constante, nous ne pouvons utiliser 1 test par itération au lieu de 3: test que j'ai, est de moins en moins, est plus le code ci-dessus.

Tout d'abord l'inégalité de la fin vers le début. Le premier élément est ajusté pour être différente de la dernière.

Si nous marchons toute la liste, nous fait, sinon la première partie de la liste diffère du dernier élément.

Si la dernière comparer est croissant, définissez le premier élément de INT_MAX et de la recherche vers le début, pour un non-croissant paire.

Autrement
Si la dernière comparaison est décroissant, définissez le premier élément de INT_MIN et de la recherche vers le début, pour un non-décroissant paire.

Lors de la découverte d'un comparer échec se produit, le tableau n'est pas ordonné ou nous en sommes qu'au début. Si, au début, de gérer ce cas particulier.

Dans tous les cas, seulement 1 comparer par itération.

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

Je vais faire des tests un peu plus tard.

Si le tableau est const, besoin de 2 test par boucle.

Pour commencer, la fonction doit être déclarée comme

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

c'est au moins le premier paramètre doit avoir la qualification const parce que le tableau transmis n'est pas changé à l'intérieur de la fonction.

Les variables tempcr et tempdcr n'ont pas été initialisée et indéterminé valeurs. Donc la fonction a un comportement indéfini. Vous devez les initialiser comme

int tempcr = 0, tempdcr = 0;

Il n'y a pas de sens de continuer les itérations de la boucle si il est déjà connu que le tableau est trié, car il est inefficace.

En outre, la fonction a une logique de bug.

Considérons la matrice { 0, 0, -1 }

Dans ce cas, dans la première itération de la boucle, la variable tempcr sera augmenté en raison de l'instruction if

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

Mais dans la deuxième itération de la boucle, la variable tempdcr sera augmenté.

De sorte que la fonction de rapport que le tableau est trié si elle est triée dans l'ordre décroissant.

Je voudrais définir la fonction de la façon suivante

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

Si le tableau transmis a tous les éléments égaux les uns aux autres alors la fonction de juge triée dans l'ordre croissant.

Comme l'a indiqué @chux - Rétablir Monica dans sa réponse au lieu de compter les éléments que vous pouvez utiliser les variables correspondantes comme objet boolean. Dans ce cas, la fonction peut ressembler à

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