Java数据结构与算法-学习笔记1
1.数据结构与算法概述
1.1什么是数据结构？
官方解释：数据结构是一门研究非数值计算的程序设计问题中的操作对象，以及他们之间的关系和操作等相关问题的学科。
大白话：数据结构就是把数据元素按照一定的关系组织起来的集合，用来组织和存储数据。
1.2数据结构分类
- 逻辑结构 ：按照数据与数据之间的关系进行分类的
- 物理结构 ： 计算机存储角度出发
1.2.1数据结构-逻辑结构
- 集合结构：数据元素之间没有关系
- 线性结构：数据元素之间存在一对一的关系
- 树形结构：数据元素之间存在一对多的层次关系
- 图形结构：数据元素之间是多对多的关系
1.2.2数据结构-物理结构
- 顺序存储结构：数据元素存储在地址连续的存储单元里面
- 链式存储结构：数据元素存储在任意的存储单元里面，链式存储结构引入了指针
1.3什么是算法？
算法是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法解决问题的策略机制，也就是说，能够对一定规范的输入，在有限时间内获得所需要的输出。
- 花最少的时间完成需求
- 占用最少的内存空间完成需求
2.算法分析
我们分析一个算法的运行时间，最重要的就是把核心操作的次数和输入规模关联起来。
2.1算法的时间复杂度分析
- 事后分析估计方法
- 事后分析估计方法
2.1.1算法时间复杂度-函数渐进增长分析
在我们比较算法随着输入规模的增长量时，可以有以下规则：
1.算法函数中的常数可以忽略；
2.算法函数中最高次幂的常数因子可以忽略；
3.算法函数中最高次幂越小，算法效率越高。
以下四种情况：
- 随着输入规模的增大，算法的常数操作可以忽略不计
- 随着输入规模的增大，与最高次项相乘的常数可以忽略
- 最高次项的指数大的，随着n的增长，结果也会变得增长特别快
- 算法函数中n最高次幂越小，算法效率越高
2.1.2算法时间复杂度-大O标记法
在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随着n的变化情况并确定T(n)的量级。算法的时间复杂度，就是算法的时间量度，记作:T(n)=O(f(n))
执行次数=执行时间
用大写O()来体现算法时间复杂度的记法，我们称之为大O记法。一般情况下，随着输入规模n的增大，T(n)增长最慢的算法为最优算法。
如果忽略判断条件的执行次数和输出语句的执行次数，那么当输入规模为n时，以上算法执行的次数分别为：
算法一：3次
算法二：n+3次
算法三：n^2+2次
如果用大O记法表示上述每个算法的时间复杂度，应该如何表示呢？基于我们对函数渐近增长的分析，推导大O阶的表示法有以下几个规则可以使用：
1.用常数1取代运行时间中的所有加法常数；
2.在修改后的运行次数中，只保留高阶项；
3.如果最高阶项存在，且常数因子不为1，则去除与这个项相乘的常数；
所以，上述算法的大O记法分别为：
算法一：O(1)
算法二：O(n)
算法三：O(n^2)
2.1.3常见大O阶
-
线性阶
一般含有非嵌套循环涉及线性阶，线性阶就是随着输入规模的扩大，对应计算次数呈直线增长public static void main(String[] args) { int sum = 0; int n=100; for (int i = 1; i <= n; i++) { sum += i; } System.out.println("sum=" + sum); }
上面这段代码，它的循环的时间复杂度为O(n),因为循环体中的代码需要执行n次
- 平方阶
一般嵌套循环属于这种时间复杂度public static void main(String[] args) { int sum=0,n=100; for (int i = 1; i <=n ; i++) { for (int j = 1; j <=n ; j++) { sum+=i; } } System.out.println(sum); }
上面这段代码，n=100，也就是说，外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环中出来，就需要执行100*100次，也就是n的平方次，所以这段代码的时间复杂度是O(n^2)
-
立方阶
一般三层嵌套循环属于这种时间复杂度public static void main(String[] args) { int x=0,n=100; for (int i = 1; i <=n ; i++) { for (int j = i; j <=n ; j++) { for (int j = i; j <=n ; j++) { x++; } } } System.out.println(x); }
上面这段代码，n=100，也就是说，外层循环每执行一次，中间循环循环就执行100次，中间循环每执行一次，最内层循环需要执行100次，那总共程序想要从这三个循环中出来，就需要执行100100100次，也就是n的立方，所以这段代码的时间复杂度是O(n^3)
-
对数阶
对数，属于高中数学的内容，我们分析程序以程序为主，数学为辅，所以不用过分担心。int i=1,n=100; while(i<n){ i = i*2; }
由于每次i*2之后，就距离n更近一步，假设有x个2相乘后大于n，则会退出循环。由于是2^x=n,得到x=log(2)n,所以这个循环的时间复杂度为O(logn);
对于对数阶，由于随着输入规模n的增大，不管底数为多少，他们的增长趋势是一样的，所以我们会忽略底数。
-
常数阶
一般不涉及循环操作的都是常数阶，因为它不会随着n的增长而增加操作次数。例如：public static void main(String[] args) { int n=100; int i=n+2; System.out.println(i); }
上述代码，不管输入规模n是多少，都执行2次，根据大O推导法则，常数用1来替换，所以上述代码的时间复杂度
为O(1)
下面是对常见时间复杂度的一个总结：
他们的复杂程度从低到高依次为：
O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n3)
根据前面的折线图分析，我们会发现，从平方阶开始，随着输入规模的增大，时间成本会急剧增大，所以，我们的算法，尽可能的追求的是O(1),O(logn),O(n),O(nlogn)这几种时间复杂度，而如果发现算法的时间复杂度为平方阶、立方阶或者更复杂的，那我们可以分为这种算法是不可取的，需要优化。
2.1.4函数调用的时间复杂度分析
案例一：
public static void main(String[] args) {
int n=100;
for (int i = 0; i < n; i++) {
show(i);
}
}
private static void show(int i) {
System.out.println(i);
}
在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部只执行了一行代码，所以show方法的时间复杂度为O(1),那main方法的时间复杂度就是O(n)
案例二：
public static void main(String[] args) {
int n=100;
for (int i = 0; i < n; i++) {
show(i);
}
}
private static void show(int i) {
for (int j = 0; j < i; i++) {
System.out.println(i);
}
}
在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部也有一个for循环，所以show方法的时间复杂度为O(n),那main方法的时间复杂度为O(n^2)
案例三：
public static void main(String[] args) {
int n=100;
show(n);
for (int i = 0; i < n; i++) {
show(i);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.println(j);
}
}
}
private static void show(int i) {
for (int j = 0; j < i; i++) {
System.out.println(i);
}
}
在show方法中，有一个for循环，所以show方法的时间复杂度为O(n),在main方法中，show(n)这行代码内部执行的次数为n，
第一个for循环内调用了show方法，所以其执行次数为n^2,
第二个嵌套for循环内只执行了一行代码，所以其执行次数为n^2,
那么main方法总执行次数为n+n2+n2=2n^2+n。
根据大O推导规则，去掉n保留最高阶项，并去掉最高阶项的常数因子2，所以最终main方法的时间复杂度为O(n^2)
2.1.5 最坏情况
从心理学角度讲，每个人对发生的事情都会有一个预期，比如看到半杯水，有人会说：哇哦，还有半杯水哦！但也有人会说：天哪，只有半杯水了。一般人处于一种对未来失败的担忧，而在预期的时候趋向做最坏的打算，这样即使最糟糕的结果出现，当事人也有了心理准备，比较容易接受结果。假如最糟糕的结果并没有出现，当事人会很快乐。
算法分析也是类似，假如有一个需求：
有一个存储了n个随机数字的数组，请从中查找出指定的数字。
public int search(int num){
int[] arr={11,10,8,9,7,22,23,0};
for (int i = 0; i < arr.length; i++) {
if (num==arr[i]){
return i;
}
}
return -1;
}
最好情况：
查找的第一个数字就是期望的数字，那么算法的时间复杂度为O(1)
最坏情况：
查找的最后一个数字，才是期望的数字，那么算法的时间复杂度为O(n)
平均情况：
任何数字查找的平均成本是O(n/2)
最坏情况是一种保证，在应用中，这是一种最基本的保障，即使在最坏情况下，也能够正常提供服务，所以，除非特别指定，我们提到的运行时间都指的是最坏情况下的运行时间
2.2算法的空间复杂度分析
计算机的软硬件都经历了一个比较漫长的演变史，作为为运算提供环境的内存，更是如此，从早些时候的512k,经历了1M，2M，4M…等，发展到现在的8G，甚至16G和32G，所以早期，算法在运行过程中对内存的占用情况也是一个经常需要考虑的问题。我么可以用算法的空间复杂度来描述算法对内存的占用。
2.2.1java中常见内存占用
-
基本数据类型内存占用情况:
-
计算机访问内存的方式都是一次一个字节
-
一个引用（机器地址）需要8个字节表示：
例如： Date date = new Date(),则date这个变量需要占用8个字节来表示 -
创建一个对象
比如new Date()，除了Date对象内部存储的数据(例如年月日等信息)占用的内存，该对象本身也有内存开销，每个对象的自身开销是16个字节，用来保存对象的头信息。 -
一般内存的使用，如果不够8个字节，都会被自动填充为8字节：
-
java中数组被被限定为对象
他们一般都会因为记录长度而需要额外的内存，一个原始数据类型的数组一般需要24字节的头信息(16个自己的对象开销，4字节用于保存长度以及4个填充字节)再加上保存值所需的内存。
2.2.2算法的空间复杂度
了解了java的内存最基本的机制，就能够有效帮助我们估计大量程序的内存使用情况。
算法的空间复杂度计算公式记作：S(n)=O(f(n)),其中n为输入规模，f(n)为语句关于n所占存储空间的函数。
案例：
对指定的数组元素进行反转，并返回反转的内容。
解法一：
public static int[] reverse1(int[] arr){
int n=arr.length;//申请4个字节 int temp;//申请4个字节
for(int start=0,end=n-1;start<=end;start++,end--){
temp=arr[start];
arr[start]=arr[end];
arr[end]=temp;
}
return arr;
}
解法二：
public static int[] reverse2(int[] arr){
int n=arr.length;//申请4个字节
int[] temp=new int[n];//申请n*4个字节+数组自身头信息开销24个字节
for (int i = n-1; i >=0; i--) {
temp[n-1-i]=arr[i];
}
return temp;
}
忽略判断条件占用的内存，我们得出的内存占用情况如下：
算法一：
不管传入的数组大小为多少，始终额外申请4+4=8个字节；
算法二：
4+4n+24=4n+28;
根据大O推导法则，算法一的空间复杂度为O(1),算法二的空间复杂度为O(n),所以从空间占用的角度讲，算法一要
优于算法二。
由于java中有内存垃圾回收机制，并且jvm对程序的内存占用也有优化（例如即时编译），我们无法精确的评估一个java程序的内存占用情况，但是了解了java的基本内存占用，使我们可以对java程序的内存占用情况进行估算。
由于现在的计算机设备内存一般都比较大，基本上个人计算机都是4G起步，大的可以达到32G，所以内存占用一般情况下并不是我们算法的瓶颈，普通情况下直接说复杂度，默认为算法的时间复杂度。
但是，如果你做的程序是嵌入式开发，尤其是一些传感器设备上的内置程序，由于这些设备的内存很小，一般为几kb，这个时候对算法的空间复杂度就有要求了，但是一般做java开发的，基本上都是服务器开发，一般不存在这样的问题。
2801
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
