【1】冒泡排序算法

冒泡排序是一种简单的排序算法，其基本思想是通过相邻两个元素之间的比较和交换，将较大的元素逐步向数组末尾冒泡。

具体来说，冒泡排序的过程是这样的：对于长度为n的数组a，首先比较a[0]和a[1]，如果a[0]>a[1]，则交换它们的位置，否则不动；接着比较a[1]和a[2]，如果a[1]>a[2]，则交换它们的位置，否则不动；依此类推，直到比较a[n-2]和a[n-1]为止。这样一次比较和交换过程可以将数组中的最大元素移动到最后一个位置。

然后，我们再对前n-1个元素重复上述过程，但这次只需要比较前n-1个元素，因为第n个元素已经是最大的了。依此类推，直到所有元素都排好序为止。

下面是一个使用C++语言实现冒泡排序的代码：

#include <iostream>
using namespace std;

void bubbleSort(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 temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

int main() {
    int a[] = {64, 25, 12, 22, 11};
    int n = sizeof(a) / sizeof(a[0]);
    bubbleSort(a, n);
    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

在这个代码中，我们定义了一个名为bubbleSort的函数，它接受两个参数：一个整数数组a和数组的长度n。函数中嵌套了两个for循环，第一个for循环用于控制比较和交换的轮数，第二个for循环用于进行实际的比较和交换操作。

在main函数中，我们定义了一个整数数组a，并初始化了它的值。然后，我们计算出数组的长度，并将数组和长度传递给bubbleSort函数进行排序。最后，我们打印出排好序的数组。

能够动态地输出每一轮排序后的数组结果的C++代码：

#include <iostream>
using namespace std;

void bubbleSort(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 temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
        cout << "Pass " << i+1 << ": ";
        for (int k = 0; k < n; k++) {
            cout << a[k] << " ";
        }
        cout << endl;
    }
}

int main() {
    int a[] = {64, 25, 12, 22, 11};
    int n = sizeof(a) / sizeof(a[0]);
    
    cout << "Original array: ";
    for (int i = 0; i < n; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    
    bubbleSort(a, n);
    
    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    
    return 0;
}

Original array: 64 25 12 22 11 
Pass 1: 25 12 22 11 64 
Pass 2: 12 22 11 25 64 
Pass 3: 12 11 22 25 64 
Pass 4: 11 12 22 25 64 
Sorted array: 11 12 22 25 64

可以看到，在每一次比较和交换操作之后，我们输出了当前数组的状态。首先，原始的数组是64 25 12 22 11，然后第一轮排序将最大的元素64移到了数组的最后一个位置，变成了25 12 22 11 64；第二轮排序将次大的元素25移到了倒数第二个位置，变成了12 22 11 25 64；依此类推，直到最后数组完全排好序为止，变成了11 12 22 25 64。