个人笔记1（数据结构）

目录

时间复杂度

空间复杂度

---

时间复杂度

算法中的基本操作的执行次数，为算法的时间复杂度

准确时间复杂度函数式，不方便在算法之间进行比较，所以用大O的渐进表示法（大概估算，方便比较）

1. 用1取代常数
2. 只保留最高阶项
3. 去除与最高阶项（不是1时）相乘的常数

时间复杂度取最差的期望（底线思维）

时间复杂度是计算算法执行次数，一个执行次数，不一定是一条语句，可能是多条语句，但肯定是常数条

例1：计算strchr的时间复杂度

while(*str)
{
    if(*str == character)
        return str;
    else
        ++str;
}
return NULL;

时间复杂度为 O（n）

例2：计算冒泡排序的时间复杂度

准确的：F(N)=（N-1）+（N-2）+（N-3）+…+2+1=N*（N-1）/2

O(N^2)    最好的情况：O(N)

例3：计算二分查找的时间复杂度

折半了多少次就除了多少个2，除了多少个2就找了多少次

最好：O(1)   最坏：O(log₂N)

因为要在文本中写对数不好写，而时间复杂度中，log₂N经常出现，所以我们会把它简写成logN

例4：消失的数字

思路1：创建一个n+1个数的数组，全部初始化成-1；遍历这些数字，这个数是多少，就写到数组下标对应位置；遍历一遍数组，哪个位置是-1，这个位置的下标就是缺失的数字  时间复杂度：O(N)

思路2：异或（相同为0，相异为1） 用一个x=0跟数组中这些数据都异或一遍，然后再跟0-n的数字异或一遍，最后x是缺失的数字（出现两次的数都异或没了，只有缺失的那个数字出现1次） 时间复杂度：O(N) 代码：

int missingNumber(int* nums, int numsSize) {
	int x = 0;
	for (int i = 0; i < numsSize; ++i)
	{
		x ^= nums[i];
	}
	for (ing j = 0; j < numsSize + 1; ++j)
	{
		x ^= j;
	}
}

思路3：排序+二分查找  用冒泡：O(N^2+logN)  用快排：O(N*logN)

思路4：公式计算 求和公式计算减掉数组中的数字  O(N)

例5：计算阶乘递归Fac的时间复杂度

 时间复杂度：O(N)

例6：计算斐波那契递归Fib的时间复杂度

时间复杂度：2^0+2^1+…+2^(N-2) ≈ O(2^N)

如果改用循环迭代，时间复杂度：O(N)

---

空间复杂度

算法里更看重时间效率，不太看重空间效率。

空间复杂度也是一个数学表达式，是对一个算法在运行过程中额外临时占用存储空间大小的量度。

空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。

空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。

注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

例1：计算冒泡排序的空间复杂度

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

空间复杂度：O(1)，因为只有end，exchange，i是额外开辟的空间

例2：计算斐波那契的空间复杂度

// 返回斐波那契数列的前n项
long long* Fibonacci(size_t n)
{
    if(n==0)
    return NULL;
    long long * fibArray = (long long *)malloc((n+1) * sizeof(long long));
    fibArray[0] = 0;
    fibArray[1] = 1;
    for (int i = 2; i <= n ; ++i)
    {
        fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
    }
    return fibArray;
}

空间复杂度：O(N)

例3：计算阶乘递归Fac的空间复杂度

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

空间复杂度：O(N)

例4：斐波那契递归的空间复杂度

O(N)，因为空间是不累计的，可以重复利用

例5：轮转数组：给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

• 尽可能想出更多的解决方案
• 使用空间复杂度为O(1)，时间复杂度为O(N)的原地算法解决这个问题

方法一：

时间复杂度为O(N)，空间复杂度为O(N)

方法二：三次逆置，空间复杂度为O(1)，时间复杂度为O(N)

代码：

void reverse(int* nums, int left, int right)
{
    while(right > left)
    {
        int tmp = nums[left];
        nums[left] = nums[right];
        nums[right] = tmp;
        ++left;
        --right;
    }
}
void rotate(int* nums, int numsSize, int k){
    k %= numsSize;
    reverse(nums, numsSize-k, numsSize-1);
    reverse(nums, 0, numsSize-k-1);
    reverse(nums, 0, numsSize-1);
}