Precisa verificar se a matriz é classificada usando uma função em C

Lógica errada

OP código de falha devido a

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

deve ser

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

Considere o caso quando A[i]==A[i+1], ambos os contadores devem aumentar.

Lixo Valores

Faltando inicialização @kaylum.

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

Abordagem alternativa:

Existem 4 possibilidades

• Matriz tem o mesmo valor de valor cada de onde ou é de tamanho 0.

• Matriz é crescente. A[i] >= A[i-1] para todos i > 0 e o comprimento é superior a 0.

• Matriz é decrescente. A[i] <= A[i-1] para todos i > 0 e o comprimento é superior a 0.

• Nenhuma das acima.

Simplesmente loop e ajustar duas bandeiras. int tempcr, tempdcr; contadores não são necessárias.

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

Simplificações e alguns micro otimização possível, mas algo para esclarecer de uma abordagem clara.

Muito divertido.

Se int a[] não é constante, podemos usar apenas 1 teste por iteração em vez de 3: teste eu, é menos, é mais do que o código acima.

Primeiro olhar para a desigualdade a partir do final para o início. O primeiro elemento é ajustado para ser diferente do último.

Se nós percorrer a lista inteira, nós somos feitos, caso contrário, a primeira parte da lista difere do último elemento.

Se a última comparação é ascendente, define o primeiro elemento para INT_MAX e de pesquisa para o início de um não-ascendente par.

Caso contrário,
Se a última comparação é decrescente, define o primeiro elemento para INT_MIN e de pesquisa para o início de um não-decrescente, par.

Ao encontrar uma comparação falha ocorre, a matriz é desordenada ou estamos no início. Se, no início, identificador de caso especial.

Em qualquer caso, apenas 1 compare por iteração.

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

Eu vou fazer mais alguns testes posteriores.

Se a matriz é const, precisa de teste 2 por ciclo.

Para começar, a função deve ser declarada como

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

pelo menos, o primeiro parâmetro deve ter o qualificador const porque o passado matriz não está sendo alterado dentro da função.

As variáveis tempcr e tempdcr não foram inicializados e ter indeterminado valores. Então, a função tem um comportamento indefinido. Você tem que inicializar-los como

int tempcr = 0, tempdcr = 0;

Não há sentido continuar iterações do loop se já é sabido que a matriz é não-ordenada, porque é ineficiente.

Além disso, a função tem uma lógica erro.

Considere a matriz { 0, 0, -1 }

Neste caso, na primeira iteração do loop a variável tempcr vai ser aumentado devido a instrução if

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

Mas, na segunda iteração do loop a variável tempdcr vai ser aumentado.

Então, a função irá relatar que a matriz é não-ordenada que é classificada em ordem decrescente.

Gostaria de definir a função da seguinte forma

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

Se o passado matriz tem todos os elementos iguais uns aos outros, então a função de considera-lo como ordenados em ordem crescente.

Como apontado @chux - Restabelecer Mônica, na sua resposta, em vez da contagem de elementos que você pode usar as variáveis correspondentes as boolean objetos. Neste caso, a função pode olhar como

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