2. 分别编写函数，用递归及非递归的方式实现冒泡排序算法；然后用一个整数序列测试递归及非递归方式下的执行效率。

### 回答1：
好的，关于你的问题，我可以回答。以下是递归和非递归方式实现冒泡排序算法的代码：

递归方式：

void recursiveBubbleSort(int arr[], int n)
{
    if (n == 1)
        return;

    for (int i=0; i<n-1; i++)
        if (arr[i] > arr[i+1])
            swap(arr[i], arr[i+1]);

    recursiveBubbleSort(arr, n-1);
}

非递归方式：

void iterativeBubbleSort(int arr[], int n)
{
    for (int i=0; i<n-1; i++)
        for (int j=0; j<n-i-1; j++)
            if (arr[j] > arr[j+1])
                swap(arr[j], arr[j+1]);
}

接下来，您可以通过以下代码测试递归和非递归方式下的执行效率，并比较它们：

#include <iostream>
#include <chrono>
using namespace std::chrono;

void testRecursiveBubbleSort(int arr[], int n)
{
    auto start = high_resolution_clock::now();
    recursiveBubbleSort(arr, n);
    auto stop = high_resolution_clock::now();
    auto duration = duration_cast<microseconds>(stop - start);
    std::cout << "Time taken by recursive bubble sort: " << duration.count() << " microseconds" << std::endl;
}

void testIterativeBubbleSort(int arr[], int n)
{
    auto start = high_resolution_clock::now();
    iterativeBubbleSort(arr, n);
    auto stop = high_resolution_clock::now();
    auto duration = duration_cast<microseconds>(stop - start);
    std::cout << "Time taken by iterative bubble sort: " << duration.count() << " microseconds" << std::endl;
}

int main()
{
    int arr[] = {10, 3, 7, 1, 2, 8, 6, 5, 4, 9};
    int n = sizeof(arr)/sizeof(arr[0]);

    testRecursiveBubbleSort(arr, n);
    testIterativeBubbleSort(arr, n);

    return 0;
}

希望这能帮到您，如果您还有其他问题，请随时提出。

### 回答2：
冒泡排序算法是一种简单的排序算法，它重复地遍历要排序的序列，每次比较相邻的两个元素，如果顺序错误就交换它们的位置，直到整个序列有序为止。

首先，我们来实现递归方式的冒泡排序算法。这里我们需要定义一个递归函数bubbleSortRecursive，它的输入是整数序列arr和序列的长度n，返回值是排序后的整数序列。

def bubbleSortRecursive(arr, n):
    if n == 1:  # 如果序列只剩下一个元素，直接返回
        return arr
    for i in range(n-1):
        if arr[i] > arr[i+1]:  # 如果相邻元素顺序错误，交换它们的位置
            arr[i], arr[i+1] = arr[i+1], arr[i]
    return bubbleSortRecursive(arr, n-1)  # 递归调用

# 测试递归方式的冒泡排序算法
arr = [5, 3, 8, 6, 2, 7]
n = len(arr)
sorted_arr = bubbleSortRecursive(arr, n)
print(sorted_arr)

接下来，我们来实现非递归方式的冒泡排序算法。这里我们定义一个函数bubbleSortNonRecursive，它的输入是整数序列arr，并原地修改序列的顺序。

def bubbleSortNonRecursive(arr):
    n = len(arr)
    for i in range(n-1):
        for j in range(n-i-1):
            if arr[j] > arr[j+1]:  # 如果相邻元素顺序错误，交换它们的位置
                arr[j], arr[j+1] = arr[j+1], arr[j]

# 测试非递归方式的冒泡排序算法
arr = [5, 3, 8, 6, 2, 7]
bubbleSortNonRecursive(arr)
print(arr)

最后，我们来对递归方式和非递归方式的冒泡排序算法进行执行效率的测试。我们可以使用Python内置的time模块来实现。

import time

# 测试递归方式的执行效率
start_time = time.process_time()
arr = [5, 3, 8, 6, 2, 7] * 10000
n = len(arr)
sorted_arr = bubbleSortRecursive(arr, n)
end_time = time.process_time()
print("递归方式的执行时间：", end_time - start_time)

# 测试非递归方式的执行效率
start_time = time.process_time()
arr = [5, 3, 8, 6, 2, 7] * 10000
bubbleSortNonRecursive(arr)
end_time = time.process_time()
print("非递归方式的执行时间：", end_time - start_time)

通过比较两种算法的执行时间，我们可以得出它们的执行效率。一般而言，非递归方式的冒泡排序算法通常比递归方式的执行速度更快。

### 回答3：
冒泡排序是一种简单的排序算法，它的基本思想是重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。重复地进行这个过程直到整个序列有序为止。

递归方式实现冒泡排序算法可以通过两种方法进行递归调用。如下所示：

def recursive_bubble_sort(arr, n):
    if n == 1:
        return arr
    for i in range(n-1):
        if arr[i] > arr[i+1]:
            arr[i], arr[i+1] = arr[i+1], arr[i]
    return recursive_bubble_sort(arr, n-1)

非递归方式实现冒泡排序算法则可以通过嵌套的循环实现。如下所示：

def iterative_bubble_sort(arr):
    n = len(arr)
    for i in range(n-1):
        for j in range(n-1-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

为了测试递归和非递归方式下的执行效率，我们可以定义一个包含大量整数的序列进行排序并计算执行时间。如下所示：

import time

arr = [5, 2, 9, 1, 7, 3, 6, 8, 4]

start_time = time.time()
sorted_arr_recursive = recursive_bubble_sort(arr, len(arr))
end_time = time.time()
recursive_execution_time = end_time - start_time

start_time = time.time()
sorted_arr_iterative = iterative_bubble_sort(arr)
end_time = time.time()
iterative_execution_time = end_time - start_time

print("递归方式下的执行时间：", recursive_execution_time)
print("非递归方式下的执行时间：", iterative_execution_time)

这样我们就可以通过比较递归和非递归方式下的执行时间了解它们的效率。