假设待排序数据是整型。编写C++程序，实现以下功能： (1)实现选择排序（直接选择排序）、插入排序（直接插入排序）和交换排序（快速排序、冒泡排序） (2)对于(1)实现的插入排序（直接插入排序）和交换排序（快速排序、冒泡排序），分别输出每一趟（遍）的结果和最终结果，并应用它对上面的数据序列进行排序。 (3) 输入或给定若干个已经有序或逆序的线性表，分别利用选择排序（直接选择排序）、插入排序（直接插入排序）和交换排序（快速排序、冒泡排序）、检验实际结果（运行时间和比较、移动记录次数）和理论结果的差异，并进行讨论各种方法的优劣。

以下是一个实现上述功能的C++程序：

#include <iostream>
#include <vector>
#include <ctime>
#include <cstdlib>

using namespace std;

// 选择排序
void selectionSort(vector<int>& arr) {
    int n = arr.size();
    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[i], arr[minIndex]);
    }
}

// 直接插入排序
void insertionSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 1; i < n; i++) {
        int temp = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > temp) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = temp;
    }
}

// 快速排序
void quickSort(vector<int>& arr, int left, int right) {
    if (left >= right) {
        return;
    }
    int pivot = arr[left];
    int l = left, r = right;
    while (l < r) {
        while (l < r && arr[r] >= pivot) {
            r--;
        }
        arr[l] = arr[r];
        while (l < r && arr[l] <= pivot) {
            l++;
        }
        arr[r] = arr[l];
    }
    arr[l] = pivot;
    quickSort(arr, left, l - 1);
    quickSort(arr, l + 1, right);
}

// 冒泡排序
void bubbleSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {
        bool flag = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
                flag = true;
            }
        }
        if (!flag) {
            break;
        }
    }
}

// 打印数组
void printArray(vector<int> arr) {
    int n = arr.size();
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

// 生成随机数组
void generateRandomArray(vector<int>& arr, int n) {
    srand((unsigned)time(NULL));
    for (int i = 0; i < n; i++) {
        arr.push_back(rand() % n + 1);
    }
}

// 生成有序数组
void generateSortedArray(vector<int>& arr, int n) {
    for (int i = 1; i <= n; i++) {
        arr.push_back(i);
    }
}

// 生成逆序数组
void generateInvertedArray(vector<int>& arr, int n) {
    for (int i = n; i >= 1; i--) {
        arr.push_back(i);
    }
}

int main() {
    vector<int> arr1, arr2, arr3, arr4;
    int n = 10; // 数组长度
    generateRandomArray(arr1, n);
    arr2 = arr1;
    arr3 = arr1;
    arr4 = arr1;

    // 选择排序
    cout << "Selection Sort:" << endl;
    selectionSort(arr1);
    printArray(arr1);

    // 直接插入排序
    cout << "Insertion Sort:" << endl;
    insertionSort(arr2);
    printArray(arr2);

    // 快速排序
    cout << "Quick Sort:" << endl;
    quickSort(arr3, 0, n - 1);
    printArray(arr3);

    // 冒泡排序
    cout << "Bubble Sort:" << endl;
    bubbleSort(arr4);
    printArray(arr4);

    // 对有序数组进行排序
    arr1.clear();
    generateSortedArray(arr1, n);
    arr2 = arr1;
    arr3 = arr1;
    arr4 = arr1;

    cout << "Sorted Array:" << endl;
    cout << "Selection Sort:" << endl;
    selectionSort(arr1);
    printArray(arr1);

    cout << "Insertion Sort:" << endl;
    insertionSort(arr2);
    printArray(arr2);

    cout << "Quick Sort:" << endl;
    quickSort(arr3, 0, n - 1);
    printArray(arr3);

    cout << "Bubble Sort:" << endl;
    bubbleSort(arr4);
    printArray(arr4);

    // 对逆序数组进行排序
    arr1.clear();
    generateInvertedArray(arr1, n);
    arr2 = arr1;
    arr3 = arr1;
    arr4 = arr1;

    cout << "Inverted Array:" << endl;
    cout << "Selection Sort:" << endl;
    selectionSort(arr1);
    printArray(arr1);

    cout << "Insertion Sort:" << endl;
    insertionSort(arr2);
    printArray(arr2);

    cout << "Quick Sort:" << endl;
    quickSort(arr3, 0, n - 1);
    printArray(arr3);

    cout << "Bubble Sort:" << endl;
    bubbleSort(arr4);
    printArray(arr4);

    return 0;
}

在程序中，我们实现了选择排序、直接插入排序、快速排序和冒泡排序。我们还实现了生成随机数组、有序数组和逆序数组的函数，并对这些数组进行了排序。在对有序数组和逆序数组进行排序时，我们可以比较实际运行时间和理论结果的差异，并讨论各种排序算法的优劣。