【如何计算一段代码(程序)的空间复杂度】

如何计算一段代码(程序)的空间复杂度

空间复杂度是指程序在运行过程中所占用的内存空间大小。计算空间复杂度时，需要考虑程序本身所占空间、输入数据所占空间以及辅助变量所占空间。

一般通过以下步骤来计算：

1. 找出程序中占用空间的变量和数据结构。
2. 分析这些变量和数据结构的空间大小与输入规模（通常用 n 表示）的关系。
3. 如果是固定大小的变量，如简单的整数、浮点数等，其空间复杂度通常为 O(1)。
4. 如果创建了与输入规模 n 成正比的数组或其他数据结构，空间复杂度通常为 O(n)。
5. 对于嵌套的数据结构或复杂的分配情况，需要更仔细地分析其空间增长与 n 的关系。

例如，在

void BubbleSort(int* a, int n) { 
	assert(a); 
	for (size_t end = n; end > 0; --end) { 
		int exchange = 0; 
		for (size_t i = 1; i < end; ++i) { 
			if (a(i-1) > a(i)) { 
				Swap(&a(i-1), &a(i)); exchange = 1; 
				} 
			} 
		if (exchange ==0) break; 
	} 
}

这段冒泡排序代码中，一共只有 3 个固定大小的变量

size_t end = n;
int exchange = 0;
size_t i = 1;

属于常数阶，其空间复杂度为 O(1)。

又如

long long* Fibonacci(size_t n) { 
	if(n==0) return NULL; 
	long long * fibArray = (long long *)malloc((n+1) * sizeof(long long)); 
	fibArray(0) = 0; 
	fibArray(1) = 1; 
	for (int i = 2; i < = n ; ++i) { 
	fibArray(i) = fibArray(i -1) + fibArray (i - 2);
	} return fibArray; 
}

这段斐波那契数列的代码，新创建了一个数组“fibArray”，用来保存计算出来的斐波那契数，一共 malloc 了 n+1 个长整型的空间，空间复杂度是 O(N)。

总之，计算空间复杂度需要仔细分析代码中变量和数据结构的空间分配与输入规模的关系。

计算空间复杂度的步骤

计算一段代码的空间复杂度，通常需要考虑以下几个关键步骤。首先，明确代码中所使用的变量类型和数量。对于简单的变量，如整数、浮点数等基本数据类型，它们所占用的空间是固定的。接下来，分析动态分配的内存空间，例如通过malloc、new等操作分配的数组或对象。还要考虑函数调用时的栈空间，包括参数传递和局部变量的存储。
以一个简单的示例来说明，比如一个函数用于计算前n个整数的和：

int sum(int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += i;
    }
    return sum;
}

在这个例子中，只有一个整数变量sum用于存储计算结果，其空间复杂度为O(1)，因为变量sum所占用的空间不随输入n的变化而变化。
再看一个动态分配内存的例子：

int* createArray(int n) {
    int* arr = (int*)malloc(n * sizeof(int));
    return arr;
}

这个函数动态分配了一个大小为n的整数数组，其空间复杂度为O(n)，因为分配的内存空间大小与输入n成正比。

固定大小变量的空间复杂度

固定大小变量的空间复杂度相对简单直观。无论程序的输入规模如何变化，这类变量所占用的空间始终保持恒定。比如，一个整数变量在大多数编程语言中通常占用固定的字节数（例如 4 字节或 8 字节）。
以 C 语言中的int类型为例，无论程序处理的数据量是大是小，单个int类型变量所占用的空间都是固定的。即使在处理大规模数据的程序中，只要使用的固定大小变量数量有限，它们对总体空间复杂度的影响通常较小。
又如在 Java 中，boolean类型始终占用 1 字节的空间，short类型占用 2 字节，long类型占用 8 字节等，这些基本数据类型的空间占用不会因输入数据的规模而改变。
以下是一个 C 语言的代码示例，用于展示固定大小变量的空间使用情况：

#include <stdio.h>

int main() {
    int num1 = 10;  // 4 字节
    char ch = 'A';  // 1 字节
    float flt = 3.14;  // 4 字节

    printf("Size of int: %zu bytes\n", sizeof(num1));
    printf("Size of char: %zu bytes\n", sizeof(ch));
    printf("Size of float: %zu bytes\n", sizeof(flt));

    return 0;
}

在这个示例中，num1（int 类型）、ch（char 类型）和 flt（float 类型）的空间大小都是固定的，不会因为程序的其他操作或输入数据的变化而改变。通过 sizeof 操作符可以获取它们的实际字节数。

与输入规模成正比的数据结构的空间复杂度

当数据结构的空间需求与输入规模成正比时，其空间复杂度为线性。常见的例子包括动态数组、链表等。
以动态数组为例，如果我们需要创建一个能够存储n个整数的动态数组，那么随着n的增加，所需的存储空间也会线性增长。这是因为每个元素都需要一定的空间来存储，元素数量越多，总存储空间就越大。
再比如链表，虽然每个节点的大小可能是固定的，但节点的数量取决于输入规模。当输入规模增大，链表的长度增加，所需的存储空间也就相应增加。
在实际编程中，如果需要频繁地添加或删除元素，并且事先不知道元素的具体数量，使用与输入规模成正比的动态数据结构可以提高空间的灵活性和利用率。
以下是使用 C 语言分别实现动态数组和链表，并分析其空间复杂度的代码示例：

动态数组示例：

#include <stdio.h>
#include <stdlib.h>

// 创建一个可以存储 n 个整数的动态数组
int* createDynamicArray(int n) {
    int* arr = (int*)malloc(n * sizeof(int));
    return arr;
}

int main() {
    int n = 10;
    int* arr = createDynamicArray(n);
    printf("Dynamic array of size %d created.\n", n);
    free(arr);
    return 0;
}

在上述代码中，createDynamicArray 函数创建的动态数组的空间大小与输入的 n 成正比，空间复杂度为 O(n)。

链表示例：

#include <stdio.h>
#include <stdlib.h>

// 链表节点结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 创建新的链表节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 向链表尾部添加节点
void append(Node** head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    Node* curr = *head;
    while (curr->next!= NULL) {
        curr = curr->next;
    }
    curr->next = newNode;
}

int main() {
    Node* head = NULL;
    append(&head, 10);
    append(&head, 20);
    append(&head, 30);

    // 遍历链表并打印节点数据
    Node* curr = head;
    while (curr!= NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }

    // 释放链表内存
    curr = head;
    Node* temp;
    while (curr!= NULL) {
        temp = curr;
        curr = curr->next;
        free(temp);
    }

    return 0;
}

在这个链表的示例中，节点的数量取决于添加操作的次数，也就是输入规模。随着添加元素的增多，链表长度增加，所需存储空间也相应增加，空间复杂度为 O(n)。

嵌套数据结构的空间复杂度分析

对于嵌套的数据结构，空间复杂度的分析会稍微复杂一些。需要分别考虑每个嵌套层次的数据结构及其规模。
例如，一个二维数组可以看作是数组元素为数组的嵌套结构。如果二维数组的大小为m×n，那么其空间复杂度为O(m×n)。
再比如一个二叉树，每个节点可能包含若干个子节点指针以及数据。如果二叉树的节点数量为n，那么除了节点数据本身占用的空间外，指针所占用的空间也需要考虑在内。在最坏情况下，二叉树可能退化为链表，此时空间复杂度接近O(n)；而在平衡的情况下，空间复杂度通常为O(n)。
以下是使用 C 语言分别对二维数组和二叉树的空间复杂度进行分析的代码示例：

二维数组示例：

#include <stdio.h>

int main() {
    int m = 5, n = 5;
    int arr[m][n];

    printf("Space complexity of the 2D array is O(%d * %d) = O(%d)\n", m, n, m * n);

    return 0;
}

在这个示例中，二维数组 arr 的空间复杂度为 O(m * n)。

二叉树示例：

#include <stdio.h>
#include <stdlib.h>

// 二叉树节点结构体
typedef struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

// 创建新的二叉树节点
TreeNode* createTreeNode(int data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 计算二叉树的空间复杂度（简单估计，不考虑内存对齐等细节）
int calculateSpaceComplexity(TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    return sizeof(TreeNode) + calculateSpaceComplexity(root->left) + calculateSpaceComplexity(root->right);
}

int main() {
    // 构建一个简单的二叉树
    TreeNode* root = createTreeNode(1);
    root->left = createTreeNode(2);
    root->right = createTreeNode(3);
    root->left->left = createTreeNode(4);
    root->left->right = createTreeNode(5);

    int spaceComplexity = calculateSpaceComplexity(root);
    printf("Space complexity of the binary tree is approximately O(%d)\n", spaceComplexity);

    // 释放二叉树节点内存
    //...

    return 0;
}

在这个示例中，对于二叉树，每个节点除了自身数据的空间，还包含指向左右子节点的指针空间。在计算空间复杂度时，需要递归地考虑每个节点及其子树的空间。平衡二叉树的空间复杂度通常为 O(n)，最坏情况下（退化为链表）接近 O(n) 。

计算空间复杂度时输入数据所占空间

在计算空间复杂度时，需要区分输入数据本身所占的空间和程序运行时额外所需的空间。如果输入数据所占的空间只取决于问题本身，与算法无关，那么在计算空间复杂度时通常不考虑这部分空间。
例如，一个函数接收一个固定大小的数组作为输入，并对其进行操作。此时，数组本身的空间不纳入空间复杂度的计算，而只考虑函数在处理过程中额外申请的空间，如临时变量、辅助数组等。
但如果输入数据的空间大小会因算法的不同操作而发生变化，例如对输入数组进行动态扩展或裁剪，那么这部分变化的空间就需要纳入空间复杂度的计算。

综上所述，计算一段代码的空间复杂度需要综合考虑变量、数据结构、嵌套结构以及输入数据等多个方面的因素，通过仔细分析程序在不同情况下所需的存储空间与输入规模的关系，来准确确定空间复杂度的级别。这有助于评估程序的内存使用效率，为优化算法和选择合适的数据结构提供重要依据。
以下是使用 C 语言的代码示例来解释计算空间复杂度时输入数据所占空间的情况：

示例 1：输入数据空间不变

#include <stdio.h>

void processArray(int arr[], int size) {
    int temp;  // 临时变量，额外空间
    for (int i = 0; i < size; i++) {
        temp = arr[i];
        // 对 temp 进行一些操作
    }
}

int main() {
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    processArray(arr, 10);
    return 0;
}

在上述代码中，processArray 函数接收一个固定大小为 10 的数组 arr 。计算空间复杂度时，数组 arr 本身的空间不考虑，只考虑函数内的临时变量 temp 所占用的固定空间，空间复杂度为 O(1)。

示例 2：输入数据空间变化

#include <stdio.h>
#include <stdlib.h>

void resizeArray(int** arr, int size) {
    *arr = (int*)realloc(*arr, size * sizeof(int));  // 动态改变输入数组的大小
}

int main() {
    int* arr = (int*)malloc(5 * sizeof(int));
    resizeArray(&arr, 10);
    free(arr);
    return 0;
}

在这个示例中，resizeArray 函数会动态改变输入数组 arr 的大小。所以在计算空间复杂度时，这部分变化的空间需要考虑，空间复杂度取决于重新分配的大小，可能是 O(n) （n 为重新分配后的大小）。