【力扣 - 时间复杂度和空间复杂度】

力扣刷题时，题目要求里经常有时间复杂度和空间复杂度的要求。那么，什么是时间复杂度和空间复杂度呢？

定义

时间复杂度和空间复杂度都是用于衡量算法性能的指标，但它们分别从不同的角度来评估算法的效率。

1. 时间复杂度：

   • 时间复杂度是衡量算法执行时间随输入规模增长而变化的度量。
   • 它用大O符号（O）来表示，通常用于表示算法执行时间的上限。
   • 时间复杂度描述了随着输入规模增长，算法执行时间的增长趋势。
   • 常见的时间复杂度包括：
     • O(1)：常数时间复杂度，表示算法的执行时间与输入规模无关。
     • O(log n)：对数时间复杂度，表示算法的执行时间随输入规模的对数增长。
     • O(n)：线性时间复杂度，表示算法的执行时间与输入规模成正比。
     • O(n^2)：平方时间复杂度，表示算法的执行时间与输入规模的平方成正比。
     • O(2^n)：指数时间复杂度，表示算法的执行时间随输入规模呈指数增长。

2. 空间复杂度：

   • 空间复杂度是衡量算法执行过程中所需的存储空间大小的度量。
   • 它也用大O符号（O）来表示，通常用于表示算法执行过程中所需的额外空间。
   • 空间复杂度描述了算法所需的额外存储空间随输入规模增长而变化的趋势。
   • 常见的空间复杂度包括：
     • O(1)：常数空间复杂度，表示算法执行过程中所需的额外空间是固定的，与输入规模无关。
     • O(n)：线性空间复杂度，表示算法执行过程中所需的额外空间与输入规模成正比。
     • O(n^2)：平方空间复杂度，表示算法执行过程中所需的额外空间与输入规模的平方成正比。
     • O(log n)：对数空间复杂度，表示算法执行过程中所需的额外空间随输入规模的对数增长。

总的来说，时间复杂度和空间复杂度是评估算法性能的重要指标，它们可以帮助我们了解算法在处理不同规模的数据时的效率和资源消耗情况。
计算时间复杂度和空间复杂度的方法略有不同，但都可以通过分析算法中的基本操作数量来进行评估。

计算时间复杂度的方法：

1. 基本操作计数法：

   • 首先，确定算法中的基本操作，例如赋值、比较、算术运算等。
   • 然后，分析算法中每个基本操作的执行次数，通常使用输入规模（n）表示。
   • 最后，通过分析算法中基本操作的执行次数，得到一个关于输入规模的函数，并且忽略常数因子和低阶项，即得到时间复杂度的表示。

2. 大O表示法：

   • 使用大O符号（O）表示算法的时间复杂度，它表示算法执行时间的增长趋势。
   • 通常，通过找到算法的最差情况时间复杂度来评估算法的性能，因为最差情况下能够给出算法的上界。

计算空间复杂度的方法：

1. 内存分配计算法：
   • 首先，分析算法中使用的数据结构和变量，以及它们所需的内存空间。
   • 然后，通过分析算法中每个变量的大小和数据结构的存储方式，来确定算法所需的额外空间。
   • 最后，得到一个关于输入规模的函数，表示算法所需的额外空间，并使用大O符号表示空间复杂度。

在计算时间复杂度和空间复杂度时，需要考虑算法的最坏情况、平均情况和最好情况。通常情况下，我们主要关注最坏情况下的复杂度，因为它能够给出算法性能的上界，帮助我们了解算法在任何情况下的执行情况。

总的来说，计算时间复杂度和空间复杂度需要对算法中的基本操作数量和内存使用进行深入分析，以便更好地评估算法的性能和资源消耗情况。

示例

下面是一个示例的C语言代码，它实现了一个简单的冒泡排序算法，并对一个整数数组进行排序。我们将对其进行时间复杂度和空间复杂度的分析。

#include 

void bubble_sort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n-1; i++) {
        for (j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, n);
    printf("Sorted array: \n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

时间复杂度分析：

• 冒泡排序算法的时间复杂度取决于数组的大小，假设数组的长度为 n。
• 冒泡排序算法中，嵌套循环会对数组进行多次比较和交换操作。
• 在最坏情况下，冒泡排序算法的时间复杂度是 O(n^2)。这是因为在每一轮循环中，需要比较 n - 1 次，共有 n - 1 轮循环。

空间复杂度分析：

• 冒泡排序算法的空间复杂度主要取决于额外的辅助空间，即用于交换元素的临时变量。
• 在这段代码中，只使用了一个额外的临时变量 temp 来进行元素交换。
• 因此，这段代码的空间复杂度是 O(1)，即常数空间复杂度。

综上所述，这段代码的时间复杂度为 O(n^2)，空间复杂度为 O(1)。

评估

在评估算法的性能时，时间复杂度和空间复杂度都是重要的考量因素，但取决于具体的应用场景和需求。

时间复杂度的重要性：

• 时间复杂度衡量了算法的执行时间随着输入规模增长的趋势，它是衡量算法效率的重要指标之一。
• 在很多情况下，特别是对于需要高效处理大量数据的情况，时间复杂度是首要考虑的因素。例如，对于大型数据库的查询、排序和搜索等操作，时间复杂度的高低直接影响到系统的性能和响应时间。

空间复杂度的重要性：

• 空间复杂度衡量了算法执行过程中所需的额外存储空间大小，它是评估算法对系统资源消耗的重要指标之一。
• 在资源受限的环境下，例如嵌入式系统、移动设备和内存受限的服务器，空间复杂度成为非常重要的考虑因素。过高的空间复杂度可能会导致内存溢出或性能下降。

总体考量：

• 在实际应用中，需要综合考虑时间复杂度和空间复杂度，并且根据具体情况进行权衡和取舍。
• 有时候，可以通过优化算法来降低时间复杂度，但可能会牺牲一定的空间复杂度，或者相反。
• 在不同的应用场景中，可能会更加关注其中一种复杂度。例如，对于实时系统，可能更关注时间复杂度；对于移动应用，可能更关注空间复杂度。

因此，时间复杂度和空间复杂度都是算法评估的重要指标，根据具体需求和环境选择合适的算法设计和优化策略是至关重要的。

以空间换时间

以空间换时间的说法指的是在算法设计中，通过增加额外的存储空间来降低算法的时间复杂度，以提高算法的执行效率。这种策略通常是在空间资源相对充足的情况下进行的。

以下是一个示例的C语言代码，展示了以空间换时间的典型案例之一——使用哈希表来优化查找操作：

#include 
#include 

#define SIZE 1000

// 哈希表结构体
struct HashTable {
    int key;
    int value;
};

// 初始化哈希表
struct HashTable* createHashTable() {
    struct HashTable* hashTable = (struct HashTable*)malloc(SIZE * sizeof(struct HashTable));
    for (int i = 0; i < SIZE; i++) {
        hashTable[i].key = -1;
        hashTable[i].value = -1;
    }
    return hashTable;
}

// 在哈希表中插入键值对
void insert(struct HashTable* hashTable, int key, int value) {
    int index = key % SIZE;
    while (hashTable[index].key != -1) {
        index = (index + 1) % SIZE;
    }
    hashTable[index].key = key;
    hashTable[index].value = value;
}

// 从哈希表中查找键对应的值
int get(struct HashTable* hashTable, int key) {
    int index = key % SIZE;
    while (hashTable[index].key != key && hashTable[index].key != -1) {
        index = (index + 1) % SIZE;
    }
    if (hashTable[index].key == key) {
        return hashTable[index].value;
    } else {
        return -1; // 表示未找到对应的值
    }
}

int main() {
    struct HashTable* hashTable = createHashTable();

    insert(hashTable, 5, 100);
    insert(hashTable, 10, 200);
    insert(hashTable, 15, 300);

    printf("Value for key 5: %d\n", get(hashTable, 5));   // 输出: 100
    printf("Value for key 10: %d\n", get(hashTable, 10)); // 输出: 200
    printf("Value for key 15: %d\n", get(hashTable, 15)); // 输出: 300

    free(hashTable);
    return 0;
}

在这个示例中，我们使用了一个大小为 SIZE 的哈希表来存储键值对。哈希表的大小可以根据实际情况调整。

优点：

• 快速查找：哈希表的查询操作平均时间复杂度为 O(1)，因此查找速度非常快，不受数据量的影响。
• 降低时间复杂度：相比于线性查找，哈希表的使用降低了查找操作的时间复杂度，尤其是在大规模数据的情况下，可以显著提高算法的执行效率。
• 简化算法设计：哈希表的设计简单，插入和查找操作易于实现。

通过增加额外的存储空间，我们在查找操作时实现了较低的时间复杂度，提高了算法的执行效率，这就是以空间换时间的典型案例。