用C++语言至少设计出（冒泡排序、快速排序和归并排序）的递归和非递归排序算法；对数组中的89，98，67，45，37，83，90数据进行排序(按从小到大的顺序排序)，给出完整代码

首先，我会分别介绍这三个排序算法的非递归和递归版本，并提供如何使用它们对给定数组进行排序的示例。

**1. 冒泡排序（非递归）**

#include <iostream>
void bubbleSort(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]) {
                std::swap(arr[j], arr[j + 1]);
            }
        }
    }
}

// 排序后的数组示例
int data[] = {89, 98, 67, 45, 37, 83, 90};
int size = sizeof(data) / sizeof(data[0]);
bubbleSort(data, size);
for (int i : data) {
    std::cout << i << " ";
}

**2. 冒泡排序（递归）**
由于冒泡排序不适合直接递归实现，这里我们提供一个简单的示例，展示如何使用类似的思想将大元素“冒泡”到最后：

void bubbleSortRecursive(int arr[], int start, int end) {
    if (start >= end) return;
    // 交换如果需要
    if (arr[start] > arr[end]) {
        std::swap(arr[start], arr[end]);
    }
    // 递归处理剩余部分
    bubbleSortRecursive(arr, start + 1, end - 1);
}

bubbleSortRecursive(data, 0, size - 1);

**3. 快速排序（非递归）**

void quickSort(int arr[], int left, int right) {
    if (left < right) {
        int pivotIndex = partition(arr, left, right);
        quickSort(arr, left, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, right);
    }
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[i + 1], arr[high]);
    return i + 1;
}

quickSort(data, 0, size - 1);

**4. 快速排序（递归）**
快速排序通常通过分治法实现，递归版的代码结构相似：

void quickSortRecursive(int arr[], int low, int high) {
    if (low < high) {
        int pivotIndex = partition(arr, low, high);
        quickSortRecursive(arr, low, pivotIndex - 1);
        quickSortRecursive(arr, pivotIndex + 1, high);
    }
}

quickSortRecursive(data, 0, size - 1);

**5. 归并排序（非递归）**

void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int mid = l + (r - l) / 2;
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }
}

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;

    int L[n1], R[n2];

    for (int i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[m + 1+ j];

    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j])
            arr[k++] = L[i++];
        else
            arr[k++] = R[j++];
    }

    while (i < n1)
        arr[k++] = L[i++];

    while (j < n2)
        arr[k++] = R[j++];
}

mergeSort(data, 0, size - 1);

以上代码都是针对数组`data`进行操作的示例。注意，对于实际项目，可能需要添加错误检查和边界条件处理。