第六章 Java数据结构和算法 之 其他数据结构(二)

发布于:2021-07-22 08:26:03



文章目录
一. 数组与链表1.1 数组1.2 链表1.3 数组与链表区别
二. 堆 & 栈2.1 堆2.2 栈2.3 Java中堆 & 栈
三. 树 & 图3.1 二叉树3.1.1 定义3.1.2 存储结构3.1.3 遍历3.1.4 B+树
3.2 图
四. 其他4.1 深拷贝和浅拷贝



一. 数组与链表
1.1 数组
1.2 链表
1.3 数组与链表区别
内存存储:
① 数组从栈中分配空间,对程序员方便快速,自由度小。
② 链表从堆中分配内存。自由度大但申请管理比较麻烦。逻辑结构:
① 数组必须事先定义固定的长度(元素个数),不能适应数据动态地增减情况(数据插入、删除比较麻烦)。当数据增加时,可能会超出数组的最大空间(越界);当数据减少时,造成内存浪费。
② 链表动态地进行存储分配,可以适应数据动态地增减情况(数据插入删除简单)(数组中插入、删除数据项时,需要移动其他项),但链表查找元素时需要遍历整个链表。
二. 堆 & 栈
2.1 堆
2.2 栈
2.3 Java中堆 & 栈

(1)java 内存
java中的内存,分为两种,一为堆内存,二为栈内存。
栈内存
在函数中定义的基本类型的变量和对象的引用变量都是在函数的栈内存中分配。
当在一段代码块中声明了一个变量时,java就会在栈内存中为这个变量分配内存空间,当超过变量的作用域之后,java也会自动释放为该变量分配的空间,而这个回收的空间可以即刻用作他用。
堆内存
堆内存用于存放由new创建的对象和数组。
在堆内存中分配的内存空间,由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后,还可以在栈中定义一个特殊的变量,变量的值就等于数组或对象在堆内存中的首地址,而这个栈中的特殊变量,也就成为数组或对象的引用变量。以后可以在程序中使用栈内存中的引用变量访问堆内存中的数组或对象了。引用变量相当于是为数组或对象起的一个别名,或者是代号。
数组和对象在没有引用变量指向它的时候,才变成垃圾,不能被继续使用,但是仍然会占用堆内存空间,而后在一个不确定的时间内,由java虚拟机自动垃圾回收器回收,这也是java程序为什么会占用很大内存的原因。
(2)java 中内存分配策略
根据编译原理的观点,程序运行时的内存分配,有三种策略,分别为静态的、堆式的、栈式的。
静态存储分配指的是在编译时就能确定每个数据目标在运行时的存储空间需求,因而在编译时就给它们分配了固定的内存空间。这种分配方式要求程序代码中不能有可变数据结构(例如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译时编译程序无法准确计算所需的存储空间大小。
栈式存储分配也可以成为动态存储分配,是由一个类似于堆栈的运行栈来实现的。和静态存储分配相反,在栈式分配方案中,程序对于存储空间的需要在编译时是未知的,只有在运行的时候才能知道。但是规定在运行进入一个程序模块时,必须要知道该程序模块所需的数据区大小才能为其分配内存。同我们日常了解的栈一致,栈式存储分配遵照先进后出的原则进行分配。
堆式存储分配专门负责在编译时或运行时程序模块入口处都无法确定存储要求的数据结构的分配,比如可变长度串和对象实例。堆内存由大片的可利用块或空闲块组成,堆中的内存也可以根据任意的顺序进行分配和释放。
(3)堆&栈 比较
从通俗化的角度来说,堆是用来存放对象的,栈是用来存放执行程序的
在编程中,例如在C/C++中,所有的方法调用都是通过栈来进行的,所有的局部变量、形式参数也都是通过栈来分配内存的。使用的时候,根据栈的工作原理,从栈顶向上用即可,Stack Pointer会自动指引程序到存储位置,程序只需要进行存储即可。退出函数的时候,修改栈指针即可将栈中存储的内容销毁。这种模块速度最快,适合用户存储执行程序。但是应当注意的是,在进行内存分配是,比如为一个即将要调用的程序模块分配数据区时,应当实现知道这个所需数据区的大小,也就是说虽然分配工作是在运行程序的时候进行的,但是分配的大小是在运行程序之前就知道的,这个是编译时确定的,而不是运行时。
堆是应用程序在运行过程中请求操作系统给分配的内存,由于是操作系统管理的内存分配,所以在分配和销毁是都需要占用时间,因此堆的工作效率比较低。但是堆的优点在于,编译器不需要知道从堆中分配了多少的内存空间,也不需要知道存储的数据要在堆中停留多长的时间,这也就使得用堆来保存数据有着更大的灵活性。事实上,面向对象的多态性的实现,堆内存的分配必不可少,因为多态对象所需的数据区大小只有在运行时确定了对象以后才能知道。在java中,创建对象只需要使用new关键字即可,执行这些代码时,就会在堆中自动进行数据的保存。也就是因为这种灵活分配存储空间的特性,堆内存分配的工作效率不高。
(4)JVM中的堆和栈
堆和栈都是java用来在内存中存放数据的地方,与C++不同的是,java自动管理堆和栈,程序员不能自行设置堆和栈。
java中的堆就是运行时存储数据的区域,类的实例对象可以通过new、new Array等指令建立从中分配空间,这些空间不需要程序代码来显式释放。堆是由jvm自动垃圾回收器负责的,堆的优势是可以动态的分配内存大小,生存周期也不用实现告诉编译器,因为空间是在运行时动态进行内存分配的。如果堆中的数据确认为垃圾,则jvm的自动垃圾回收器汇自动回收相应的空间。但是缺点是,由于实在运行时动态进行空间分配,存取速度较慢。
栈的优势是:存取的速度都比堆要快,仅次于寄存器。栈数据可以共享,但是缺点时,栈空间中的数据大小和生存期必须是确定的,缺乏灵活性。栈主要存放一些基本类型的变量int, short, long, byte, float, double, boolean, char和对象句柄。
栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义:


int a = 3;
int b = 3;

编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用,然后查找栈中是否有3这个值,如果没找到,就将3存放进来,然后将a指向3。接着处理int b = 3;在创建完b的引用变量后,因为在栈中已经有3这个值,便将b直接指向3。这样,就出现了a与b同时均指向3的情况。这时,如果再令a=4;那么编译器会重新搜索栈中是否有4值,如果没有,则将4存放进来,并令a指向4;如果已经有了,则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的,因为这种情况a的修改并不会影响到b, 它是由编译器完成的,它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态,会影响到另一个对象引用变量。


三. 树 & 图
3.1 二叉树
3.1.1 定义
3.1.2 存储结构
3.1.3 遍历

(1)深度优先遍历
二叉树的深度优先遍历的非递归的通用做法是采用栈。
对每一个可能的分支路径深入到不能再深入为止,而且每个结点只能访问一次。要特别注意的是,二叉树的深度优先遍历比较特殊,可以细分为先序遍历、中序遍历、后序遍历。具体说明如下:


先序遍历:对任一子树,先访问根,然后遍历其左子树,最后遍历其右子树。中序遍历:对任一子树,先遍历其左子树,然后访问根,最后遍历其右子树。后序遍历:对任一子树,先遍历其左子树,然后遍历其右子树,最后访问根。

(2)广度优先遍历
又叫层次遍历,从上往下对每一层依次访问,在每一层中,从左往右(也可以从右往左)访问结点,访问完一层就进入下一层,直到没有结点可以访问为止。


3.1.4 B+树

(1)简介
B树是为磁盘或其他直接存取的辅助存储设备而设计的一种*衡搜索树。B树类似于红黑树,但它们在降低磁盘I/O操作数方面要更好一些。现在许多数据库系统使用B树或者B树的变种(B+树和B树)来存储信息。
B+树是B树的一种变形,它把所有的卫星数据都存储在叶节点中,内部节点只存放关键字和孩子指针,因此最大化了内部节点的分支因子,所以B+树的遍历也更加高效(B树需要以中序的方式遍历节点,而B+树只需把所有叶子节点串成链表就可以从头到尾遍历)。
B+树还有一个最大的好处,方便扫库,B树必须用中序遍历的方法按序扫库,而B+树直接从叶子结点挨个扫一遍就完了,B+树支持range-query非常方便,而B树不支持。这是数据库选用B+树的最主要原因。
(2)定义
每个节点node有下面的属性: n个关键字key[1],key[2], … ,key[n],以非降序存放,使得key[1]≤key[2]≤…≤key[n];
isRoot,一个布尔值,如果node是根节点,则为TRUE;否则为FALSE;
isLeaf,一个布尔值,如果node是叶子节点,则为TRUE;否则为FALSE;
Node
类型的parent指针,指向该节点的父节点
每个内部节点还包含n个
指向其孩子children[0],children[1], … , children[n],叶子节点没有孩子。(注:此处有争议,B+树到底是与B 树n-1个关键字有n棵子树保持一致,还是B+树n个关键字的结点中含有n棵子树;两种定义都可以,只要自己实现的时候统一用一种就行。如无特殊说明,以下的都是后者:即n个关键字对应n棵子树);
内部节点的关键字对存储在各子树中的关键字范围加以分割:如果key[i]为任意一个存储在内部节点中的关键字,childNum[i]为该节点的对应下标的子树指针指向的节点的任意一个关键字,那么 key[1] ≤ childNum[1] < key[2] ≤ childNum[2] < key[3] ≤ childNum[3] < … < key[n] ≤ childNum[n]
任何和关键字相联系的**“卫星数据(satellite information)” **将与关键字一样存放在叶子节点中,一般地,可能只是为每个关键字对应的”卫星数据”存放一个指针,指针指向存放实际数据的磁盘页,匹配了某个叶子节点的关键字即可通过该指针找到其他对应数据。
每个叶子节点还有指向下一个节点的指针next,方便遍历整棵B+树。
每个叶子节点具有相同的深度,即树的高度h。
每个节点所包含的关键字个数有上界和下界,用一个被B+树的最小度数(minmum degree)的固定整数t≥2来表示这些界: 除了根节点以外的每个节点必须至少有t个关键字。因此,除了根节点以外的每个内部节点至少有t个孩子
每个节点至多有2t个关键字,因此,一个内部节点至多可有2t个孩子。当一个节点恰好有2t个关键字时,称该节点是满的。
结合以上的具体定义,下面这张图更加详细的描述了一棵具体的B+树。

(3)插入
内部节点并不存储真正的信息,而是保存其叶子节点的最小值作为索引。每次插入删除都进行更新(此时用到parent指针),保持最新状态。
关于所有叶子节点都处于同一深度是如何实现的?这与B+树具体的插入和删除算法有关。简单解释一下插入时的情况,根据插入值的大小,逐步向下直到对应的叶子节点。如果叶子节点关键字个数小于2t,则直接插入值或者更新卫星数据;如果插入之前叶子节点已经满了,则分裂该叶子节点成两半,并把中间值提上到父节点的关键字中,如果这导致父节点满了的话,则把该父节点分裂,如此递归向上。所以树高是一层层的增加的,叶子节点永远都在同一深度。下面是我实现的B+树中的插入代码的片段:


public void insert(Comparable key, Object obj, BPlusTree tree)
{
// 叶子节点则插入
if (isLeaf) {
// 不需要分裂直接插入
if (containsKeyword(key) || keywords.size() < tree.getDegree()) {
insertInNotFull(key, obj);
// 直接插入
if (parent != null) {
parent.updateAfterInsert(tree); // 更新父节点的信息(将最小的值存到父节点的关键字中作为索引)
}
} else { // 需要分裂成左右两个节点
splitNode(key, obj, tree);
}
} else { // 如果不是叶子节点则继续往下搜索
Node leafNode = downToLeaf(key); // 逐步向下到对应的叶子节点
leafNode.insert(key, obj, tree);
}
}

3.2 图
四. 其他
4.1 深拷贝和浅拷贝

    对象的创建方法
    clone顾名思义就是复制, 在Java语言中, clone方法被对象调用,所以会复制对象。所谓的复制对象,首先要分配一个和源对象同样大小的空间,在这个空间中创建一个新的对象。那么在java语言中,有几种方式可以创建对象呢?
    (1) 使用new操作符创建一个对象
    new操作符的本意是分配内存。程序执行到new操作符时, 首先去看new操作符后面的类型,因为知道了类型,才能知道要分配多大的内存空间。分配完内存之后,再调用构造函数,填充对象的各个域,这一步叫做对象的初始化,构造方法返回后,一个对象创建完毕,可以把他的引用(地址)发布到外部,在外部就可以使用这个引用操纵这个对象。
    (2)使用clone方法复制一个对象
    lone在第一步是和new相似的, 都是分配内存,调用clone方法时,分配的内存和源对象(即调用clone方法的对象)相同,然后再使用原对象中对应的各个域,填充新对象的域, 填充完成之后,clone方法返回,一个新的相同的对象被创建,同样可以把这个新对象的引用发布到外部。

    引用的拷贝


//引用拷贝
private static void copyReferenceObject(){
Person p = new Person(23, "zhang");
Person p1 = p;
System.out.println(p);
System.out.println(p1);
}

这里打印的结果:
com.yaolong.clone.Person@3654919e
com.yaolong.clone.Person@3654919e
可以看到,打印的结果是一样的,也就是说,二者的引用是同一个对象,并没有创建出一个新的对象。
而下面所说的浅拷贝与深拷贝,都是对象拷贝。
深拷贝和浅拷贝是只针对Object和Array这样的引用数据类型的。
深拷贝和浅拷贝的示意图大致如下:



浅拷贝只复制指向某个对象的指针,而不复制对象本身,新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象,新对象跟原对象不共享内存,修改新对象不会改到原对象。


    浅拷贝
    浅拷贝是按位拷贝对象,它会创建一个新对象,这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型,拷贝的就是基本类型的值;如果属性是内存地址(引用类型),拷贝的就是内存地址 ,因此如果其中一个对象改变了这个地址,就会影响到另一个对象。
    实现对象拷贝的类,必须实现Cloneable接口,并覆写clone()方法。
    Persion类:

package com.yaolong.clone;

public class Person implements Cloneable{

//private Integer age;
private int age;//阿里规范中规定pojo类中的属性强制使用包装类型,这里只是测试

private String name;

public Person(Integer age, String name) {
super();
this.age = age;
this.name = name;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Override
public String toString() {
return super.toString();
}

@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

//对象拷贝
private static void copyRealObject() throws CloneNotSupportedException{
Person p = new Person(23, "zhang");
Person p1 = (Person) p.clone();
System.out.println(p);
System.out.println(p1);
}

这里打印的结果:


com.yaolong.clone.Person@28084850
com.yaolong.clone.Person@37c390b8

可以看出,二者的对象地址不一样,因此实现了拷贝。
但是还是有个问题,就是Person类中有一个String类型的引用对象name,它真的也被拷贝过去了吗,还是说依然是引用的是同一个name对象呢,在上面的代码基础上,我们继续打印:


System.out.println("pName:"+p.getName().hashCode());
System.out.println("p1Name:"+p1.getName().hashCode());

这里打印的结果:


pName:115864556
p1Name:115864556

可见,二者的name属性依然是指向同一个对象。上面故意将age属性改为int基本类型,因为基本数据类型是不存在引用问题。
由上可知,从Object中继承过来的clone默认实现的是浅拷贝。


    深拷贝
    深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。
    如果想要深拷贝一个对象, 这个对象必须要实现Cloneable接口,实现clone方法,并且在clone方法内部,把该对象引用的其他对象也要clone一份 , 这就要求这个被引用的对象必须也要实现Cloneable接口并且实现clone方法。
    那么,按照上面的结论, Body类组合了Head类, 而Head类组合了Face类,要想深拷贝Body类,必须在Body类的clone方法中将Head类也要拷贝一份,此时两个独立的Body对象内的head引用已经指向了独立的两个Head对象,但这对于两个Head对象来说,他们指向了同一个Face对象,为了使Head对象完全独立。只要在拷贝Head对象的时候,也将Face对象拷贝一份就可以了。这需要让Face类也实现Cloneable接口,实现clone方法,并且在在Head对象的clone方法中,拷贝它所引用的Face对象。

static class Body implements Cloneable{
public Head head;
public Body() {}
public Body(Head head) {this.head = head;}

@Override
protected Object clone() throws CloneNotSupportedException {
Body newBody = (Body) super.clone();
newBody.head = (Head) head.clone();
return newBody;
}

}

static class Head implements Cloneable{
public Face face;

public Head() {}
public Head(Face face){this.face = face;}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

static class Head implements Cloneable{
public Face face;

public Head() {}
public Head(Face face){this.face = face;}
@Override
protected Object clone() throws CloneNotSupportedException {
//return super.clone();
Head newHead = (Head) super.clone();
newHead.face = (Face) this.face.clone();
return newHead;
}
}

static class Face implements Cloneable{
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

public static void main(String[] args) throws CloneNotSupportedException {

Body body = new Body(new Head(new Face()));

Body body1 = (Body) body.clone();

System.out.println("body == body1 : " + (body == body1) );

System.out.println("body.head == body1.head : " + (body.head == body1.head));

System.out.println("body.head.face == body1.head.face : " + (body.head.face == body1.head.face));


}


再次运行上面的示例,得到的运行结果如下:
body == body1 : false
body.head == body1.head : false
body.head.face == body1.head.face : false
这说名两个Body已经完全独立了,他们间接引用的face对象已经被拷贝,也就是引用了独立的Face对象。
如果在拷贝一个对象时,要想让这个拷贝的对象和源对象完全彼此独立,那么在引用链上的每一级对象都要被显式的拷贝。所以创建彻底的深拷贝是非常麻烦的,尤其是在引用关系非常复杂的情况下, 或者在引用链的某一级上引用了一个第三方的对象, 而这个对象没有实现clone方法, 那么在它之后的所有引用的对象都是被共享的。 举例来说,如果被Head引用的Face类是第三方库中的类,并且没有实现Cloneable接口,那么在Face之后的所有对象都会被拷贝前后的两个Body对象共同引用。假设Face对象内部组合了Mouth对象,并且Mouth对象内部组合了Tooth对象。
说明: 对象的 clone 方法默认是浅拷贝,若想实现深拷贝需要重写 clone 方法实现属性对象的拷贝。

相关推荐