की जरूरत है अगर जाँच करने के लिए सरणी सॉर्ट किया जाता है का उपयोग कर एक समारोह में सी

गलत तर्क

सेशन के कोड के कारण विफल रहता है

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

होना चाहिए

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

जब इस मामले पर विचार A[i]==A[i+1], दोनों काउंटर वेतन वृद्धि चाहिए.

जंक मूल्यों

लापता आरंभीकरण @kaylum.

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

वैकल्पिक दृष्टिकोण:

वहाँ रहे हैं 4 संभावनाओं

• सरणी है एक ही मूल्य मूल्य हर जगह है - या की लंबाई 0 है ।

• सरणी है आरोही. A[i] >= A[i-1] सभी के लिए i > 0 और लंबाई की तुलना में अधिक है 0.

• सरणी उतरते है. A[i] <= A[i-1] सभी के लिए i > 0 और लंबाई की तुलना में अधिक है 0.

• ऊपर से कोई भी.

बस पाश को समायोजित करने और दो झंडे है. int tempcr, tempdcr; काउंटरों की जरूरत नहीं है ।

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

सरलीकरण और कुछ सूक्ष्म अनुकूलन संभव है, लेकिन कुछ स्पष्ट करने के लिए एक स्पष्ट दृष्टिकोण है.

बहुत अधिक मज़ा है ।

अगर int a[] स्थिर नहीं है, हम कर सकते हैं केवल का उपयोग करें 1 परीक्षण के अनुसार चलना की बजाय 3: परीक्षण मैं, कम है, है और अधिक से ऊपर के कोड.

पहली बार देखने के लिए असमानता अंत से शुरुआत की ओर. पहला तत्व है समायोजित किया जा करने के लिए पिछले से अलग.

अगर हम चलते पूरी सूची है, हम कर रहे हैं, अन्यथा पहले भाग की सूची से अलग है पिछले तत्व है ।

अगर पिछले की तुलना में है, आरोही सेट में पहला तत्व के लिए INT_MAX और खोज की ओर शुरुआत के लिए एक गैर-आरोही जोड़ी.

अन्यथा
अगर पिछले की तुलना में उतरते है, सेट में पहला तत्व के लिए INT_MIN और खोज की ओर शुरुआत के लिए एक गैर-उतरते ।

खोजने पर एक की तुलना में विफलता उत्पन्न होती है, या तो सरणी अव्यवस्थित है या हम शुरुआत में कर रहे हैं. यदि शुरुआत में, कि एक विशेष मामला है ।

किसी भी मामले में, केवल 1 की तुलना के अनुसार चलना ।

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

मैं कुछ और परीक्षण के बाद.

यदि सरणी है constकी जरूरत है , 2 परीक्षण पाश प्रति.

शुरुआत के लिए समारोह में घोषित किया जाना चाहिए की तरह

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

है कि कम से कम पहली पैरामीटर होना चाहिए क्वालीफायर const क्योंकि सरणी पारित कर दिया है नहीं बदला जा रहा है के भीतर समारोह के साथ ।

चर tempcr और tempdcr थे नहीं initialized है और दुविधा में पड़ा हुआ मूल्यों. तो समारोह अपरिभाषित है व्यवहार. आप प्रारंभ करने के लिए की तरह उन्हें

int tempcr = 0, tempdcr = 0;

वहाँ कोई मतलब नहीं है, जारी रखने के लिए पुनरावृत्तियों की पाश है, तो यह पहले से ही जाना जाता है कि सरणी है unsorted क्योंकि यह अक्षम है ।

इसके अलावा समारोह में एक तार्किक बग.

पर विचार सरणी { 0, 0, -1 }

इस मामले में पाश की पहली यात्रा चर tempcr बढ़ जाएगा के कारण यदि बयान

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

लेकिन दूसरी यात्रा में पाश चर tempdcr में वृद्धि की जाएगी ।

तो समारोह को रिपोर्ट करेंगे कि सरणी है unsorted हालांकि यह हल है अवरोही क्रम में.

मैं इस समारोह में परिभाषित निम्न प्रकार है

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

यदि पारित सरणी में सभी तत्वों के बराबर एक दूसरे के समारोह के रूप में मानता है में क्रमबद्ध आरोही क्रम में.

के रूप में की ओर इशारा @chux - बहाल मोनिका में अपने जवाब के बजाय गिनती तत्वों का उपयोग कर सकते हैं इसी चर के रूप में बूलियन वस्तुओं. इस मामले में समारोह की तरह लग सकते हैं

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