【数据结构】时间复杂度

时间复杂度的定义

时间复杂度是一个函数，它定性描述该算法的运行时间。
我们默认CPU的每个单元运行消耗的时间都是相同的，因此算法的运行时间可以用算法的操作单元数量来表示。

假设算法的问题规模为n，其操作单元数量用函数f(n)来表示，那么随着n的增大，算法运行时间的增长率和f(n)的增长率相同，这称为算法的渐进时间复杂度，简称时间复杂度，记为O(f(n))。

常见时间复杂度的排序

我们所说的时间复杂度都是省略常数项系数的，因为一般情况下都默认数据规模足够大，基于这个事实，给出下列排行：
O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n³) < O(2ⁿ) < O(n!) < O(nⁿ)

为什么要去掉常数项？
因为大O就是数据量级突破一个点且数据量非常大的情况下所表现出的时间复杂度，对于这个数据量，常数项系数已经不起决定性作用了。

复杂表达式的化简

如：O(2n² + 10n + 1000)
化简步骤：

1. 去掉加法常数项，即O(2n² + 10n)
2. 去掉常熟系数，即O(n² + n)
3. 只保留最高项，即O(n² )

O(logn)中的log是以什么为底

对数函数的性质：log₂n = log₂i * log_in，其中log₂i 是常数
即O(log_in ) = O(log₂n )，因此可以直接忽略底数

常见的时间复杂度

数据结构

图

排序算法

冒泡排序

依次比较相邻的元素，如果前者大于后者，则交换。相当于从后往前确定元素。

void BubbleSort(int* Array, int )
{
    for (int i = 0; i < n; i++)
    {
        bool Flag = 0;
        int  Temp = 0;
        for (int j = 0; j < n - i - 1; j++)
        {
            if (Array[j] > Array[j + 1])
            {
                Flag = 1;
                swap(Array[j], Array[j + 1]);
            }
        }
        if (!Flag)
        {
            return;
        }
    }
}

选择排序

每一次从待排序的数据元素中选出最小的一个元素，将其放在已排好序的数列的最后，直到全部待排序的数据元素排完。
相当于从前往后确定元素。

void SelectSort(int* Array, int Num)
{
    for (int i = 0; i < Num; i++)
    {
        int Min = i;
        for (int j = i; j < Num; j++)
        {
            if (Array[Min] > Array[j])
            {
                Min = j;
            }
        }
        if (Min != i)
        {
            swap(Array[i], Array[Min]);
        }
    }
}

插入排序

还是从前往后确定，先比较前两个，排好序后再将第三个插入前面的序列，排好序后再将第4个插进去，每插入一次都确保排好序。适用于数据量少的排序。

void InsertSort(int* Array, int Num)
{
    for (int i = 0; i < Num; i++)
    {
        for (int j = i; j > 0; j--)
        {
            if (Array[j] < Array[j - 1])
            {
                swap(Array[j], Array[j - 1]);
            }
        }
    }
}

快速排序

对冒泡排序的改进。首先选取一个关键数据（通常是数组第一个元素），将比它小的数都放到它前面，将比它大的数都放到它后面。

void FastSort(int* Array, int Start, int End)
{
    if (Start >= End)
    {
        return;
    }
    int i = Start;
    int j = End;
    int Key = Array[i];
    while (i < j)
    {
        while (i < j && Array[j] >= Key)
        {
            j--;
        }
        Array[i] = Array[j];
        while (i < j && Array[i] <= Key)
        {
            i++;
        }
        Array[j] = Array[i];
    }
    Array[i] = Key;
    FastSort(Array, Start, i - 1);
    FastSort(Array, i + 1, End);
}

归并排序

将两个顺序序列合并成一个。每一层递归上都有三个步骤：

• 分解：将n个元素分成2个含n/2个元素的子序列
• 解决：用合并排序法对2个子序列递归的排序
• 合并：合并2个已排序的子序列，得到排序结果

void MergeSort_(int* Array, int Left, int Mid, int Right)
{
    int LeftSize  = Mid - Left;
    int RightSize = Right - Mid + 1;
    int *LeftArr  = new int[LeftSize];
    int *RightArr = new int[RightSize];

    for (int i = Left; i < Mid; i++)
    {
        LeftArr[i - Left] = Array[i];
    }
    for (int i = Mid; i <= Right; i++)
    {
        RightArr[i - Mid] = Array[i];
    }
    int i = 0;
    int j = 0;
    int k = Left;
    while (i < LeftSize && j < RightSize)
    {
        if (LeftArr[i] < RightArr[j])
        {
            Array[k++] = LeftArr[i++];
        }
        else
        {
            Array[k++] = RightArr[j++];
        }
    }
    while (i < LeftSize)
    {
        Array[k++] = LeftArr[i++];
    }
    while (j < RightSize)
    {
        Array[k++] = RightArr[j++];
    }
}
void MergeSort(int* Array, int Left, int Right)
{
    if (Left == Right)
    {
        return;
    }
    int Mid = (Left + Right) / 2;
    MergeSort(Array, Left, Mid);
    MergeSort(Array, Mid + 1, Right);
    MergeSort_(Array, Left, Mid + 1, Right);
}

堆排序

类似于快速排序，堆排序反复选择最大的项目并将其移动到列表的末尾。区别在于，不是扫描整个列表来查找最大的元素，而是先将列表转换为最大堆（父节点的值总是大于子节点），以加快速度。
注意：堆一定是一颗完全二叉树。
这里涉及到二叉树的概念，以后再补充。

// TODO

搜索算法

具体示例

经典题目：求x的n次方

注意：递归算法的时间复杂度本质上是看，递归的次数 * 每次递归的时间复杂度；
空间复杂度是看，递归深度 * 每次递归的空间复杂度。

// O(n)
int Sub_1(int x, int n)
{
    int Result = 1;
    for (int i = 0; i < n; i++)
    {
        Result = Result * x;
    }
    return Result;
}
// O(n)
int Sub_2(int x, int n)
{
    if (n == 0)
    {
        return 1;
    }
    return Sub_2(x, n - 1) * x;
}
// O(logn)
int Sub_3(int x, int n)
{
    if (n == 0)
    {
        return 1;
    }
    int t = Sub_3(x, n / 2);
    if (n % 2 == 1)
    {
        return t * t * x;
    }
    return t * t;
}