写一个函数,用冒泡法对数组中的整数按由小到大的顺序排序,并在主函数中调用它,对任意长度整型数组进行排序。2 5 78 98 36 47 24 8 19 56
时间: 2023-04-25 12:04:22 浏览: 73
以下是用冒泡法对整型数组按由小到大排序的函数:
```python
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
return arr
```
在主函数中调用该函数,对任意长度的整型数组进行排序:
```python
arr = [2, 5, 78, 98, 36, 47, 24, 8, 19, 56]
sorted_arr = bubble_sort(arr)
print(sorted_arr)
```
输出结果为:[2, 5, 8, 19, 24, 36, 47, 56, 78, 98]
相关问题
用c++用选择法对数组中10个整数按由小到大排序,要求使用函数调用
以下是使用选择排序对数组按由小到大排序的C代码,其中使用了函数调用:
```
#include <stdio.h>
void selectionSort(int arr[], int n);
void swap(int *a, int *b);
int main() {
int arr[10] = {5, 3, 9, 1, 7, 2, 8, 4, 10, 6};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Before sorting: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
selectionSort(arr, n);
printf("\nAfter sorting: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
void selectionSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
swap(&arr[minIndex], &arr[i]);
}
}
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
```
输出:
```
Before sorting: 5 3 9 1 7 2 8 4 10 6
After sorting: 1 2 3 4 5 6 7 8 9 10
```
写一个 “冒泡法”函数,在主函数中由键盘输入10个数存入数组,调用函数对数组中的数据进行排序后按从小到大的次序输出。 程序如下:
下面是一个使用冒泡排序法对数组进行排序的示例代码:
```c
#include <stdio.h>
void bubble_sort(int arr[], int n)
{
int i, j;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
int main()
{
int arr[10];
int i;
printf("Please enter 10 numbers:\n");
for (i = 0; i < 10; i++) {
scanf("%d", &arr[i]);
}
bubble_sort(arr, 10);
printf("Sorted array in ascending order:\n");
for (i = 0; i < 10; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
```
在这个示例程序中,我们首先定义了一个 `bubble_sort` 函数来实现冒泡排序法。该函数接受两个参数:一个整数数组和该数组的长度。它使用嵌套的循环来交换相邻的元素,直到整个数组都被排序。
在主函数中,我们先从键盘读入10个数存入数组,然后调用 `bubble_sort` 函数对数组进行排序。最后,我们按从小到大顺序输出排序后的数组。