编写一个函数 is_sorted(arr)，接收一个整数数组作为参数，返回该数组是否为递增的（即每 个元素都比前一个大或相等）。

编写一个名为 `is_sorted` 的函数，其功能是检查给定的整数数组 arr 是否按升序排列。这个函数可以遍历数组，比较相邻元素，如果发现有任意一对元素 a[i] < a[i+1] 不满足递增条件，则返回 False，表示数组不是递增的；如果整个数组遍历完毕都没有找到违反递增的情况，那么返回 True，表示数组是有序的。

下面是一个 Python 函数的示例实现：

def is_sorted(arr):
    for i in range(len(arr) - 1): # 遍历除最后一个元素外的所有元素
        if arr[i] > arr[i + 1]: # 如果当前元素大于下一个元素
            return False # 直接返回False，表示不是递增序列
    return True # 如果循环结束都没有返回，说明是递增的

# 使用示例
arr1 = [1, 2, 3, 4, 5]
print(is_sorted(arr1))  # 输出: True

arr2 = [1, 3, 2, 4, 5]
print(is_sorted(arr2))  # 输出: False

相关问题

两个递增有序的数组合并另一个数组用C语言做

如果要合并3个或多个递增有序的数组，可以使用归并排序的思想。具体步骤如下：

1. 定义一个新的数组result，用于存放合并后的结果；
2. 将第一个数组和第二个数组合并成一个新的数组temp，即调用前面已经实现的合并两个有序数组的函数merge_sorted_arrays()；
3. 将temp数组和第三个数组合并成一个新的数组temp2，即再次调用merge_sorted_arrays()函数，将合并后的结果存放到temp2中；
4. 重复步骤3，直到所有数组都被合并到temp2中；
5. 将temp2数组中的元素拷贝到result数组中；
6. 返回result数组。

以下是C语言实现代码：

#include <stdio.h>

int* merge_sorted_arrays(int arr1[], int arr2[], int m, int n) {
    int i = 0, j = 0, k = 0;
    int* result = (int*)malloc((m + n) * sizeof(int));

    while (i < m && j < n) {
        if (arr1[i] <= arr2[j]) {
            result[k] = arr1[i];
            i++;
        } else {
            result[k] = arr2[j];
            j++;
        }
        k++;
    }

    while (i < m) {
        result[k] = arr1[i];
        i++;
        k++;
    }

    while (j < n) {
        result[k] = arr2[j];
        j++;
        k++;
    }

    return result;
}

int* merge_sorted_arrays_multiple(int* arrays[], int n, int lengths[]) {
    int* temp = NULL;
    int temp_length = 0;

    for (int i = 0; i < n; i++) {
        temp = merge_sorted_arrays(temp, arrays[i], temp_length, lengths[i]);
        temp_length += lengths[i];
    }

    int* result = (int*)malloc(temp_length * sizeof(int));
    memcpy(result, temp, temp_length * sizeof(int));
    free(temp);
    return result;
}

int main() {
    int arr1[] = {1, 3, 5, 7, 9};
    int arr2[] = {2, 4, 6, 8, 10};
    int arr3[] = {11, 13, 15, 17, 19};
    int* arrays[] = {arr1, arr2, arr3};
    int lengths[] = {5, 5, 5};
    int n = sizeof(arrays) / sizeof(arrays[0]);
    int* result = merge_sorted_arrays_multiple(arrays, n, lengths);

    for (int i = 0; i < n * 5; i++) {
        printf("%d ", result[i]);
    }

    free(result);
    return 0;
}

注意，以上实现假设所有输入数组已经是递增有序的。如果不是，则需要在合并前先对它们进行排序。另外，需要记得在函数结束时释放动态分配的数组空间，避免内存泄漏。

编写一个程序来检查给定的数组是否已经按递增顺序排序

以下是一个 Python 代码示例，用于检查给定的数组是否已按递增顺序排序：

def is_sorted(arr):
    n = len(arr)
    for i in range(1, n):
        if arr[i] < arr[i-1]:
            return False
    return True

该函数接受一个数组 `arr`，并遍历数组中的每个元素。如果当前元素小于前一个元素，则返回 False。如果整个数组都被遍历完了且没有返回 False，则说明数组已经按递增顺序排序，返回 True。

可以通过以下方式使用该函数：

arr = [1, 2, 3, 4, 5]
if is_sorted(arr):
    print("The array is sorted.")
else:
    print("The array is not sorted.")

输出结果应该是：

The array is sorted.

如果数组不是按递增顺序排序，则输出结果应该是：

The array is not sorted.