数据结构（空间复杂度+顺序表）[2]

空间复杂度

在数据结构中，空间复杂度是用来描述算法或数据结构所使用的内存空间量的度量指标。它表示算法或数据结构所需要的额外内存空间随输入规模增长的趋势。

空间复杂度可以分为以下几种情况：

1. 最坏情况空间复杂度（Worst-case Space Complexity）：表示在最坏情况下算法或数据结构所需要的额外内存空间量。这是一种保证，无论输入规模如何，算法或数据结构所需要的额外内存空间不会超过这个值。

2. 平均情况空间复杂度（Average-case Space Complexity）：表示在平均情况下算法或数据结构所需要的额外内存空间量。这是对算法或数据结构在各种输入情况下的平均表现的度量。

3. 最好情况空间复杂度（Best-case Space Complexity）：表示在最好情况下算法或数据结构所需要的额外内存空间量。这是一种理想化的情况，即算法或数据结构在最理想的输入情况下所需要的额外内存空间。

计算空间复杂度时，通常使用大O记法（O notation）来表示。例如，如果一个算法的空间复杂度为O(n)，表示算法所需要的额外内存空间随输入规模n线性增长。

举例计算空间复杂度时，可以考虑以下情况：

1. 数组：一个大小为n的数组，需要O(n)的额外内存空间。

2. 链表：一个包含n个节点的链表，需要O(n)的额外内存空间。

3. 栈：一个包含n个元素的栈，需要O(n)的额外内存空间。

4. 队列：一个包含n个元素的队列，需要O(n)的额外内存空间。

5. 二叉树：一个包含n个节点的二叉树，最坏情况下需要O(n)的额外内存空间。

需要注意的是，在计算空间复杂度时，通常只考虑算法或数据结构本身所需要的额外内存空间，而不考虑输入数据所占用的空间。
以下是几个常见算法的示例程序，包括计算空间复杂度的注释。

1. 冒泡排序（Bubble Sort）：

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

# 冒泡排序的空间复杂度为O(1)，因为只需要常数级别的额外内存空间来存储临时变量和迭代变量。

2. 快速排序（Quick Sort）：

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr)//2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

# 快速排序的空间复杂度取决于递归调用的层数，最坏情况下的空间复杂度为O(n)，平均情况下的空间复杂度为O(log n)。

3. 归并排序（Merge Sort）：

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]
    left = merge_sort(left)
    right = merge_sort(right)
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

# 归并排序的空间复杂度为O(n)，因为需要额外的O(n)的内存空间来存储归并操作的结果。

4. 堆排序（Heap Sort）：

def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2
    if left < n and arr[i] < arr[left]:
        largest = left
    if right < n and arr[largest] < arr[right]:
        largest = right
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)
    for i in range(n//2 - 1, -1, -1):
        heapify(arr, n, i)
    for i in range(n-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)

# 堆排序的空间复杂度为O(1)，因为只需要常数级别的额外内存空间来存储临时变量和迭代变量。

5. 二叉搜索树（Binary Search Tree）：

class Node:
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None

def insert(root, key):
    if root is None:
        return Node(key)
    if key < root.key:
        root.left = insert(root.left, key)
    else:
        root.right = insert(root.right, key)
    return root

# 二叉搜索树的空间复杂度取决于树的高度，最坏情况下的空间复杂度为O(n)，平均情况下的空间复杂度为O(log n)。

以上示例程序中的空间复杂度计算是基于算法本身所需要的额外内存空间，实际应用中还需要考虑输入数据的大小和存储方式对空间复杂度的影响。

顺序表

顺序表是一种基于数组实现的线性表，它的元素在内存中是连续存储的。顺序表的特点是可以通过下标来快速访问元素，但插入和删除操作可能需要移动大量元素。

以下是一个简单的顺序表的示例程序：

class ArrayList:
    def __init__(self):
        self.data = []

    def is_empty(self):
        return len(self.data) == 0

    def length(self):
        return len(self.data)

    def get(self, index):
        if index < 0 or index >= len(self.data):
            raise IndexError("Index out of range")
        return self.data[index]

    def insert(self, index, value):
        if index < 0 or index > len(self.data):
            raise IndexError("Index out of range")
        self.data.insert(index, value)

    def delete(self, index):
        if index < 0 or index >= len(self.data):
            raise IndexError("Index out of range")
        del self.data[index]

在上述示例程序中，我们使用一个列表来存储顺序表的元素。is_empty方法用于判断顺序表是否为空，length方法返回顺序表的长度，get方法用于获取指定位置的元素，insert方法用于在指定位置插入一个元素，delete方法用于删除指定位置的元素。

顺序表的空间复杂度为O(n)，其中n是顺序表的元素个数。因为顺序表的元素在内存中是连续存储的，所以需要一段连续的内存空间来存储所有元素。当插入或删除元素时，可能需要移动其他元素，导致时间复杂度为O(n)。但是通过下标访问元素的时间复杂度为O(1)。