3.输入N个正整数，要求输出从小到大排序后的结果。 （分别用选择排序和冒泡排序实现）

### 回答1：
选择排序实现：

#include <stdio.h>

void selectionSort(int arr[], int n) {
int i, j, min_idx;

// One by one move boundary of unsorted subarray
for (i = ; i < n-1; i++) {
// Find the minimum element in unsorted array
min_idx = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;

// Swap the found minimum element with the first element
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}

int main() {
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr)/sizeof(arr[]);
selectionSort(arr, n);
printf("Sorted array: \n");
for (int i=; i < n; i++)
printf("%d ", arr[i]);
return ;
}

冒泡排序实现：

#include <stdio.h>

void bubbleSort(int arr[], int n) {
int i, j;
for (i = ; i < n-1; i++) {
// Last i elements are already in place
for (j = ; 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[] = {64, 25, 12, 22, 11};
int n = sizeof(arr)/sizeof(arr[]);
bubbleSort(arr, n);
printf("Sorted array: \n");
for (int i=; i < n; i++)
printf("%d ", arr[i]);
return ;
}

### 回答2：
选择排序简单实现步骤：

1. 声明一个函数selection_sort，参数为一个整数数组nums。

2. 在函数内部，使用双重循环来实现选择排序的算法。

3. 外层循环从数组的第一个元素开始，依次将其与后面的元素比较。

4. 内层循环从外层循环的下一个元素开始，依次将其与外层循环的元素比较，并找出当前最小的元素。

5. 将找到的最小元素与外层循环的元素进行交换。

6. 继续进行下一轮循环，直至所有元素都按照从小到大的顺序排列。

7. 在主程序中调用selection_sort函数，将需要排序的数组作为参数传入，并输出排序后的结果。

冒泡排序简单实现步骤：

1. 声明一个函数bubble_sort，参数为一个整数数组nums。

2. 在函数内部，使用双重循环来实现冒泡排序的算法。

3. 外层循环从数组的第一个元素开始，依次将其与后面的元素比较。

4. 内层循环从数组的最后一个元素开始，依次将其与前面的元素比较，并不断地将较大的元素向后移动。

5. 继续进行下一轮循环，直至所有元素都按照从小到大的顺序排列。

6. 在主程序中调用bubble_sort函数，将需要排序的数组作为参数传入，并输出排序后的结果。

这两种排序算法的时间复杂度都是O(n^2)，但是选择排序比冒泡排序的交换次数更少，效率稍高一些。

### 回答3：
选择排序是一种简单直观的排序算法。其基本思想是从待排序的数据中选择最小的元素，将其放在已排序序列的末尾。重复以上步骤直到所有元素排序完成。

冒泡排序是一种交换排序算法。其基本思想是从左至右依次比较相邻两个元素的大小，如果前一个元素大于后一个元素，则交换这两个元素。重复以上步骤直到所有元素排序完成。

选择排序的实现过程如下：
1. 从待排序序列中选择最小的元素，将其与序列第一个元素交换位置。
2. 在剩余的序列中选择最小的元素，将其与序列第二个元素交换位置。
3. 重复以上步骤，直到所有元素排序完成。

冒泡排序的实现过程如下：
1. 从待排序序列的第一个元素开始，比较相邻的两个元素的大小，如果前一个元素大于后一个元素，则交换这两个元素。
2. 重复以上步骤，直到所有元素排序完成。

代码示例：
选择排序实现：

def selection_sort(nums):
    n = len(nums)
    for i in range(n-1):
        min_index = i # 假设当前位置为最小元素的索引
        for j in range(i+1, n):
            if nums[j] < nums[min_index]:
                min_index = j # 更新最小元素的索引
        nums[i], nums[min_index] = nums[min_index], nums[i] # 将最小元素与当前位置交换
    return nums

nums = [3, 2, 1, 5, 4]
sorted_nums = selection_sort(nums)
print(sorted_nums)

冒泡排序实现：

def bubble_sort(nums):
    n = len(nums)
    for i in range(n):
        for j in range(n-1-i):
            if nums[j] > nums[j+1]:
                nums[j], nums[j+1] = nums[j+1], nums[j] # 交换相邻元素
    return nums

nums = [3, 2, 1, 5, 4]
sorted_nums = bubble_sort(nums)
print(sorted_nums)

以上是使用Python语言实现的选择排序和冒泡排序的示例，通过选择排序和冒泡排序，我们可以将N个正整数按照从小到大的顺序进行排序。