需要检查数组是否使用 C 中的函数排序

Question

基本上，我们需要检查一维数组的元素是否使用函数排序： 如果它们按升序排序：返回 1 如果它们按降序排序：返回 -1 如果它们没有排序：返回 0 这是我正在使用的方法，但是它不返回 1 而是返回 0，我不确定问题出在哪里，欢迎任何 cmet 或解决问题的新方法，因为我是初学者。

int Is_Sorted(int* A, int n){
    int tempcr, tempdcr;

for (int i=0; i<N-1; i++){

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

}

Answer 1

错误的逻辑

OP 的代码由于

而失败

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

---

替代方法：

有四种可能

• 数组在每个位置 - 或长度为 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个：test i，is less，is more em> 以上代码。

首先从头到尾寻找不等式。第一个元素被调整为与最后一个元素不同。

如果我们遍历整个列表，我们就完成了，否则列表的第一部分与最后一个元素不同。

如果最后一个比较是升序，则将第一个元素设置为 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次测试。

Answer 2

对于初学者来说，函数应该像这样声明

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

至少第一个参数应该有限定符const，因为传递的数组在函数内没有改变。

变量tempcr 和tempdcr 未初始化并且具有不确定的值。因此该函数具有未定义的行为。你必须像这样初始化它们

int tempcr = 0, tempdcr = 0;

如果已经知道数组是未排序的，那么继续循环的迭代是没有意义的，因为它效率低。

此外，该函数有一个逻辑错误。

考虑数组{ 0, 0, -1 }

在这种情况下，在循环的第一次迭代中，变量 tempcr 将由于 if 语句而增加

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 - Reinstate Monica 在他的回答中指出的那样，您可以将相应的变量用作布尔对象，而不是计算元素。在这种情况下，函数看起来像

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