搜索插入位置 力扣 Python

题目描述：

解题代码：

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        if target in nums:
            return nums.index(target)
        else:
            nums.append(target)
            nums.sort()
            return nums.index(target)

题目分析：

时间复杂度分析：

- 如果目标元素在列表中，则最坏情况下需要遍历整个列表，时间复杂度为O(n)。
- 如果目标元素不在列表中，则需要添加元素并排序，时间复杂度为O(nlogn)。

因此，最坏情况下时间复杂度为O(nlogn)，平均情况下为O(nlogn)。

空间复杂度分析：

- 如果目标元素在列表中，则不需要额外的空间，空间复杂度为O(1)。
- 如果目标元素不在列表中，则需要添加元素，空间复杂度为O(1)。

因此，空间复杂度为O(1)。

涉及的知识点 ：

Python中常见算法的时间复杂度和空间复杂度：

1. 排序算法：
- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)
- 插入排序：时间复杂度O(n^2)，空间复杂度O(1)
- 选择排序：时间复杂度O(n^2)，空间复杂度O(1)
- 快速排序：时间复杂度O(nlogn)，空间复杂度O(logn)
- 归并排序：时间复杂度O(nlogn)，空间复杂度O(n)

快速排序的时间复杂度为O(nlogn)是基于平均情况下的分析得出的，具体的计算方法如下：

1. 在平均情况下，快速排序的每一层都会将数组分成两部分，每部分的长度大约为原数组长度的一半，因此快速排序的递归深度为O(logn)。

2. 在每一层中，需要进行一次分区操作，时间复杂度为O(n)。

3. 因此，快速排序的时间复杂度为O(nlogn)。

快速排序的空间复杂度为O(logn)，是由于快速排序是一种递归算法，每次递归都需要保存一些状态信息，这些状态信息保存在栈中，因此快速排序的空间复杂度与递归深度成正比，即为O(logn)。在Python编程中，由于Python的递归深度有限制，因此快速排序的空间复杂度可能会受到限制。

2. 查找算法：
- 顺序查找：时间复杂度O(n)，空间复杂度O(1)
- 二分查找：时间复杂度O(logn)，空间复杂度O(1)

3. 图算法：
- 深度优先搜索（DFS）：时间复杂度O(V+E)，空间复杂度O(V)
- 广度优先搜索（BFS）：时间复杂度O(V+E)，空间复杂度O(V)

4. 动态规划算法：
- 斐波那契数列：时间复杂度O(n)，空间复杂度O(1)
- 背包问题：时间复杂度O(nW)，空间复杂度O(W)

需要注意的是，以上时间复杂度和空间复杂度只是算法的理论复杂度，实际运行时还会受到具体实现、数据规模等因素的影响。

在Python中常见的算法的时间复杂度和空间复杂度如下：

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

线性时间复杂度的算法的执行时间与输入规模成正比，即随着输入规模的增加，执行时间也会相应地增加。例如，遍历一个列表、计算列表中元素的和等操作都是线性时间复杂度的算法。

时间复杂度计算过程：

假设算法的执行时间为T(n)，n为输入规模，执行时间与输入规模成正比，即T(n) = k * n，其中k为常数。

空间复杂度为O(1)，即不需要额外的空间。

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

对数时间复杂度的算法的执行时间与输入规模的对数成正比，即随着输入规模的增加，执行时间会增加，但增加的速度会变慢。例如，二分查找算法就是对数时间复杂度的算法。

时间复杂度计算过程：

假设算法的执行时间为T(n)，n为输入规模，执行时间与输入规模的对数成正比，即T(n) = k * log n，其中k为常数。

空间复杂度为O(1)，即不需要额外的空间。

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

平方时间复杂度的算法的执行时间与输入规模的平方成正比，即随着输入规模的增加，执行时间会快速增加。例如，冒泡排序、选择排序等排序算法都是平方时间复杂度的算法。

时间复杂度计算过程：

假设算法的执行时间为T(n)，n为输入规模，执行时间与输入规模的平方成正比，即T(n) = k * n^2，其中k为常数。

空间复杂度为O(1)，即不需要额外的空间。

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

指数时间复杂度的算法的执行时间与输入规模的指数成正比，即随着输入规模的增加，执行时间会非常快速地增加。例如，求解旅行商问题的暴力算法就是指数时间复杂度的算法。

时间复杂度计算过程：

假设算法的执行时间为T(n)，n为输入规模，执行时间与输入规模的指数成正比，即T(n) = k * 2^n，其中k为常数。

空间复杂度为O(n)，即需要额外的空间来存储递归调用的栈帧。