数据结构和算法基础概念

一、数据结构和算法的重要性

1. 算法是程序的灵魂，优秀的程序可以在海量数据计算时，依然保持高速计算
2. 一般来讲 程序会使用了内存计算框架(比如Spark)和缓存技术(比如Redis等)来优化程序,再深入的思考一下，这些计算框架和缓存技术， 它的核心功能是哪个部分呢？
3. 拿实际工作经历来说, 在Unix下开发服务器程序，功能是要支持上千万人同时在线， 在上线前，做内测，一切OK,可上线后，服务器就支撑不住了, 公司的CTO对代码进行优化，再次上线，坚如磐石。你就能感受到程序是有灵魂的，就是算法。
4. 目前程序员面试的门槛越来越高，很多一线IT公司(大厂)，都会有数据结构和算法面试题(负责的告诉你，肯定有的)
5. 如果你不想永远都是代码工人,那就花时间来研究下数据结构和算法

二、数据结构和算法的关系

• 数据data结构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了数据结构.学好数据结构可以编写出更加漂亮,更加有效率的代码。
• 要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决.
• 程序 = 数据结构 + 算法
• 数据结构是算法的基础, 换言之，想要学好算法，需要把数据结构学到位。

三、数据结构概述

1、数据结构

• 什么是数据结构？
  数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。
  数据结构包括：线性结构和非线性结构。

• 数据的存储结构
  顺序存储结构
  顺序存储结构： 是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的。数组就是顺序存储结构的典型代表。
  链式存储结构
  链式存储结构： 是把数据元素存放在内存中的任意存储单元里，也就是可以把数据存放在内存的各个位置。这些数据在内存中的地址可以是连续的，也可以是不连续的。

和顺序存储结构不同的是，链式存储结构的数据元素之间是通过指针来连接的，我们可以通使用指针来找到某个数据元素的位置，然后对这个数据元素进行一些操作。
顺序存储结构和链式存储结构的区别。

• 数据的逻辑结构
  指反映数据元素之间的逻辑关系的数据结构，其中的逻辑关系是指数据元素之间的前后关系，而与他们在计算机中的存储位置无关。逻辑结构分为以下四类：
  1.集合结构
  集合结构中的数据元素同属于一个集合，他们之间是并列的关系，除此之外没有其他关系。如下图，可以很好的表示集合结构中的元素之间的关系：
  
  2.线性结构
  线性结构中的元素存在一对一的相互关系。如下图，可以很好的表示线性结构中的元素之间的关系：
  
  3.树形结构
  树形结构中的元素存在一对多的相互关系。如下图，可以很好的表示树形结构中的元素之间的关系：
  
  4.图形结构
  图形结构中的元素存在多对多的相互关系。如下图，可以很好的表示图形结构中的元素之间的关系：
  

四、算法分析

不同的算法执行过程和执行效率可能差别很大，为此必须对算法的基本性能进行分析和评价，通常从正确性、可读性、健壮性、效率等几个方面来评价算法的性能。
正确性： 算法的执行结果应当满足预先规定的功能和性能要求。
可读性： 一个算法应当思路清晰，层次分明、简单明了、易读易懂。
健壮性： 当输入不合法数据时，应能作合适处理，不至于引起严重的后果。
效率： 算法的效率指的是时间效率和空间效率。所谓时间效率是指执行一个算法所花费的时间。二空间效率指的是执行一个算法所需要的空间大小。
从理论角度来讲，一般讲“算法分析”更多指算法时间的效率分析，也称算法时间复杂度。
对于计算机来说，最重要的资源是时间（CPU时间）和空间（内存）。因此一般意义上讲算法分析指时间复杂度和空间复杂度。

4.1、算法的时间复杂度

度量一个程序(算法)执行时间的两种方法

事后统计的方法
这种方法可行, 但是有两个问题：一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；二是所得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式，要在同一台计算机的相同状态下运行，才能比较那个算法速度更快。

事前估算的方法通过分析某个算法的时间复杂度来判断哪个算法更优.

4.1.1、时间频度

基本介绍
时间频度： 一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
举例说明：
如：计算1-100所有数字之和, 我们设计两种算法：

• 第一种：使用for循环计算

	public void test1(){
		int total = 0;
		int end = 100;
		//使用for循环计算
		for(int i = 1;i <= end;i++){
			total += i;
		}
	}

时间复杂度：T(n)=n+1

• 第二种：直接计算

	public void test2(){
		int total = 0;
		int end = 100;
		total = (1+end) * end/2;
	}

时间复杂度：T(n) = 1

举个例子：忽略系数


由上面两张图可得如下结论：

1. 2n+20 和 2n 随着n 变大，执行曲线无限接近, 20可以忽略
2. 3n+10 和 3n 随着n 变大，执行曲线无限接近, 10可以忽略

举个例子：忽略低次项

结论:

1. 2n^2+3n+10 和 2n^2 随着n 变大, 执行曲线无限接近, 可以忽略 3n+10
2. n^2+5n+20 和 n^2 随着n 变大,执行曲线无限接近, 可以忽略 5n+20

举例说明：忽略系数

结论:

1. 随着n值变大，5n^2+7n 和 3n^2 + 2n ，执行曲线重合, 说明 这种情况下, 5和3可以忽略。
2. 而n^3+5n 和 6n^3+4n ，执行曲线分离，说明多少次方式关键

4.1.2、时间复杂度

时间复杂度

1. 一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。

2. T(n) 不同，但时间复杂度可能相同。 如：T(n)=n²+7n+6 与 T(n)=3n²+2n+2 它们的T(n) 不同，但时间复杂度相同，都为O(n²)。

3. 计算时间复杂度的方法：

• 用常数1代替运行时间中的所有加法常数 T(n)=n²+7n+6 => T(n)=n²+7n+1
• 修改后的运行次数函数中，只保留最高阶项 T(n)=n²+7n+1 => T(n) = n²
• 去除最高阶项的系数 T(n) = n² => T(n) = n² => O(n²)

4.1.3、常见的时间复杂度

常数阶O(1)
对数阶O(log2n)
线性阶O(n)
线性对数阶O(nlog2n)
平方阶O(n^2)
立方阶O(n^3)
k次方阶O(n^k)
指数阶O(2^n)

常见的时间复杂度对应图：

说明：

• 常见的算法时间复杂度由小到大依次为：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜ Ο(nk) ＜Ο(2n) ，随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低
• 从图中可见，我们应该尽可能避免使用指数阶的算法

（1）常数阶O(1)

无论代码执行了多少行，只要是没有循环等复杂结构，那这个代码的时间复杂度就都是O(1)

		int i = 1;
		int j = 2;
		i++;
		++j;
		int k = i + j;

上述代码在执行的时候，它消耗的时候并不随着某个变量的增长而增长，那么无论这类代码有多长，即使有几万几十万行，都可以用O(1)来表示它的时间复杂度。

（1）对数阶O(log2n)

public void test2(int n){
		int i = 1;
		while (i < n){
			i = i * 2;
		}
	}

说明：
  在while循环里面，每次都将 i 乘以 2，乘完之后，i 距离 n 就越来越近了。假设循环x次之后，i 就大于 2 了，此时这个循环就退出了，也就是说 2 的 x 次方等于 n，那么 x = log2n也就是说当循环 log2n 次以后，这个代码就结束了。因此这个代码的时间复杂度为：O(log2n) 。 O(log2n) 的这个2 时间上是根据代码变化的，i = i * 3 ，则是 O(log3n) .

（1）线性阶O(n)

	public void test2(int n){
		int j = 0;
		for (int i = 1;i <= n;i++){
			j = i;
			j++;
		}
	}

说明：
  这段代码，for循环里面的代码会执行n遍，因此它消耗的时间是随着n的变化而变化的，因此这类代码都可以用O(n)来表示它的时间复杂度

（1）线性对数阶O(nlogN)

	public void test2(int n){
		int j = 1;
		for (int i = 1;i <= n;i++){
			while (j < n){
				j = j * 2;
			}
		}
	}

说明：
  线性对数阶O(nlogN) 其实非常容易理解，将时间复杂度为O(logn)的代码循环N遍的话，那么它的时间复杂度就是 n * O(logN)，也就是了O(nlogN)

（1）平方阶O(n²)

public void test2(int n){
		for (int i = 1;i <= n;i++){
			for (int j = 1;j <= n;j++){
				j = i;
				j++;
			}
		}
	}

说明：
  平方阶O(n²) 就更容易理解了，如果把 O(n) 的代码再嵌套循环一遍，它的时间复杂度就是 O(n²)，这段代码其实就是嵌套了2层n循环，它的时间复杂度就是 O(nn)，即 O(n²) 如果将其中一层循环的n改成m，那它的时间复杂度就变成了 O(mn)

4.2、算法空间复杂度简介

4.2.1、基本介绍

1. 类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间，它也是问题规模n的函数。
2. 空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序和归并排序算法就属于这种情况
3. 在做算法分析时，主要讨论的是时间复杂度。从用户使用体验上看，更看重的程序执行的速度。一些缓存产品(redis, memcache)和算法(基数排序)本质就是用空间换时间.