需要检查如果阵列是排序的使用功能在C

错误的逻辑

作社的失败，因为代码

}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 都没有初始化和具有不确定值。 因功能不确定的行为。 你有初始化他们喜欢

int tempcr = 0, tempdcr = 0;

是没有意义继续迭代的循环，如果这已经是众所周知，该阵列的未分类，因为这是效率低下。

而且功能有一个逻辑上的错误。

考虑阵列 { 0, 0, -1 }

在这种情况下在第一次循环迭代变量 tempcr 将增加是由于，如果声明

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

但是，在第二次循环迭代变量 tempdcr 将会增加。

所以功能将报告列为未分类，虽然它是按降序排列。

我将定义的功能以下列方式

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