集合及数据结构第二节————算法、时间复杂度和空间复杂度

系列文章目录

集合及数据结构第二节————算法、时间复杂度和空间复杂度

算法、时间复杂度和空间复杂度

1. 数据结构和算法的关系
2. .算法的定义
3. 算法的特性
4. 算法设计的要求
5. 算法效率
6. 时间复杂度的概念
7. 大O的渐进表示法
8. 常见时间复杂度计算举例
9. 常见空间复杂度计算举例

---

---

一、算法

1.数据结构和算法的关系

数据结构是组织和管理数据的方式，算法则是解决问题的方法。数据结构和算法是紧密相关的，因为一个好的算法必须基于一个高效的数据结构。

具体来说，数据结构提供了存储和组织数据的方式，算法则利用这些数据结构来实现特定的任务。例如，在查找某个元素时，可以使用二分查找算法，它需要一个有序的数据结构（如数组）来实现。对于不同的算法，可能需要不同的数据结构来实现。

因此，学习数据结构和算法可以帮助我们更好地理解如何使用各种数据结构来解决问题，以及如何选择最适合特定问题的算法。同时，了解不同算法的复杂度和效率，也可以帮助我们编写更高效、更优化的代码。

2.算法的定义

算法是一组用于解决特定问题或执行特定任务的有序步骤。算法通常由一系列指令或规则组成，这些指令描述了解决问题或完成任务的过程。算法可以应用于各种领域，包括计算机科学、数学、工程学和物理学等。算法的设计和优化是计算机科学领域的核心问题之一，人们一直在努力设计出更高效、更复杂、更卓越的算法来解决日益增长的问题。

3.算法的特性（ * * ）

算法具有五个基本特性：输入、输出、有穷性、确定性和可行性等。

输入和输出

算法具有零个或多个输入，因为对与绝大多数算法类实输入是必要的。但是只要求打印时，就不需要输入任何参数。因此算法的输入可以为零。
算法至少有一个或者多个输出，如果不输出那么这个算法就没有意义。

有穷性

有穷性：算法必须能在有限步骤内完成，并且要自动结束而不出现无限循环否则就不是算法。

确定性

算法在任何时候给定相同的输入，都应该产生相同的输出，即算法的结果不受计算机硬件和软件等环境的影响。

可行性

算法必须是可行的，也就是说，无论从时间还是空间上来看，算法都必须能够在实际应用中被实现。

简单性

算法应当尽可能简单，以便于程序员的实现和维护。

4.算法设计的要求（ * * * ）

正确性

正确性：算法是针对一个具体问题的求解而设计的。算法是否正确，通常要用某种程序设计语言将其转化为程序，然后检验，其执行结果应当满足预先规定的功能和性能要求。程序的正确性可以从下面四个层次理解：

1. 算法程序没有语法错误
2. 算法程序对合法的输入数据能够产生满足要求的输出结果
3. 算法程序对于非法的输入数据能够得到满足规格说明的结果
4. 算法程序对于精心选择的，甚至刻意为之的测试数据都有满足要求的输出结果

可读性

算法设计的一大目的是为了人的阅读和交流，其次才是为计算机执行，因此算法应该易于理解，另外，晦涩难懂大的程序容易有较多难以察觉的错误而难于调试

健壮性

算法健壮性是指算法对于输入数据的变化或异常情况具有一定的容错能力，能够正确、稳定地输出结果。在实际应用中，输入数据往往是不完美的，可能存在数据缺失、错误、异常等问题，健壮的算法能够适应这些情况，保证程序的正确性和稳定性。

高效性

算法的高效性指的是在计算资源（如时间、内存等）有限的情况下，算法能够在较短的时间内完成任务并得到正确的结果。这就要求算法具有足够的速度和空间效率（分别以算法的时间复杂度和空间复杂度来衡量），能够在处理大规模数据时保持合理的运行时间和内存占用。

算法的高效性对于实际应用非常重要，因为它可以大大提高程序的运行速度和资源利用效率，从而提高系统的整体性能。在一些特定的场景下，如大数据处理、人工智能等，算法的高效性更是至关重要的因素。

下面求斐波那契数列的算法好还是不好，为什么？该如何衡量一个算法的好坏呢？

public static long Fib(int N){
	if(N < 3){
	return 1;
	}
	 return Fib(N-1) + Fib(N-2);
}

这时候就要用到算法效率的概念了。

5.算法效率

算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率被称作空间复杂度。
时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间，
在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

二、时间复杂度

1.时间复杂度的概念

时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个数学函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

2. 大O的渐进表示法（ * * ）

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

Func1 执行的基本操作次数 ：

N = 10 F(N) = 130
N = 100 F(N) = 10210
N = 1000 F(N) = 1002010

实际计算时间复杂度时，其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里就使用大O的渐进表示法。
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号

3.推导大O阶方法（ * * ）

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

• N = 10 F(N) = 100
• N = 100 F(N) = 10000
• N = 1000 F(N) = 1000000
  通过上面会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。
  另外有些算法的时间复杂度存在最好、平均和最坏情况：
  最坏情况：任意输入规模的最大运行次数(上界)
  平均情况：任意输入规模的期望运行次数
  最好情况：任意输入规模的最小运行次数(下界)
  例如：在一个长度为N数组中搜索一个数据 x
  最好情况：1次找到
  最坏情况(一般时间复杂度考虑的情况)：N次找到
  平均情况：N/2次找到
  在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

4.常见时间复杂度计算举例

【实例1】

计算func2的时间复杂度

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

【实例2】

计算func3的时间复杂度

void func3(int N, int M) {//M和N都属于问题的规模，在计算时间复杂度时都要用上
        int count = 0;
        for (int k = 0; k < M; k++) {//M
            count++;
        }
        for (int k = 0; k < N; k++) {//N
            count++;
        }
        System.out.println(count);

    }

【实例3】

计算func4的时间复杂度

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

【实例4】

计算bubbleSort的时间复杂度

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

【实例5】

计算binarySearch（二分查找）的时间复杂度

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

【实例6】

计算阶乘递归factorial的时间复杂度
递归的时间复杂度 = 递归的次数 * 每次递归后执行的次数

    long factorial(int N) {//递归的时间复杂度 = 递归的次数 * 每次递归后执行的次数
        return N < 2 ? N : factorial(N-1) * N;
    }

【实例7】

计算斐波那契递归fibonacci的时间复杂度

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

4.总结

以后常见的时间复杂度：O（logN） O（N） O（N*longN） O（N^2）

三、空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法

1.常见空间复杂度计算举例

【实例1】

计算bubbleSort的空间复杂度

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

实例1使用了常数个额外空间，所以空间复杂度为 O(1)

【实例2】

计算fibonacci的空间复杂度

 int[] fibonacci(int n) {
        long[] fibArray = new long[n + 1];
        fibArray[0] = 0;
        fibArray[1] = 1;
        for (int i = 2; i <= n ; i++) {
            fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
        }
        return fibArray;
    }

实例2动态开辟了N个空间，空间复杂度为 O(N)

【实例3】

计算阶乘递归Factorial的空间复杂度

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

实例3递归调用了N次，开辟了N个栈帧（每次递归都会开辟一块空间），每个栈帧使用了常数个空间。空间复杂度为O(N)