下面是一个使用C++实现快速排序的示例代码，以及其时间和空间复杂度分析。

C++实现代码：

#include <iostream>
using namespace std;

// 快速排序的划分函数
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++; // 递增较小元素的索引
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return i + 1; // 返回枢轴的正确位置
}

// 快速排序的递归函数
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high); // 枢轴的索引

        quickSort(arr, low, pi - 1); // 对枢轴左侧子数组递归排序
        quickSort(arr, pi + 1, high); // 对枢轴右侧子数组递归排序
    }
}

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

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quickSort(arr, 0, n - 1);
    cout << "排序后的数组: \n";
    printArray(arr, n);
    return 0;
}

时间复杂度分析：

1. 最坏情况时间复杂度：
   快速排序的最坏情况发生在每次选择的枢轴是数组中的最大或最小元素，这使得划分不平衡。在这种情况下，时间复杂度为 (O(n^2))，因为每次递归只会减少一个元素。

2. 平均时间复杂度：
   平均情况下，快速排序的表现非常好。每次划分大约将数组分成两半，因此总的递归深度为 ( log n )，每一层递归中我们需要线性遍历数组。因此平均时间复杂度为 (O(n log n))。

3. 最好情况时间复杂度：
   在最理想的情况下，每次划分的枢轴将数组平均地分成两半，这与平均情况类似，因此最好情况时间复杂度也是 (O(n log n))。

空间复杂度分析：

1. 原地排序：
   快速排序是一种原地排序算法，除了递归栈外，不需要额外的数组存储空间，因此其辅助空间复杂度主要来源于递归调用栈。

2. 空间复杂度：
   在平均和最好情况下，递归的深度为 (O(log n))，因此空间复杂度为(O(log n))。但是在最坏情况下，递归深度可以达到 (O(n))，因此最坏情况下的空间复杂度为 (O(n))。

• 平均时间复杂度：(O(n log n))
• 最坏情况时间复杂度：(O(n^2))
• 最好情况时间复杂度：(O(n log n))
• 平均空间复杂度：(O(log n))