算法复杂度分析

1、时间复杂度

按照复杂度从低到高以此列出。

1.1常数时间 (O(1))

无论数据量多大，算法的运行时间都保持不变。

#include <iostream>

int main() {
    int array[] = {1, 2, 3, 4, 5};
    // 不管数组大小如何，以下操作的时间复杂度都是O(1)
    std::cout << "The first element is: " << array[0] << std::endl;
    return 0;
}

1.2对数时间 (O(log n))

算法的运行时间与数据量的对数增幅相关，经典例子是二分搜索。

#include <iostream>

// 二分查找是典型的O(log n)时间复杂度算法
int binarySearch(int arr[], int l, int r, int x) {
    while (l <= r) {
        int m = l + (r - l) / 2;

        // 如果x正好在中间
        if (arr[m] == x)
            return m;

        // 如果x大于中位数，则只能在右半边
        if (arr[m] < x)
            l = m + 1;
        else
            r = m - 1;
    }
    
    // 元素不存在
    return -1;
}

int main() {
    int array[] = {2, 3, 4, 10, 40};
    int n = sizeof(array) / sizeof(array[0]);
    int x = 10;
    int result = binarySearch(array, 0, n-1, x);
    (result == -1)
        ? std::cout << "Element is not present in array"
        : std::cout << "Element is present at index " << result;
    return 0;
}

1.3线性时间 (O(n))

算法的运行时间与数据量呈线性关系，如for循环单次遍历一个列表。

#include <iostream>

// 线性搜索是O(n)时间复杂度的例子
int linearSearch(int arr[], int n, int x) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == x) {
            return i;
        }
    }
    return -1;
}

int main() {
    int array[] = {1, 2, 3, 4, 5};
    int x = 3;
    int n = sizeof(array) / sizeof(array[0]);
    int result = linearSearch(array, n, x);
    (result == -1)
        ? std::cout << "Element not found"
        : std::cout << "Element found at position: " << result;
    return 0;
}

1.4线性对数时间 (O(n log n))

算法运行时间与数据量的线性乘以对数成正比，常见于一些高效的排序算法，如快速排序和归并排序。

#include <iostream>
#include <algorithm>

// 快速排序是O(n log n)时间复杂度的例子
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        // pi is partitioning index, arr[p] is now at right place
        int pi = partition(arr, low, high);

        // 递归地分别对划分左右两部分进行排序
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main() {
    int array[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(array) / sizeof(array[0]);
    quickSort(array, 0, n - 1);
    std::cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        std::cout << array[i

1.5二次时间 (O(n^2))

算法运行时间与数据量的平方成正比，双层for循环，例如简单的排序算法（冒泡排序）、双重遍历列表。

#include <iostream>
using namespace std;

void printPairs(int arr[], int n) {
    for (int i = 0; i < n; i++) {         // 外层循环 O(n)
        for (int j = 0; j < n; j++) {     // 内层循环 O(n)
            cout << "(" << arr[i] << ", " << arr[j] << ")" << endl;
        }
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr)/sizeof(arr[0]);
    printPairs(arr, n);
    return 0;
}

1.6 立方时间 (O(n^3))

算法的运行时间与数据量的立方成正比，这在某些图问题或矩阵乘法中可以看到。

#include <iostream>
using namespace std;

void printTriplets(int arr[], int n) {
    for (int i = 0; i < n; i++) {         // 第一层循环 O(n)
        for (int j = 0; j < n; j++) {     // 第二层循环 O(n)
            for (int k = 0; k < n; k++) { // 第三层循环 O(n)
                cout << "(" << arr[i] << ", " << arr[j] << ", " << arr[k] << ")" << endl;
            }
        }
    }
}

int main() {
    int arr[] = {1, 2, 3};
    int n = sizeof(arr)/sizeof(arr[0]);
    printTriplets(arr, n);
    return 0;
}

1.7指数时间 (O(2^n))

算法的运行时间随数据量指数级增长，这在某些递归计算和优化问题中较常见。

#include <iostream>
using namespace std;

int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n - 1) + fibonacci(n - 2); // 每次调用产生两个子调用
}

int main() {
    int n = 10;
    cout << "Fibonacci number is " << fibonacci(n) << endl;
    return 0;
}

1.8阶乘时间 (O(n!))

算法运行时间与数据量的阶乘成正比，常见于解决旅行商问题等排列问题。

#include <iostream>
using namespace std;

void permute(string a, int l, int r) {
    if (l == r) {
        cout << a << endl;
    } else {
        for (int i = l; i <= r; i++) {
            swap(a[l], a[i]);             // 交换字符
            permute(a, l+1, r);           // 递归调用
            swap(a[l], a[i]);             // 回溯，还原字符的位置
        }
    }
}

int main() {
    string str = "ABC";
    int n = str.size();
    permute(str, 0, n - 1);
    return 0;
}

2、空间复杂度

2.1 常量空间复杂度（O(1) ）

算法的额外空间不随输入规模的增加而增加，即算法所需的额外空间是固定的。

#include <iostream>
using namespace std;

// 函数示例：打印数组中第一个元素
void printFirstElement(int arr[], int size) {
    if (size > 0) {
        cout << "First element of the array is: " << arr[0] << endl;
    } else {
        cout << "Array is empty." << endl;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]); // 计算数组的大小
    printFirstElement(arr, size);
    return 0;
}

2.2 线性空间复杂度（O(n)）

算法的额外空间随着输入规模的增加线性增长。

#include <iostream>
#include <vector>
using namespace std;

// 函数示例：复制一个整数数组
vector<int> copyArray(int arr[], int size) {
    vector<int> copy(size); // 分配一个大小为 size 的向量
    for (int i = 0; i < size; ++i) {
        copy[i] = arr[i];
    }
    return copy;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]); // 计算数组的大小
    vector<int> copiedArray = copyArray(arr, size);
    cout << "Copied array: ";
    for (int num : copiedArray) {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

示例中，copyArray() 函数创建了一个新的大小与输入数组相同的向量来存储数组的副本。随着输入数组大小的增加，额外空间的需求也线性增加，因此空间复杂度是 O(n)。

2.3 平方空间复杂度（O(n^2)）

额外空间的需求随着输入规模的增加而呈平方级增长。

#include <iostream>
#include <vector>
using namespace std;

// 函数示例：生成一个 n × n 的零矩阵
vector<vector<int>> generateZeroMatrix(int n) {
    vector<vector<int>> matrix(n, vector<int>(n, 0));  //(n, 0)表示生成一个大小为n的一维向量，所有元素都初始化为0。vector<int>(n, 0)表示使用这个大小为n的一维向量初始化每一行，生成n行
    return matrix;
}

int main() {
    int n;
    cout << "Enter the size of the matrix: ";
    cin >> n;
    vector<vector<int>> zeroMatrix = generateZeroMatrix(n);
    cout << "Zero matrix of size " << n << " × " << n << " is generated." << endl;
    return 0;
}

2.4对数空间复杂度(O(log(n))

递归时，递归调用栈的空间复杂度随着问题规模的对数增长。

#include <iostream>
using namespace std;

// 递归函数示例：计算阶乘
int factorial(int n) {
    if (n == 0 || n == 1)
        return 1;
    return n * factorial(n - 1);
}

int main() {
    int n;
    cout << "Enter a number: ";
    cin >> n;
    cout << "Factorial of " << n << " is: " << factorial(n) << endl;
    return 0;
}

factorial() 函数使用递归来计算阶乘。递归调用栈的深度随着输入规模的对数增长，因此空间复杂度是 O(logn)。

2.5线性对数空间复杂度（O(nlogn) ）

通常出现在使用分治算法时，递归调用栈的空间复杂度为线性对数级别。

#include <iostream>
#include <vector>
using namespace std;

// 函数示例：归并排序
void merge(vector<int>& arr, int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    vector<int> L(n1), R(n2);

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

    int i = 0, j = 0, k = left;
    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++];
    }
}

void mergeSort(vector<int>& arr, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge