Java时间复杂度和空间复杂度分析

1：实现二分查找算法的递归及非递归。（分析时间复杂度及空间复杂度）

迭代算法

1. #define _CRT_SECURE_NO_WARNINGS

2.  

3. #include<stdio.h>

4. #include<string.h>

5. #include<assert.h>

6.  

7. int BinarySearch(int arr[], int len, int num)

8. {

9. assert(arr);

10.  

11. int left = 0;

12. int right = len - 1;

13. int mid;

14.  

15. while (left <= right)

16. {

17. mid = left + (right - left) / 2;

18.  

19. if (num > arr[mid])

20. {

21. left = mid + 1;

22. }

23. else if (num < arr[mid])

24. {

25. right = mid - 1;

26. }

27. else

28. {

29. return mid;

30. }

31. }

32.  

33. return -1;

34. }

35.  
36.  
37.  

38. int main()

39. {

40. int arr[] = { 1,2,3,4,5,6,7,8,9 };

41. int length = sizeof(arr) / sizeof(arr[0]);

42. int aim = 9;

43. int result;

44.  

45. result = BinarySearch(arr, length, aim);

46.  

47. if (result == -1)

48. {

49. printf("Can't find %d\n", aim);

50. }

51. else

52. {

53. printf("%d at %d postion\n", aim,result + 1);

54. }

55.  
56.  

57. return 0;

58. }

二分查找时，每次都在原有查找内容进行二分，所以时间复杂度为O（log2 n）
因为变量值创建一次，所以空间复杂度为O（1）

递归算法

1. int BinarySearchRecursion(int arr[5], int lef, int rig,int aim)

2. {

3. int mid = lef + (rig - lef) / 2;

4.  
5.  

6. if (lef <= rig)

7. {

8. if (aim < arr[mid])

9. {

10. rig = mid - 1;

11. BinarySearchRecursion(arr, lef, rig, aim);

12. }

13. else if (arr[mid] < aim)

14. {

15. lef = mid + 1;

16. BinarySearchRecursion(arr, lef, rig, aim);

17. }

18. else if (aim == arr[mid])

19. {

20. return mid;

21. }

22.  

23. }

24. else

25. return -1;

26.  

27. }

28.  
29.  

30. int main()

31. {

32. int arr[] = { 1,2,3,5,6, };

33. int sz = sizeof(arr)/sizeof(arr[0]);

34. int result;

35.  

36. result = BinarySearchRecursion(arr, 0, sz - 1, 4);

37.  

38. if (-1 == result)

39. {

40. printf("Can't find it.\n");

41. }

42. else

43. printf("Aim at %d location\n", result+1);

44. }

时间复杂度为O（log2 n）
每进行一次递归都会创建变量，所以空间复杂度为O（log2 n）

2：实现斐波那契数列的递归及非递归。（分析时间复杂度及空间复杂度）

迭代算法

1. int FeiBoNaCciInteration(int a,int b,int num)

2. {

3. int c;

4.  

5. if (num <= 0)

6. return -1;

7. else if (num == 1)

8. return a;

9. else if (num == 2)

10. return b;

11. else

12. {

13. while (num - 2)

14. {

15. c = a + b;

16. a = b;

17. b = c;

18. num--;

19. }

20. return c;

21. }

22.  

23. }

24.  

25. int main()

26. {

27. int n;

28. int result;

29.  

30. printf("Input n\n");

31. scanf("%d", &n);

32.  

33. result = FeiBoNaCciInteration(2, 3, n);//可自定义输入第一个数和第二个数

34. if (result == -1)

35. {

36. printf("Input Error!\n");

37. }

38. else

39. {

40. printf("n is %d\n", result);

41. }

42.  

43. return 0;

44. }

时间复杂度O（n)
空间复杂度为O（1）

递归算法

1. int FeiBoNaCciRecursion(int num)

2. {

3. if (num < 0)

4. return -1;

5. if (num <= 2 && num > 0)

6. return 1;

7. else

8. return FeiBoNaCciRecursion(num - 1) + FeiBoNaCciRecursion(num - 2);

9.  

10. }

11.  

12. int main()

13. {

14. int n;

15. int result;

16.  

17. printf("Input n\n");

18. scanf("%d", &n);

19.  

20. result = FeiBoNaCciRecursion(n);

21.  

22. if (result == -1)

23. printf("Input Error!\n");

24. else

25. printf("Result is %d\n", result);

26.  

27. return 0;

28. }

时间复杂度为O（2^n）
空间复杂度为O（n）

 参考：https://blog.csdn.net/halotrriger/article/details/78994122?utm_source=copy

--------------------- 本文来自 qq_17534301 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/qq_17534301/article/details/82872963?utm_source=copy