JAVA数据结构学习（1）——链表

1、概念

1.1 Java

Java一般用来做服务器开发
拿一个淘宝网站举例子：
本质上我们所看到的网页， 是一些数据的集合
我们在我们的电脑上看到这些数据， 都是从淘宝服务器获得的。

Java代码 .java - .class – 根据。Class文件产生的对象才是实际有意义的
数据存储在数据库MySql 管控数据（外存）

Java本质工作核心： 攒数据
Java要不要临时存储数据

// java为了更好更优秀的处理数据（不在完全通过我们手动操作）java提供了一些class-----》 java的集合类
java 最终怎么临时存储数据 = 数组 + 对象

1.2 数据结构和JAVA有什么关系?

（数据结构在JAVA上的表现） 数据结构本身和JAVA没有任何关系, 只不过JAVA中有多种集合、数组、等集合性质的多对象存储结构, 有时候我们希望更便捷,更具有逻辑性的操作这些集合或者数组数据 所以,我们根据数据结构的组织方式, 构建了一些特殊的JAVA集合类 用于描述了一些JAVA对象的底层数据的组成关系
Java的集合类底层组织数据的方式， 是参照某些数据结构（逻辑、思想）来进行的。
Java需要临时存储数据， --》 提供集合类 —》 数组 + 链表

1.3 数据结构的种类和JAVA中的集合类别有哪些?

数据结构： 抽象概念/逻辑概念
集合： 一堆数据
线性表： 有序的序列（操作受限的线性表： 栈：先进后出 队列： 先进先出）
Y = ax + b
树： 一对多的数据关系， 国家， 族谱
图： 多对多的关系： 理论层级
集合类分类:
1, Collection
2, Map

1. 为什么需要集合类？
   很多情况下，我们需要对一组对象进行操作。而且很可能事先并不知道到底有多少个对象。为了解决这个问题呢，Java 就提供了集合类供我们使用。(存储更多类型问题, 扩容问题, 内存空间浪费问题, 数据查找问题, 数据删除问题等等)
2. 集合类的特点： a. 只能存储引用数据类型 b. 可以自动地调整自己的大小
3. 数组和集合类都是容器，它们有何不同？
   a. 数组可以存储基本数据类型的数据，集合不可以。
   b. 数组的长度是固定的，集合可以自动调整自己的大小。
   c. 数组的效率高，相对来说集合效率比较低。
   d. 数组没有API，集合有丰富的API。

数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 公式：数据结构=数据+结构
数据结构用来抽象的描述数据的组织关系 数据：用类型表示 结构：在任何问题中，数据元素都不是孤立存在的，它们之间都存在着某种关系，这种数据元素相互之间的关系称为结构。 元素之间，通常有以下四种基本结构： 集合 线性结构 树形结构 图结构
前面分类中定义的关系，描述的是数据元素间的逻辑关系，因此又称为逻辑结构。 但是仅仅知道数据元素间的逻辑关系是不够的，因为我们得实现自己的数据结构。

我们需要用具体的java代码, 来模拟或者来表示数据结构
因此，我们得关注数据结构在计算机底层是如何表示的？ 数据结构在计算机中的表示，称为数据的物理结构，又称为存储结构或者映像。 结构的表示可以分为两种：顺序存储结构 (顺序映像) 和 链式存储结构 (非顺序映像)。 顺序映像：借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系。(数组) 非顺序映像：借助指示元素存储地址的”指针”，来表示数据元素的逻辑关系。(链表)

2 数组

2.1 数组

Q1: 数组我们都很熟悉，那你理解的数组是什么样的呢？它的最主要特点是什么呢？
数组是连续存储 -->随机访问
Q2: 为什么数组的索引是一般都是从0开始的呢？
第一个层面: 历史遗留问题. 硬件资源, 上世纪40-50年代 微型机, 存储数据
第二个层面: 方便计算.
(下标-1) * 单个元素空间 + 基础位置
Q3: 为什么数组的效率比链表高？
链表: 链表是非连续存储, 如果查找一个元素需要一步一步遍历
数组: 是连续存储, 可以根据下标一步计算出存储位置

2.2 数组的操作

2.2.1 数组的基本操作

(1)添加 (保证元素的顺序)
最好情况：O(1)
最坏情况：移动n个元素，O(n)
平均情况：移动 n/2 个元素，O(n)
(2) 删除 (保证元素的顺序)
最好情况：O(1)
最坏情况：移动n-1个元素，O(n)
平均情况：移动(n-1)/2个元素，O(n)
(3)查找
a. 根据索引查找元素：O(1)
b. 查找数组中与特定值相等的元素 ①大小无序：O(n) ②大小有序：O(log2n)
(4)总结
数组: 添加和删除慢 o(n)
查找快: 尤其根据下标查找 -->大小有序的折半查找

3 链表

3.1 什么是链表

Java中什么是链表, 一个对象持有另一个对象的引用, 另一个对象持有之后的一个对象的引用,…… 构成一个链表

Java的角度，链表的本质: 是java对象的相互持有和引用

Node zs = new Node("zs", null);
Node ls = new Node("ls", null);
Node wu = new Node("wu", null);
Node zl = new Node("zl", null);
zs.next = ls;
ls.next = wu;
wu.next = zl;

得到一个链表如下：zs -> ls ->wu ->zl
形象地说，链表就是用一串链子将结点串联起来。
结点：包含数据域和指针域。
数据域：数据
指针域：下一个结点的地址

3.2 链表的分类

（1）单链表: 在链表中的每一个节点, 都有一个子结点, (尾结点没有子结点)

（2）循环单链表: 单链表的改进, 让单链表的尾结点的下一个结点, 指向头结点

（3）双向链表: 双向链表也是单链表的改进, 让结点不仅可以指向之后的元素, 也可以指向之前的元素

（4）双向循环链表: 双向链表的一个改进, 头元素的之前指向尾元素, 尾元素的之后指向头元素

3.3 单链表操作

单链表：
（1）单链表操作: 查找o(n), 添加和删除o(1)

3.4 双向链表的操作

双向链表操作:查找o(n), 添加和删除o(1)

（1）很容易验证，前面那些操作，双向链表和单链表的时间复杂度是一样的。那为什么在工程上，我们用的一般是双向链表而不是单链表呢？
因为在实际操作过程中, 双向链表根据下标查找的效率, 是高于单链表.

--> 隐性的结论, 在实际工作中, 根据下标查找这个操作相对添加和删除比较频繁

思想: 用空间换时间

（2）求链表的中间元素 判断链表中是否有环(circle)

public class Ex1 {
   
    public static void main(String[] args) {
   

        Node1 node1 = new Node1("1", null);
        Node1 node2 = new Node1("2", node1);
        Node1 node3 = new Node1("3", node2);
        Node1 node4 = new Node1("4", node3);
        Node1 node5 = new Node1("5", node4);
        Node1 node6 = new Node1("6", node5);
        Node1 node7 = new Node1("7", node6);

        // 7 -- 6 --5  --4  --3  --2  --1
        // 快慢指针:
        Node1 f = node7;// 快指针
        Node1 l = node7;// 慢指针
        // 判断快指针的下一个元素, 以及下下个元素, 是不是null, 不是null向后继续移动
        while (f.next != null && f.next.next != null){
   
            f = f.next.next;// 移动两步
            l = l.next; // 移动一步
        }

        // f接近于于尾部的时候, 跳出上述循环
        System.out.println(l.value);

    }
}
class Node1{
   
    String value