数据结构的加强甜点-序列1

尾递归

问题

介绍

尾递归

问题

在空间复杂度这块，有个O(n)示例如下：

void recur(int n) {
    if (n == 1) return;
    return recur(n - 1);
}

这很明显是个尾递归，未啥没优化成O(1)

介绍

在传统的递归中，典型的模型是首先执行递归调用，然后获取递归调用的返回值并计算结果
以这种方式，在每次递归调用返回之前，你不会得到计算结果
这样做的缺点有二：
效率低，占内存
如果递归链过长，可能会statck overflow
若函数在尾位置调用自身（或是一个尾调用本身的其他函数等等），则称这种情况为尾递归
尾递归也是递归的一种特殊情形
尾递归是一种特殊的尾调用，即在尾部直接调用自身的递归函数

特点

对尾递归的优化也是关注尾调用的主要原因
尾递归在普通尾调用的基础上，多出了2个特征：
在尾部调用的是函数自身（Self-called）；
可通过优化，使得计算仅占用常量栈空间 (Stack Space)

原理

当编译器检测到一个函数调用是尾递归的时候，它就覆盖当前的活动记录而不是在栈中去创建一个新的
编译器可以做到这点，因为递归调用是当前活跃期内最后一条待执行的语句，于是当这个调用返回时栈帧中并没有其他事情可做，因此也就没有保存栈帧的必要了
通过覆盖当前的栈帧而不是在其之上重新添加一个，这样所使用的栈空间就大大缩减了，这使得实际的运行效率会变得更高

答案

这段代码是尾递归，理论上可以将空间复杂度优化至O(1)
不过绝大多数编程语言（例如 Java, Python, C++, Go, C# 等）都不支持自动优化尾递归，因此在这里写O(n)

数组栈堆内存分配

前言

栈内存分配由编译器自动完成，而堆内存由程序员在代码中分配（请注意这里的栈和堆不是数据结构中的栈和堆）
1.栈不灵活，分配的内存大小不可更改；堆相对灵活，可以动态分配内存；
2.栈是一块比较小的内存，容易出现内存不足；堆内存很大，但是由于是动态分配，容易碎片化，管理堆内存的难度更大、成本更高；
3.访问栈比访问堆更快，因为栈内存较小、对缓存友好，堆帧分散在很大的空间内，会出现更多的缓存未命中；

分析

假设刚开始，堆、栈是空的
1---声明数组：
int[] array = null;
array只是声明而已，会在栈为其开辟一个空间，堆为开辟空间
2---创建数组：
array = new int[10];
创建数组，在堆里面开辟空间储存数组，同时栈中的array指向该存储空间

3---给数组赋值：
for(int i = 0; i < 10; i++) array[i]=i+1;

再分析

int[] a = {2,3,4};
int[] b = new int[4];
b = a;

// 定义Person类
public class Person {                                                  
	public int age;
	public double height;
    public void info() {
            System.out.println("年龄：" + age + ",身高：" + height);
    }
}

// 测试类
public class ArrayTest {           
    public static void main(String[] args) {

        // 定义一个students数组变量，其类型是Person[]
        Person[] students = new Person[2];

        Person zhang = new Person();
        zhang.age = 10;
        zhang.height = 130;

        Person lee = new Person();
        lee.age = 20;
        lee.height = 180;

        //将zhang变量赋值给第一个数组元素
        students[0] = zhang;
        //将lee变量赋值给第二个数组元素
        students[1] = lee;

        //下面两行代码结果一样，因为lee和student[1]
        //指向的是同一个Person实例
        lee.info();
        students[1].info();
    }
}

Person[] students = new Person[2] 时

Person zhang = new Person();
zhang.age = 10;
zhang.height = 130;
Person lee = new Person();
lee.age = 20;
lee.height = 180; 时

将zhang变量赋值给第一个数组元素
students[0] = zhang;
将lee变量赋值给第二个数组元素
students[1] = lee; 时

所谓多维数组

先说结论：
Java语言里提供了支持多维数组的语法
如果从数组底层的运行机制上来看，没有多维数组！
开始讲解：
Java里数组是引用类型，因此数组变量其实是一个引用
什么是引用？
引用=起个别名；并不另外开辟内存单元；但占用内存的同一位置
什么是引用类型？
值类型直接存储其值，而引用类型存储对其值的引用
这个引用指向真实的数组内存，如果数组元素也是引用类型，也就是多维数组
那是不是最终都指向一维数组的内容
举例说明：
定义一个二维数组，当作一维数组遍历
结果为null null null null,
说明二维数组其实就是一维数组里元素的引用类型
即一个长度为2的数组

// 定义一个二维数组
int[][] a;
// 把a当作一维数组进行初始化，初始化a是一个长度为4的数组
// a数组的元素又是引用类型
a = new int[4][];
// 把a当作一维数组进行遍历，遍历a的每个元素
for (int i = 0; i < a.length; i++) {
    System.out.println(a[i]);// null null null null
}
// 初始化a的第一个元素
a[0] = new int[2];
// 访问a数组的第一个元素所指向数组的第二个元素
a[0][1] = 6;
// a数组的第一个元素是一个一维数组，遍历这个一维数组
for (int i = 0; i < a[0].length; i++) {
    System.out.println(a[0][i]);
}

int[][] a;
a = new int[4][]; 时
a[0] = new int[2];
a[0][1] = 6; 时
程序采用动态初始化a[0]数组，
因此系统将为a[0]所引用数组的每个元素默认分配0，
程序显示的将a[0]的第二个元素赋值为6
再举例：
int[][] b = new int[3][4];
同时初始化二维数组的两个维数
该代码定义了一个b数组变量，这个数组变量指向一个长度为3的数组
这个数组的元素又是一个数组类型，它们各指向对应长度为4的int[]数组
每个数组元素的值为0

程序局部性原理应用

除了查找性能链表不如数组外
还有一个优势让数组的性能高于链表,即程序局部性原理
这里简介一下，这属于组成原理的内容
我们知道 CPU 运行速度是非常快的，如果 CPU 每次运算都要到内存里去取数据无疑是很耗时的
所以在 CPU 与内存之间往往集成了挺多层级的缓存，这些缓存越接近CPU，速度越快
所以如果能提前把内存中的数据加载到如下图中的 L1, L2, L3 缓存中，那么下一次 CPU 取数的话直接从这些缓存里取即可，能让CPU执行速度加快
那什么情况下内存中的数据会被提前加载到 L1,L2,L3 缓存中呢
答案是当某个元素被用到的时候，那么这个元素地址附近的的元素会被提前加载到缓存中
以整型数组 1，2，3，4为例
当程序用到了数组中的第一个元素（即 1）时
由于 CPU 认为既然 1 被用到了，那么紧邻它的元素 2，3，4 被用到的概率会很大，所以会提前把 2，3，4 加到 L1,L2,L3 缓存中去，这样 CPU 再次执行的时候如果用到 2，3，4，直接从 L1,L2,L3 缓存里取就行了，能提升不少性能

数据结构的加强甜点-序列1

尾递归

问题

介绍

特点

原理

答案

数组栈堆内存分配

前言

分析

再分析

所谓多维数组

程序局部性原理应用

猜你喜欢