1. 算法和数据结构

1.1 什么是算法

//计算a和b的之和
public static int plus(int a, int b){
    return a + b;
}

//计算1+2+3...+n的和
public static int sum(int n){
    int result = 0;
    for(int i = 1; i <= n; i++){
        result += i;
    }
    return result;
}

1.2 什么是数据结构

算法的概念大家大致明白了吧，那数据结构又是什么呢？

我的理解是：数据结构是算法的基石。如果把算法比喻成美丽灵动的舞者，那么数据结构就是舞者脚下广阔而坚定的舞台。

数据结构（data structure），是数据的组织、管理和存储格式，其使用目的是为了高效地 访问 和 修改数据。

那你们知道数据结构都有哪些组成方式吗？

1. 线性结构
   线性结构是最简单的数据结构，包括数组、链表、以及由它们衍生出来的栈、队列、哈希表…
2. 树
   舒适相对复杂的数据结构，其中比较又代表性的是二叉树，由它衍生出了二叉堆之类的数据结构…
3. 图
   图是更为复杂的数据结构，因为在图中会呈现出多对多的关联关系…
4. 其他数据结构
   除了以上所说的，还有像跳表、哈希链表、位图等等，之后都会涉及讲解到的。

有了数据结构这个舞台，算法才可以尽情舞蹈。在解决问题时，不同的算法会选用不同的数据结构。例如排序算法中的堆排序，利用的就是二叉堆这样的一种数据结构；再如缓存淘汰算法LRU（Least Recently Used）利用的就是特殊的数据结构哈希链表。

关于算法在不同数据结构上的操作过程，在后续会进行一一的学习滴。

2. 时间复杂度

2.1 如何判断一个算法的好坏呢？

2.2 基本操作执行次数

关于代码的基本操作执行次数，就是说每条语句在操作中执行多少次。下面就举代码例子说明

代码1：T(n) = 1，执行次数是常量

	public static void test1(int n) {
		
		// if语句执行次数：1
		if (n > 10) { 
			System.out.println("n > 10");
		} else if (n > 5) { // 2
			System.out.println("n > 5");
		} else {
			System.out.println("n <= 5"); 
		}
		
		// for语句执行次数：1(int i = 0) + 4(i < 4) + 4(i ++) + 4(System...) = 13
		for (int i = 0; i < 4; i++) {
			System.out.println("test");
		}
	}

代码2：T(n) = 1 + 3n，执行次数是线性的

public static void test2(int n) {

    // 1(int i = 0) + 3n(i < n, i++, System...)
    for (int i = 0; i < n; i++) {
    System.out.println("test");
	}
}

代码3：T(n) = 3n^2 + 3n + 1，执行次数是用多项式计算的

public static void test3(int n) {

    // 1 + 2n + n * (1 + 3n)【内存循环在外层循环n次基础上在计算次数】
    // = 1 + 2n + n + 3n^2
    // = 3n^2 + 3n + 1
    // O(n^2)
    for (int i = 0; i < n; i++) {
    	for (int j = 0; j < n; j++) {
        	System.out.println("test");
    	}
	}
}

代码4：T(n) = 48n + 1，执行次数是线性的

public static void test4(int n) {

    // 1 + 2n + n * (1 + 15 + 15 + 15)
    // = 1 + 2n + 46n
    // = 48n + 1
    for (int i = 0; i < n; i++) {
    	for (int j = 0; j < 15; j++) {
        	System.out.println("test");
    	}
	}
}

代码5：T(n) = log2(n)，执行次数是对数

public static void test5(int n) {
    // 8 = 2^3
    // 16 = 2^4

    // 3 = log2(8)
    // 4 = log2(16)
    //log2(n)
    while ((n = n / 2) > 0) {
    	System.out.println("test");
	}
}

代码6：T(n) = log5(n)，执行次数是对数

public static void test6(int n) {
    //25 = 5^2

    // log5(n)
    while ((n = n / 5) > 0) {
    	System.out.println("test");
	}
}

代码7：T(n) = 1 + 3*log2(n) + 2 * nlog2(n)，执行次数是对数

public static void test7(int n) {
    // 1 + 2*log2(n) + log2(n) * (1 + 3n)
    //  = 1 + 3*log2(n) + 2 * nlog2(n)
    for (int i = 1; i < n; i = i * 2) {
    	// 1 + 3n
    	for (int j = 0; j < n; j++) {
        	System.out.println("test");
    	}
	}
}

代码8：T(n) = 1 + 3n，执行次数是线性的

public static void test8(int n) {
    int a = 10;
	int b = 20;
	int c = a + b;
	int[] array = new int[n];
	// 1 + n + n + n
	// = 
	for (int i = 0; i < array.length; i++) {
    	System.out.println(array[i] + c);
	}
}

2.3 大O表示法

有了基本操作执行次数的函数T(n)，是否就可以分析和比较代码的运行时间了呢？还是有一定困难的。

例如算法A的执行次数是T(n)=100，算法B的执行次数是T(n)=5n^2，这两个到底谁的运行时间更长一些呢？这就要看n的取值了。

因此，为了解决时间分析的难题，有了渐进时间复杂度( asymptotic time complexity)的概念，其官方定义如下：

若存在函数f(n)，使得当n趋近于无穷大时，T(n)/f(n) 的极限值为不等于零的常数,则称f(n) 是 T(n)的同数量级函数。记作 T(n) = O(f(n))，O为算法的渐进时间复杂度，简称为时间复杂度。

因此，渐进时间复杂度用大写O表示，所以也被称为大O表示法。

这个定义好晦涩呀，看不明白！

直白来说，时间复杂度就是把程序的相对执行时间函数T(n)简化为一个数量级，这个数量级可以是n、n^2、n3等。

如何推导出时间复杂度呢？有如下几个原则：

● 如果运行时间是常数量级，则用常数1表示
● 只保留时间函数中的最高阶项
● 如果最高阶项存在，则省去最高阶项前面的系数

让我们回头看看刚才那些代码。

代码1：
T(n) = 1，只有常数量级，则转化的时间复杂度为：T(n) = O(1)

代码2：
T(n) = 1 + 3n，最高阶项为3n，省去系数3和常量1，则转化的时间复杂度为：T(n) = O(n)

代码3：
T(n) = 3n^2 + 3n + 1，最高阶项为3n^2，省去系数3、3n和常量1，则转化的时间复杂度为：T(n) = O(n^2)

代码3：
T(n) = 1 + 3*log2(n) + 2 * nlog2(n)，最高阶项为 2 * nlog2(n)，省去系数2和常量1，则转化的时间复杂度为：
T(n) = O(nlog(n))

注意细节：
1. 大O表示法仅仅是一种粗略的分析模型，是一种估算，能帮助我们短时间内了解一个算法的执行效率
2. 对数阶的细节
a. 对数阶一般省略底数
log2n = log29 ∗ log9n
b. 所以 log2n 、log9n 统称为 logn

常见种类

根据从小到大排列，常见的算法时间复杂度主要有：
O(1) < O(log N) < O(N) < O(Nlog N) < O(N^2) < O(2^N) < O(N!) < O(N^N)

3. 空间复杂度

3.1 概念定义

class Node {
    int val;
    Node next;
    Node(int x) { val = x; }
}

void algorithm(int N) {
    int num = N;             // 变量
    int[] nums = new int[N]; // 动态数组
    Node node = new Node(N); // 动态对象
}

int test() {
    return 0;
}

void algorithm(int N) {
    for (int i = 0; i < N; i++) {
        test();
    }
}

int algorithm(int N) {
    if (N <= 1) return 1;
    return algorithm(N - 1) + 1;
}

4. 算法优化

● 用尽量少的存储空间
● 用尽量少的执行步骤（执行时间）

根据情况，可以
● 空间换时间
● 时间换空间

关于空间复杂度的知识，我们就介绍到这里。时间复杂度和空间复杂度都是学好算法的重要前提，一定要牢牢掌握哦！

5. 总结