Trzeba sprawdzić, posortowana czy tablicy za pomocą funkcji w C

Błędna logika

Kod operacji wywala z powodu

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

powinno być

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

Rozważmy przypadek, gdy A[i]==A[i+1]oba licznika powinny rosnąć.

Niepotrzebne Wartości

Brakuje inicjowanie @kaylum.

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

Alternatywne podejście:

Są 4 możliwości

• Tablica ma to samo znaczenie, gdzie lub ma długość 0.

• Tablica rośnie. A[i] >= A[i-1] dla wszystkich i > 0 i długość jest większa niż 0.

• Tablica idzie malejąco. A[i] <= A[i-1] dla wszystkich i > 0 i długość jest większa niż 0.

• Żaden z powyższych.

Po prostu зациклите i ustaw dwie flagi. int tempcr, tempdcr; liczniki nie są potrzebne.

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

Możliwe są pewne uproszczenia i микрооптимизация, ale coś wyjaśni wyraźny podejście.

Zbyt zabawne.

Jeśli int a[] nie jest stały, możemy użyć tylko 1 test na iterację zamiast 3: testy i, mniej, więcej z powyższego kodu.

Najpierw spójrz na nierówności od końca do początku. Pierwszy element jest regulowany tak, aby różnił się on od tego ostatniego.

Jeśli przejdziemy pełna lista skończymy, w przeciwnym razie pierwsza część listy różni się od ostatniego elementu.

Jeśli to ostatnie porównanie jest wykonywane w kolejności rosnącej, zaznacz pierwszy element wartość INT_MAX i szukajcie na początku nie wzrosty na parze.

Inaczej
Jeśli to ostatnie porównanie jest wykonywane malejąco, zaznacz pierwszy element wartość INT_MIN i szukajcie na początku неубывающую parę.

W przypadku wykrycia błędu porównania lub tablica неупорядочен, albo znajdujemy się na początku. Jeśli na początku zapoznaj się z tym szczególnym wydarzeniem.

W każdym razie, tylko 1 porównanie za iterację.

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

Zrobię jeszcze kilka testów później.

Jeśli tablica jest consttrzeba 2 test na cykl.

Na początek funkcja musi być zadeklarowana w następujący sposób

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

czyli, przynajmniej pierwszy parametr musi mieć kwalifikacje const bo przekazany do tablicy nie zmienia się wewnątrz funkcji.

Zmienne tempcr i tempdcr nie były inicjowane i mają wartości nieokreślone. W ten sposób funkcja ma niepewne zachowanie. Musisz zainicjować ich, jak

int tempcr = 0, tempdcr = 0;

Nie ma sensu kontynuować iteracji pętli, jeśli już wiadomo, że tablica несортирован, bo on jest nieskuteczne.

Ponadto, w funkcji jest błąd logiczny.

Rozważmy tablicę { 0, 0, -1 }

W tym przypadku na pierwszej iteracji pętli zmienna tempcr zostanie zwiększona poprzez oświadczenia if

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

Ale na drugiej iteracji pętli zmienna tempdcr zostanie zwiększona.

W ten sposób funkcja informuje, że tablica nie jest posortowana, choć jest posortowana w kolejności malejącej.

Ja bym określił funkcję w następujący sposób

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

Jeśli przekazany tablica zawiera wszystkie elementy równe sobie nawzajem, to funkcja uważa go отсортированным w porządku rosnącym.

Jak wskazał @chux - Przywróć Monice w swojej odpowiedzi, zamiast liczenia elementów można użyć odpowiednie zmienne jako logicznych obiektów. W tym przypadku funkcja może wyglądać tak

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