初入数据结构—复杂度

PART1：数据结构的概念

数据结构是计算机存储、储存数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。

PART2：算法的概念

算法是对特定问题求解步骤的一种描述，其是指令的有限序列，每条指令表示一个或多个操作。

简而言之，算法即是解决问题的一系列计算步骤，将我们目前所有的数据转换成输出结果。

PART3：算法效率

①复杂度

不同的算法运行时间上存在很大的差别。

衡量一个算法的好坏，一般从时间和空间两个方面来衡量。

时间复杂度反映了一个算法运行的速度，空间复杂度反映了一个算法运行所需要申请的额外空间的大小。

②时间复杂度T（N）

一个算法运行的时间很难精确的描述出来，每运行一次他的运行时间都是在变化的，因此我们无法准确的描述一个算法所需要的时间。

这里我们采用比较算法程序的增长量级也就是在一个算法执行次数不断增大的情况下他的时间复杂度的表达式的影响程度从而反映一个算法的时间复杂度是大是小。

③空间复杂度

一个算法在运行的时候要开辟额外的存储空间，而开辟的空间大小我们采用空间复杂度反映。空间复杂度取决于一个算法变量的个数。

④复杂度的表示方法

计算一个算法的复杂度时，我们采用大O渐进表示法。

⑤时间复杂度的大O推导的三个规则

1.只保留最高项（类似于高数中计算极限时的"取大头"）只保留高阶项，随着执行次数的增加低阶项对于算法的结果的影响越来越小，可以忽略不计；

2.最高项的系数存在且不是1的，表示的时候去除常数系数；

3.T（N）没有N相关的项目时，用1表示，即O（1）；

PART4：复杂度的计算例子

1.时间复杂度

eg1：

void Func(int N)
{
    int count = 0;
    for (int k = 0; k < 2 * N ; ++ k)
    {
       ++count;
    }
    int M = 10;
    while (M--)
    {
        ++count;
    }
    printf("%d\n", count);
}

不难看出，K一共循环了2N次，M一共循环了10次，故Func执行的基本操作次数T（N）=2N+10。根据之前的规则，我们可以得到时间复杂度为O（N）。

eg2：

void Func(int N)
{
    int count = 0;
    for (int k = 0; k < 100; ++ k)
    {
        ++count;
    }
    printf("%d\n", count);
}

不难看出，K一共循环了100次，故Func执行的基本操作次数T（N）=100。根据之前的规则3可知Func的时间复杂度为O（1）。

eg3：

const char * strchr ( const char* str, int character)
{
    const char* p_begin = s;
    while (*p_begin != character)
    {
    if (*p_begin == '\0')
        return NULL;
    p_begin++;
    }
    return p_begin;
}

指针解引用后看与character比较，所以我们所需要查找的字符的位置是一个决定时间复杂度的因素

若查找的字符在字符串的首位，则直接匹配，此时T（N）=1

若查找的字符在字符串的中间，此时T（N）=N/2；

若查找的字符在字符串的末尾，此时T（N）=N；

eg4（递归函数）：

long long Fac(size_t N)
{
    if(0 == N)
    return 1;

    return Fac(N-1)*N;
}

不难看出，函数一共递归了n次，故T(N)=N；

eg5（冒泡排序）

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;
    }
}

如果数组是有序的，则T（N）=N；

如果数组有序且是降序，则每次比较的元素的个数为一个等差数列，根据等差数列求和可以得到其T（N）=N*(N+1)/2;

2.空间复杂度

eg（冒泡排序）：

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;
    }
}

这里我们引入了一个新的变量exchange，故空间复杂度为O（1）。

本次对于算法复杂度的总结就到这里了，感谢观看，若有不足欢迎指出。