时间复杂度与空间复杂度

冒泡排序

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;
		}
	}
}
时间复杂度为N的平方
空间复杂度为1

二分查找

int BinarySearch(int* a, int n, int x) {
	assert(a);
	int begin = 0;
	int end = n - 1;
	while (begin <= end) {
		int mid = begin + ((end - begin) >> 1);
		if (a[mid] < x) {
			begin = mid + 1;
		}
		else if (a[mid] > x) {
			end = mid - 1;
		}
		else {
			return mid;
		}
	}
	return -1;
}
时间复杂度为log以2为底N的对数

阶乘

long long Fac(size_t N) {
	if (0 == N)
		return 1;
	return Fac(N - 1) * N;
}
时间复杂度为N
空间复杂度为N

加上一个for循环之后时间复杂度为N的平方

long long Fac(size_t N) {
	if (0 == N)
		return 1;
	for (size_t i = 0; i < N; ++i) {
		//...
	}
	return Fac(N - 1) * N;
}

斐波那契数列

long long Fib(size_t N) {
	if (N < 3)
		return 1;
	return Fib(N - 1) + Fib(N - 2);
}
时间复杂度为2的n次方
空间复杂度为N

时间是累积的，一去不复返，空间是可以重复利用的。

空间的复用

消失的数字

int missingNumber(int* nums, int numsSize){
    int n = numsSize;
    int sum = (n*(n+1))/2;
    int i = 0;
    for(i=0;i<n;i++)
        sum-=nums[i];
    return sum;
}

异或：
int missingNumber(int* nums, int numsSize){
    //异或：相异为1 相同为0
    int n = numsSize;
    int x = 0;
    //这里i从0或者1开始都可以
    for(int i=0;i<=n;i++){
        x^=i;
    }
    for(int j=0;j<n;j++){
        x^=nums[j];
    }
    return x;
}

---

空间复杂度为N

轮转数组

1、void reverse(int* nums, int begin, int end)
{
    while(begin < end)
    {
        int tmp = nums[begin];
        nums[begin] = nums[end];
        nums[end] = tmp;

        ++begin;
        --end;
    }
}
void rotate(int* nums, int numsSize, int k){
    if(k > numsSize)
    {
        k %= numsSize;
    }
    
    reverse(nums, 0, numsSize-1);
    reverse(nums, 0, k-1);
    reverse(nums, k, numsSize-1);
}

2、void reverse(int* nums,int left,int right)
{
    while(left<right)
    {
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
        left++;
        right--;
    }
    return ;
}
void rotate(int* nums, int numsSize, int k){
    //如果k大于numsSize
    // if(k>=numsSize)
    //     k = k%numsSize;
    reverse(nums,numsSize-k,numsSize-1);
    reverse(nums,0,numsSize-k-1);
    reverse(nums,0,numsSize-1);
    return ;
}

3、void rotate(int* nums, int numsSize, int k){
    // 新的思路：使用拷贝+开辟新空间
    int n = numsSize;
    int* temp = (int*)malloc(n*sizeof(int));

    k%=n;
    //拷贝三步走
    
    memcpy(temp,nums+n-k,sizeof(int)*k);
    // 拷贝n-k到n-1
    memcpy(temp+k,nums,sizeof(int)*(n-k));
    // 拷贝0到k个 
    memcpy(nums,temp,sizeof(int)*n);
    // 将temp拷贝回去nums
    free(temp);
    temp = NULL;
}