Java时间复杂度与空间复杂度经典例题

时间复杂度

一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。在实际中关注的是算法的最坏运行情况。

大O的渐进表示法：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

时间复杂度计算举例

例1：

void func2(int N) {
	int count = 0;
	for (int k = 0; k < 2 * N ; k++) {
		count++;
	}
	int M = 10;
	while ((M--) > 0) {
		count++;
	}
	System.out.println(count);
}

O(2N + 10) 约去前面的参数和后面的低阶常数
时间复杂度O(N)

例2：

void func3(int N, int M) {
	int count = 0;
	for (int k = 0; k < M; k++) {
		count++;
	}
	for (int k = 0; k < N ; k++) {
		count++;
	}
	System.out.println(count);
}

时间复杂度O(M + N) M 和N都是未知的

例3：

void func4(int N) {
	int count = 0;
	for (int k = 0; k < 100; k++) {
		count++;
	}
	System.out.println(count);
}

O(100) ~ O(1) 用常数1取代所有常数
时间复杂度O(1)

例4：冒泡排序的时间复杂度

void bubbleSort(int[] array) {
	for (int end = array.length; end > 0; end--) {
		boolean sorted = true;
		for (int i = 1; i < end; i++) {
			if (array[i - 1] > array[i]) {
				Swap(array, i - 1, i);
				sorted = false;
			}
		}
		if (sorted == true) {
			break;
		}
	}
}

end：[n, n-1, n-2 … n-(n-1)]
i ：[n-1,n-2, n-3 … 1]
等差数列求和：
{[(n-1)+1]*(n-1) } / 2 ~ n^2

最坏复杂度：O(n^2) ：原始顺序为 9 8 7 6 5 4 3 2 1
最好复杂度：O(n)：原始排序为1 2 3 4 5 6 7 8 9

例5：二分查找的时间复杂度

int binarySearch(int[] array, int value) {
	int begin = 0;
	int end = array.length - 1;
	while (begin <= end) {
		int mid = begin + ((end-begin) / 2);
		if (array[mid] < value)
			begin = mid + 1;
		else if (array[mid] > value)
			end = mid - 1;
		else
			return mid;
	}
	return -1;
}

-------------------------- N
------------- N/2
------ N/4
— N/8
…
…
1
假设一共分了x次
N / 2^x = 1
N = 2^x
x = log₂N (log以2为底的N的对数）
最坏时间复杂度O(log₂N)
最好时间复杂度O(1)

例6：阶乘递归的时间复杂度

// 计算阶乘递归factorial的时间复杂度？
long factorial(int N) {
	return N < 2 ? N : factorial(N-1) * N;
}

递归的时间复杂度=递归的次数 * 每次递归后执行的次数。
递归了N-1次，每次递归执行1次
时间复杂度O(N)

例7：斐波那契递归的时间复杂度

int fibonacci(int N) {
	return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}

2⁰       fib(n)
2¹    fib(n-1)    fib(n-2)
2²   fib(n-2) fib(n-3) fib(n-3) fib(n-4)
…
2^(n-1)

每次递归后执行的次数仍是1
递归的次数：2⁰ + 2¹ + 2² +…+ 2^(n-1)
等比数列求和
S_n = 1*(1-2ⁿ)/(1-2) = 2ⁿ - 1

时间复杂度：O(2^N)
空间复杂度：O(n)
递归右边的时候左边一定是递归走完了。
左边走完后开辟的栈就被丢掉了。
所以最大的空间复杂度就是(N-1)

空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。
本质衡量一个算法浪费内存的情况。
完成某个算法所需要的临时空间的大小

1. 冒泡排序的空间复杂度

void bubbleSort(int[] array) {
	for (int end = array.length; end > 0; end--) {
		boolean sorted = true;
		for (int i = 1; i < end; i++) {
			if (array[i - 1] > array[i]) {
				Swap(array, i - 1, i);
				sorted = false;
			}
		}
		if (sorted == true) {
			break;
		}
	}
}

O(1)
没有随着问题规模增长，让内存增加
对于第三行的boolean sorted = true;，这是循环定义，只算一个

2. 循环斐波那契的空间复杂度

int[] fibonacci(int n) {
	long[] fibArray = new long[n + 1]; //N
	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)
时间复杂度：O(N)

3. 阶乘递归的空间复杂度

long factoriall(int N) {
	return N < 2 ? N : factorial(N-1)*N;
}

O(N)
每次递归都会在栈上开辟空间。
递归N次，每次使用常数个空间

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

int fibonacci(int N) {
	return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}

空间复杂度：O(N)
递归右边的时候左边一定是递归走完了。
左边走完后开辟的栈就被丢掉了。
所以最大的空间复杂度就是(N-1)，看递归的最高度