时间复杂度

        时间复杂度是算法分析中用于衡量算法执行时间效率的一个概念。它描述了算法随着输入规模增长时，所需执行的基本操作数量的增长情况。通过对算法的时间复杂度进行分析，我们能够选择出最优的算法来解决问题。

统计时间增长趋势

        时间复杂度的统计时间增长趋势是指随着输入规模的增长，算法执行时间的增长情况。它描述了算法执行时间与输入规模之间的关系，并用大O符号表示。

        在进行时间复杂度的统计时间增长趋势分析时，我们主要关注算法执行时间的增长速度。通常，我们关注算法在最坏情况下的时间复杂度，因为它能够给出算法执行时间的一个上界。

函数渐近上界

        时间复杂度的函数渐近上界指的是对一个算法的运行时间在最坏情况下的上限估计。

        假设有一个算法，其输入规模为n，时间复杂度为T(n)。如果存在一个函数f(n)，使得对于足够大的n，T(n)始终小于等于c * f(n)，其中c是一个正常数，那么我们说T(n)的渐近上界是O(f(n))。

        换句话说，渐近上界告诉我们当输入规模趋近于无穷大时，算法的运行时间增长的速度。通过使用渐近上界，我们可以比较不同算法的效率，并选择最优的算法来解决问题。

        举例来说，如果一个算法的时间复杂度为O(n^2)，那么它的运行时间在最坏情况下将随着输入规模n的增加而平方增长。而如果另一个算法的时间复杂度为O(n*log n)，那么它的运行时间将比第一个算法更快增长。

        因此，时间复杂度的函数渐近上界提供了一种衡量算法效率的方法，帮助我们选择最适合特定问题的算法。

常见类型

        

1. 常数时间复杂度 O(1)：

   # 该函数接受一个数组作为输入，并打印出数组的第一个元素。
   # 不论数组的大小如何，函数只需要访问数组的第一个元素，因此运行时间始终保持恒定。
   def print_first_element(arr):
       print(arr[0])

2. 线性时间复杂度 O(n)：

   # 该函数接受一个数组作为输入，并遍历整个数组，打印出每个元素。
   # 由于每个元素都需要被访问一次，因此函数的运行时间与数组的大小成线性关系。
   def print_all_element(arr):
       for element in arr:
           print(element)

3. 对数时间复杂度 O(log n)：

   # 该函数实现了二分搜索算法，用于在已排序的数组中查找目标元素。
   #在每次迭代中，将待搜索范围缩小为原来的一半。这种算法的运行时间与数组大小的对数成正比。
   
   def binary_search(arr,target):
       low = 0
       high = len(arr) - 1
       while low <= high:
           mid = (low + high) // 2
           if arr[mid] == target:
               return True
           elif arr[mid] < target:
               low = mid + 1
           else:
               high = mid - 1
       return False

4. 平方时间复杂度 O(n^2)

   # 该函数接受一个数组作为输入，并打印出数组中所有元素的配对。
   # 嵌套的两个循环导致了一个平方级别的时间复杂度，因为需要遍历数组中的每个元素，并与其他元素进行配对。
   def print_all_pairs(arr):
       for i in range(len(arr)):
           for j in range(len(arr)):
               print(arr[i],arr[j])

5. 线性对数时间复杂度 O(n log n)：

   # 归并排序
   def merge_sort(arr):
       if len(arr) <= 1:
           return arr
   
       mid = len(arr) // 2
       left_half = merge_sort(arr[:mid])
       right_half = merge_sort(arr[mid:])
   
       return merge(left_half, right_half)
   
   def merge(left, right):
       result = []
       i = 0
       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
   

6. 指数时间复杂度 O(2^n)：

   # 这是一个生成给定集合的所有幂集（包括空集和自身）的递归函数。
   # 它的时间复杂度为O(2^n)，其中n是集合中元素的数量。因为在每一步递归调用中，都有两种可能的选择：要么# 将元素添加到当前子集中，要么不添加。这导致了指数级的时间复杂度。
   def powerset(s):
       if len(s) == 0:
           return [[]]
   
       subsets = []
       first = s[0]
       remaining = s[1:]
       for subset in powerset(remaining):
           subsets.append(subset)
           subsets.append([first] + subset)
   
       return subsets
   

7. 阶乘时间复杂度O(n!)

   def factorial_recur(n: int) -> int:
       if n == 0:
           return 1
       count = 0
       for _ in range(n):
           count += factorial_recur(n - 1)
       return count
   

   ps:本文参考Hello 算法