.编写一函数实现对起始地址是a,长度是n的整型数组从小到大排序

以下是一个简单的冒泡排序实现：

void sort(int *a, int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (a[j] > a[j + 1]) {
                int tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;
            }
        }
    }
}

调用方式如下：

int a[] = {3, 1, 4, 2, 5};
int n = 5;
sort(a, n);

这样就可以将数组a从小到大排序了。

相关问题

.编写一函数实现对起始地址是a,长度是n的整型数组从小到大排序。函数原型为：void sort(int *a, int n);

好的，以下是实现代码：

void sort(int *a, int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (a[i] > a[j]) {
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
    }
}

这里使用了冒泡排序的方法，时间复杂度为O(n^2)，不过对于小数组而言，效率是可以接受的。

编写一函数实现对起始地址是a,长度是n的整型数组从小到大排序。

下面是一个简单的选择排序的实现：

void sort(int *a, int n) {
    int i, j, min_idx;
    for (i = 0; i < n-1; i++) {
        min_idx = i;
        for (j = i+1; j < n; j++) {
            if (a[j] < a[min_idx]) {
                min_idx = j;
            }
        }
        int temp = a[i];
        a[i] = a[min_idx];
        a[min_idx] = temp;
    }
}

其中，变量`min_idx`表示当前未排序部分中最小元素的下标。在每一轮循环中，找到未排序部分的最小元素，将其与未排序部分的第一个元素交换。循环结束后，数组就被排序了。可以通过调用该函数来对任意整型数组进行排序。

注意：该实现并不是最优的排序算法，时间复杂度为O(n^2)，在实际应用中可能会有更好的排序算法选择。