数据结构与算法|线性结构
- 第二章 线性结构
- 2.1 多项式表示
- 2.2 什么是线性表
- 2.3 线性表的实现方式
- 2.3.1 线性表的顺序存储实现
- 2.3.2 线性表的链式存储实现
- 1. 单链表实现
- 2. 双链表实现
上篇：第一章、绪论
第二章 线性结构
线性结构是数据结构中最基础的，也是最简单的一种数据结构，其中典型的叫做 “线性表” ，那什么是线性表呢？
2.1 多项式表示
举个简单的例子：一元多项式及其运算
主要运算：多项式相加、相减、相乘等，怎样用程序设计语言来表示这两个多项式以及实现对应的操作？
【分析】如何表示多项式？
对应多项式来讲，它的关键信息主要有这么几个，一个是它的项数，包括它的最高指数，另外一个是要表现多项式的每一项，而多项式的每一项的关键信息，又是每一项的系数和指数
- 多项式项数 n n n
- 各项系数 a i a_{i} ai 及指数 i i i
方法一：顺序存储结构直接表示
数组各分量对应多项式各项，这个分量主要表示每一项的系数，指数可以对应该分量的下标
例如：
f
(
x
)
=
4
x
3
−
3
x
2
+
1
f(x)=4x^{3}-3x^{2}+1
f(x)=4x3−3x2+1
表示成：
两个多项式相加：两个数组对应分量相加
问题：那如何表示以下多项式？
f ( x ) = x + 3 x 2000 f(x)=x+3x^{2000} f(x)=x+3x2000
如果还是按照上面的顺序存储结构表示该多项式，很显然我们至少得用 2001 个分量得这样得一个数字来表示，而这 2001 个分量，其实只有 2 项是非零的，这样的一种表示方法显然会造成空间的巨大浪费，而且从 0~2001 ，很多计算都是无效的（0），那么有没有更好的方法，为什么一定要把所有零项、非零项、系数为零的，非零的，全部要表示进来呢？有没有可能只表示非零项？所以这就引入了第二种方法：顺序存储结构表示非零项
方法二：顺序存储结构表示非零项
它的基本思路是这样的，只表示非零项，每个非零项 a i x i a_{i}x^{i} aixi 涉及两个信息：系数 a i a_{i} ai 和指数 i i i，可以将一个多项式看成一个 ( a i , i ) (a_{i},i) (ai,i) 二元组合的集合。也可以用数组表示，但是与方法一不同，方法一每一个分量是系数，而现在每个分量不仅要包含系数，也要包含指数，那用什么样的数组呢？
用结构数组表示：数组分量是由系数
a
i
a_{i}
ai、指数
i
i
i 组成的结构，对应一个非零项
例如： P ( x ) 1 = 9 x 12 + 15 x 8 + 3 x 2 P(x)_{1}=9x^{12}+15x^{8}+3x^{2} P(x)1=9x12+15x8+3x2 和 P ( x ) 2 = 26 x 19 − 4 x 8 − 13 x 6 + 82 P(x)_{2}=26x^{19}-4x^{8}-13x^{6}+82 P(x)2=26x19−4x8−13x6+82 ，可以很简单的使用如下数组来表示
比方说这个，它就是一个结构，每一个分量包含了系数和指数，这样的表示方法，显然我们只需要表示非零项就可以，很多为零的项就可以省下不写，对于前面的 f ( x ) = x + 3 x 2000 f(x)=x+3x^{2000} f(x)=x+3x2000 ，只需要用两个分量就能表示，显然节省了很多空间，只要每一项都按照指数大小有序进行存储运算起来也很方便。这种方式不仅节省空间，在效率上也是比较高的，但是还是有其它的方法来表示。
方法三：链表结构存储非零项
链表中包含每个结点存储多项式的一个非零项，包括系数和指数两个数据域以及一个指针域，把它们串起来，同样，排列的时候，仍然可以按照指数递降（或者递增）的顺序进行排列
public class Node {
private int coef;
private int expon;
private Node next;
public Node(int coef,int expon) {
this.coef = coef;
this.expon = expon;
}
}
P ( x ) 1 = 9 x 12 + 15 x 8 + 3 x 2 P(x)_{1}=9x^{12}+15x^{8}+3x^{2} P(x)1=9x12+15x8+3x2 和 P ( x ) 2 = 26 x 19 − 4 x 8 − 13 x 6 + 82 P(x)_{2}=26x^{19}-4x^{8}-13x^{6}+82 P(x)2=26x19−4x8−13x6+82 这两个多项式用指针表示如图所示：
由上可以看出，同样一个问题，可以用多种方式去实现，其次是有序线性序列的组织和管理。
2.2 什么是线性表
线性表（Linear List）：是具有相同数据类型的 n 个元素的有序集合。
线性表的逻辑结构表示：
(
a
0
,
a
1
,
.
.
.
,
a
i
,
a
i
+
1
,
.
.
.
,
a
n
−
1
)
(a_{0},a_{1},...,a_{i},a_{i+1},...,a_{n-1})
(a0,a1,...,ai,ai+1,...,an−1)
线性表的基本特征：
- 表中的元素个数 n 称为表的长度，n=0 是称为空表
- 当
1
<
i
<
n
1 < i <n
1<i<n 时
- ① 第 i i i 个元素 a [ i ] a[i] a[i] 的直接前驱是 a [ i − 1 ] a[i-1] a[i−1]， a [ 0 ] a[0] a[0] 无直接前驱
- ② 第 i i i 个元素 a [ i ] a[i] a[i] 的直接后继是 a [ i + 1 ] a[i+1] a[i+1]， a [ n − 1 ] a[n-1] a[n−1] 无直接后继
- 所有元素的类型必须相同，且不能出现缺项
- 每个数据元素既可以是基本的数据类型，也可以是复杂的数据类型
- 线性表中数据元素与位置相关，即每个数据元素有唯一的序号
用图形表示的逻辑结构：
线性表中每个元素
a
i
a_{i}
ai 的唯一位置通过序号或索引
i
i
i 表示，为了算法设计方便，将逻辑序号和存储序号统一，均假设从 0 开始，这样含
n
n
n 个元素的线性表的元素序号
i
i
i 满足
0
≤
i
≤
n
−
1
0 \le i \le n-1
0≤i≤n−1。
在 Java 语言中，接口 java.util.List<E> 用于表示线性表，ADT 定义如下：
ADT List {
数据对象：
D = { a i ∣ 0 ≤ i ≤ n − 1 , n ≥ 0 , a i 为 E 类型 } D=\left \{ a_{i} \;\;|\;\; 0 \le i \le n-1, \; n \ge 0, \; a_{i} 为 E 类型 \right \} D={ai∣0≤i≤n−1,n≥0,ai为E类型}
数据关系：
r = { < a i , a i + 1 > ∣ a i , a i + 1 ∈ D , i = 0 , . . . , n − 2 } r=\left \{ <a_{i},a_{i+1}> \;|\; a_{i}, \; a_{i+1} \in D, \; i=0,...,n-2 \right \} r={<ai,ai+1>∣ai,ai+1∈D,i=0,...,n−2}
基本运算（11个）：
List()：创建线性表
boolean add(E e)：将指定的元素追加到此列表的末尾
void add(int index, E element)：将指定的元素插入此列表中的指定位置
boolean contains(Object o)：如果此列表包含指定元素，则返回 true
E get(int index)：返回此列表中指定位置的元素
int indexOf(Object o)：返回此列表中指定位置的元素
boolean isEmpty()：如果此列表不包含元素，则返回 true
E remove(int index)：删除该列表中指定位置的元素
boolean remove(Object o)：从列表中删除指定元素的第一个出现（如果存在）
E set(int index, E element)：用指定的元素替换此列表中指定位置的元素
int size()：返回此列表中的元素数
String toString()：将线性表转换为字符串
}
以下实现方式为了避免内容过于冗余，只挑选了部分基本运算进行演示。
2.3 线性表的实现方式
2.3.1 线性表的顺序存储实现
利用数组的连续存储空间顺序存放线性表的各元素
在 Java 中最典型的集合类 ArrayList 就是以这种方式实现的，在 ArrayList 中维护了一个 Object 类型的数组 elementData，关于 ArrayList 的源码分析可见博客：ArrayList-源码解读
当然我们也可以自己用数组去实现一个线性表，先创建一个 ArrLinearList 类，因为不知道线性表具体会存放哪种数据类型，可以泛型 Element 来表示任意类型的数据，如下：
public class ArrLinearList<Element> {
}
（1）初始化
既然底层是数组，那么必然要有数组类型（Object[]）的属性 data 来存放数据，通过 size 属性来记录线性表的大小。
在初始化的时候自然是要创建一个数组对象赋给 data，初始时线性表的长度 size 为 0，在 Java 可以将初始化的逻辑放在构造方法中，代码如下：
public class ArrLinearList<Element> {
// 数据元素
private Object[] data;
// 线性表大小
private int size;
// 初始容量大小
private static final int INIT_CAPACITY = 10;
/**
* 无参构造方法
*/
public ArrLinearList() {
init(INIT_CAPACITY);
}
/**
* 有参构造方法
* @param capacity 指定设置容量大小
*/
public ArrLinearList(int capacity) {
// 如果指定的容量大小小于或等于零，则初始化容量大小为默认容量大小
if (capacity <= 0) {
capacity = INIT_CAPACITY;
}
// 初始化
init(capacity);
}
/**
* 初始化
* @param maxSize 数组的最大容量
*/
private void init(int maxSize) {
// 创建一个大小为 10 的 Object 数组
data = new Object[maxSize];
// 初始化时线性表的大小为 0
size = 0;
}
}
（2）根据位序 index，查询相应的元素
因为底层时数组，可以通过数组的坐标直接得到位于 index 上的元素
/**
* 根据位序 index，返回相应元素
* @param index 为序
* @return 元素
*/
// 压制不安全的类型转换的警告
@SuppressWarnings("unchecked")
public Element get(int index) {
// 校验坐标是否合法
if (index >= size || index < 0) {
// 位置不合法
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
return (Element) data[index];
}
（3）通过元素 Element，查找所在位置
分为两种情况，首先是当 element 为 null 时，则查询数组中第一个为 null 元素的坐标位置，如果 element 不为 null，则遍历数组，通过 equals() 方法去比较，如果相同则返回坐标位置
/**
* 通过元素 Element，查找所在位置
* @param element 元素
* @return 所在位置
*/
public int indexOf(Object element) {
if (element == null) {
// 遍历数组
for (int i = 0; i < size; i++) {
if (data[i] == null)
return i;
}
} else {
for (int i = 0; i < size; i++) {
if (element.equals(data[i]))
return i;
}
}
return -1;
}
（4）在指定位序 index 上插入一个新的元素
往线性表中 index 位置上添加一个元素（0 <= index <= size），分为两种情况
- 情况一：
index等于线性表的大小，表示在末位添加元素，直接将element放到index位置上，线性表大小加一 - 情况二：
index小于线性表的大小，则需要先将位于index以及之后的所有元素往后挪动一位，再将元素element放到index位置上，线性表大小加一
还有个需要考虑的问题就是当添加的元素数量大于 data 数组的容量时要怎么扩容，通常情况下的做法就是重新创建一个新的数组，将原数组的数据复制到新数组中，再进行元素的添加，原理如下：
/**
* 将指定元素添加到线性表的末位
* @param element 元素
*/
public void add(Element element) {
add(size, element);
}
/**
* 在指定位序上插入一个新的元素
* @param index 位序
* @param element 元素
*/
public void add(int index, Element element) {
// 如果插入元素的坐标大于线性表的大小
if (index > size || index < 0) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
// 判断当前线性表的大小是否等于容量大小
if (size == data.length) {
// 如果插入当前元素后线性表的大小大于容器的大小，则进行扩容
ensureCapacity();
}
// 判断插入位置是否小于线性表长度(头部或者中间插入)
if (index < size) {
// 先将线性表位于 index 以及之后的元素都往后挪一位
for (int i = size; i > index; i--) {
data[i] = data[i-1];
}
}
// 在 index 位序上插入元素
data[index] = element;
// 线性表大小加一
size++;
}
/**
* 自动扩容方法
*/
public void ensureCapacity() {
// 新容量的大小是原容量大小的 1.5 倍
int newCapacity = data.length + (data.length >> 1);
// 创建新数组
Object[] newDate = new Object[newCapacity];
// 将原数组中的内容复制到新数组中
for (int i = 0; i < data.length; i++) {
newDate[i] = data[i];
}
// 将线性表存放数据的数组指向新的数组
data = newDate;
}
（5）删除指定位序 index 的元素
在线性表中如果需要删除指定位置 index 上的元素，只需要将 index 之后的元素都向前挪动一位即可，线性表大小减一
/**
* 删除指定位序的元素
* @param index 位序
*/
public void remove(int index) {
// 如果删除元素的坐标大于等于或者小于线性表的大小
if (index >= size || index < 0) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
// 判断删除的元素是否为末端元素
if (index == size-1) {
// 删除的是最后一个元素
data[index] = null;
} else {
for (int i = index; i < size; i++) {
data[i] = data[i+1];
}
}
// 线性表大小减一
size--;
}
/**
* 从列表中删除指定元素的第一个出现（如果存在）
* @param element 元素
*/
public void remove(Element element) {
int index = indexOf(element);
if (index != -1) {
remove(index);
}
}
（6）获取线性表的长度
上述代码每增加一个元素会让 size+1，每删除一个元素 size-1，所以直接获取 size 即为线性表的大小
/**
* 获取线性表大小
* @return 线性表大小
*/
public int size() {
return size;
}
完整代码示例：
public class ArrLinearList<Element> {
// 数据元素
private Object[] data;
// 线性表大小
private int size;
// 初始容量大小
private static final int INIT_CAPACITY = 10;
/**
* 无参构造方法
*/
public ArrLinearList() {
init(INIT_CAPACITY);
}
/**
* 有参构造方法
* @param capacity 指定设置容量大小
*/
public ArrLinearList(int capacity) {
// 如果指定的容量大小小于或等于零，则初始化容量大小为默认容量大小
if (capacity <= 0) {
capacity = INIT_CAPACITY;
}
// 初始化
init(capacity);
}
/**
* 初始化
* @param maxSize 数组的最大容量
*/
private void init(int maxSize) {
// 创建一个大小为 10 的 Object 数组
data = new Object[maxSize];
// 初始化时线性表的大小为 0
size = 0;
}
/**
* 根据位序 index，返回相应元素
* @param index 为序
* @return 元素
*/
// 压制不安全的类型转换的警告
@SuppressWarnings("unchecked")
public Element get(int index) {
// 校验坐标是否合法
if (index >= size || index < 0) {
// 位置不合法
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
return (Element) data[index];
}
/**
* 通过元素 Element，查找所在位置
* @param element 元素
* @return 所在位置
*/
public int indexOf(Object element) {
if (element == null) {
// 遍历数组
for (int i = 0; i < size; i++) {
if (data[i] == null)
return i;
}
} else {
for (int i = 0; i < size; i++) {
if (element.equals(data[i]))
return i;
}
}
return -1;
}
/**
* 将指定元素添加到线性表的末位
* @param element 元素
*/
public void add(Element element) {
add(size, element);
}
/**
* 在指定位序上插入一个新的元素
* @param index 位序
* @param element 元素
*/
public void add(int index, Element element) {
// 如果插入元素的坐标大于线性表的大小
if (index > size || index < 0) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
// 判断当前线性表的大小是否等于容量大小
if (size == data.length) {
// 如果插入当前元素后线性表的大小大于容器的大小，则进行扩容
ensureCapacity();
}
// 判断插入位置是否小于线性表长度(头部或者中间插入)
if (index < size) {
// 先将线性表位于 index 以及之后的元素都往后挪一位
for (int i = size; i > index; i--) {
data[i] = data[i-1];
}
}
// 在 index 位序上插入元素
data[index] = element;
// 线性表大小加一
size++;
}
/**
* 自动扩容方法
*/
public void ensureCapacity() {
// 新容量的大小是原容量大小的 1.5 倍
int newCapacity = data.length + (data.length >> 1);
// 创建新数组
Object[] newDate = new Object[newCapacity];
// 将原数组中的内容复制到新数组中
for (int i = 0; i < data.length; i++) {
newDate[i] = data[i];
}
// 将线性表存放数据的数组指向新的数组
data = newDate;
}
/**
* 删除指定位序的元素
* @param index 位序
*/
public void remove(int index) {
// 如果删除元素的坐标大于等于或者小于线性表的大小
if (index >= size || index < 0) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
// 判断删除的元素是否为末端元素
if (index == size-1) {
// 删除的是最后一个元素
data[index] = null;
} else {
for (int i = index; i < size; i++) {
data[i] = data[i+1];
}
}
// 线性表大小减一
size--;
}
/**
* 从列表中删除指定元素的第一个出现（如果存在）
* @param element 元素
*/
public void remove(Element element) {
int index = indexOf(element);
if (index != -1) {
remove(index);
}
}
/**
* 用指定的元素替换此列表中指定位置的元素
* @param index 指定位置
* @param element 指定元素
* @return 替换掉的元素
*/
@SuppressWarnings("unchecked")
public Element set(int index, Element element) {
// 校验坐标是否合法
if (index >= size || index < 0) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
Element oldElement =(Element) data[index];
data[index] = element;
return oldElement;
}
/**
* 判断指定元素是否在线性表中
* @return true 表示存在 false 表示不存在
*/
public boolean contains(Element element) {
return indexOf(element) != -1;
}
/**
* 获取线性表大小
* @return 线性表大小
*/
public int size() {
return size;
}
/**
* 判断当前线性表是否为空
* @return true 表示为空 false 表示不为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 返回当前线性表的字符串表示
* @return 线性表字符串表示
*/
public String toString() {
StringBuilder str = new StringBuilder("[");
for (int i = 0; i < size-1; i++) {
str.append(this.data[i]).append(",");
}
if (size > 0) {
str.append(this.data[size - 1]);
}
str.append("]");
return str.toString();
}
}
2.3.2 线性表的链式存储实现
不要求逻辑上相邻的两个元素物理上也相邻，通过 “链” 建立起数据元素之间的逻辑关系。
插入、删除不需要移动数据元素，只需修改 “链” 即可。
链表主要可分为：单向链表、双向链表 和 循环链表，
- 单向链表：每个节点只设置一个指向后继节点的指针成员，这样的链表成为线性单向链接表，简称单链表
- 双向链表：每个节点设置两个指针成员，分别用以指向其前驱节点和后继节点，这样的链表称之为线性双向链接表，简称双链表
在 Java 中非常典型的集合类 LinkedList ，其底层使用的就是双向链表，关于 LinkedList 的源码分析可见博客：LinkedList-源码解读
同样我们也可以自己用链表结构实现一个线性表，创建一个 LinkLinearList 类，使用泛型 Element 去约束数据类型
public class LinkLinearList<Element> {
}
1. 单链表实现
（1）初始化
因为底层采用的是链表结构，故在该类内部定义一个内部类 Node，存放链表的节点信息，元素 data 及其后继节点 next，在 LinkLinearList 中设置属性 header 和 tail 分别记录头节点和尾节点，在构造方法中初始化线性表大小为 0
public class LinkLinearList<Element> {
// 头节点
private Node<Element> header;
// 尾节点
private Node<Element> tail;
// 线性表的长度
private int size;
/**
* 节点
* @param <Element> 数据元素类型
*/
public static class Node<Element> {
// 数据元素
private Element data;
// 后继节点
private Node<Element> next;
}
/**
* 无参构造方法
*/
public LinkLinearList() {
// 初始化线性表的长度
size = 0;
}
}
（2）根据位序 index，查询相应的元素
因为底层是链表，如果想要获取某个 index 位置上的数据，只能遍历链表，得到 index 位置上的节点，再返回节点数据
/**
* 根据位序 index，返回相应元素
* @param index 为序
* @return 元素
*/
public Element get(int index) {
if (index >= size) {
// 位序大于线性表的大小
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
// 返回指定位序节点下的数据元素
return findNode(index).data;
}
// 通过位序获取节点
public Node<Element> findNode(int index) {
// 目标节点
Node<Element> target = null;
// 遍历链表（可采用二分法进行优化）
Node<Element> node = header;
for (int i = 0; i < size; i++) {
if (i == index) {
target = node;
break;
}
node = node.next;
}
// 返回对应节点
return target;
}
（3）通过元素 Element，查找所在位置
分为两种情况，首先是当 element 为 null 时，则查询l链表中第一个为 null 元素的坐标位置，如果 element 不为 null，则遍历链表，通过 equals() 方法去比较，如果相同则返回坐标位置
/**
* 通过元素 Element，查找所在位置
* @param element 元素
* @return 所在位置
*/
public int indexOf(Object element) {
int index = 0;
Node<Element> node = header;
if (element == null) {
// 遍历链表
do {
if (node.data == null)
return index;
index++;
node = node.next;
} while (node != null);
} else {
// 遍历链表
do {
if (element.equals(node.data))
return index;
index++;
node = node.next;
} while (node != null);
}
return -1;
}
（4）在指定位序 index 上插入一个新的元素
在链表中添加元素可分为三种情况：
- 情况一：末位插入，这种情况比较简单，只需要将原末端节点指向新插入的节点就行了
- 情况二：头部插入，新添加的节点成为头节点，该节点的后驱节点指向原头节点
- 情况三：中间插入，原位置上的前驱节点变为新插入节点的前驱节点，原节点变为新插入节点的后驱节点
/**
* 将指定元素添加到线性表的末位
* @param element 元素
*/
public void add(Element element) {
add(size, element);
}
/**
* 在指定位序上插入一个新的元素
* @param index 位序
* @param element 元素
*/
public void add(int index, Element element) {
// 校验插入位置是否合法：位置范围必须在 0 <= index <= size 这个区间内
if (!(index >= 0 && index <= size)) {
// 位置不合法
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
// 末端插入
if (index == size) {
// 原尾部节点
Node<Element> last = tail;
// 新插入节点
Node<Element> newNode = new Node<>();
// 设置节点数据
newNode.data = element;
// 尾部节点变为新插入的节点
tail = newNode;
if (last == null) {
// 如果原尾部节点为空，则表示当前链表没有元素，新插入的节点既是头节点也是尾节点
header = newNode;
} else {
// 设置原尾部节点的下一个节点为新插入的节点
last.next = newNode;
}
}
// 头部或者中间插入
else {
// 获取 index-1 位序的节点
Node<Element> beforeNode = findNode(index-1);
// 获取原 index 位序的节点
Node<Element> originNode = findNode(index);
// 新插入节点
Node<Element> newNode = new Node<>();
// 设置节点数据
newNode.data = element;
// 设置新插入的节点的 next 为原节点
newNode.next = originNode;
if (beforeNode == null) {
// 表明在头部插入节点
header = newNode;
} else {
// 表明在中间插入节点，则原 index-1 位置上的节点 next 设置为当前插入的节点
beforeNode.next = newNode;
}
}
// 线性表大小加一
size++;
}
（5）删除指定位序 index 的元素
在链表中删除指定位序的数据就是删除该位置的节点，所以在删除时要注意原节点的前驱节点 beforeNode 应该变为原节点的后驱节点 afterNode，同时也应该要注意删除的是否时头节点或者尾节点
/**
* 删除指定位序的元素
* @param index 位序
*/
public void remove(int index) {
// 校验插入位置是否合法：位置范围必须在 0 <= index <= size 这个区间内
if (!(index >= 0 && index < size)) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
// 获取 index-1 (前)位序的节点
Node<Element> beforeNode = findNode(index-1);
// 获取原 index+1 (后)位序的节点
Node<Element> afterNode = findNode(index+1);
if (beforeNode == null) {
// 如果删除的节点没有前驱节点，则说明删除的节点为头节点，则后置节点设置为头节点
header = afterNode;
} else {
// 删除的节点不是头节点，前置节点的下一个节点设置为后置节点
beforeNode.next = afterNode;
}
// 线性表大小减一
size--;
}
/**
* 从列表中删除指定元素的第一个出现（如果存在）
* @param element 元素
*/
public void remove(Element element) {
int index = indexOf(element);
if (index != -1) {
remove(index);
}
}
（6）获取线性表的长度
上述代码每增加一个元素会让 size+1，每删除一个元素 size-1，所以直接获取 size 即为线性表的大小
/**
* 获取线性表大小
* @return 线性表大小
*/
public int size() {
return size;
}
完整代码示例：
public class LinkLinearList<Element> {
// 头节点
private Node<Element> header;
// 尾节点
private Node<Element> tail;
// 线性表的长度
private int size;
/**
* 节点
* @param <Element> 数据元素类型
*/
public static class Node<Element> {
// 数据元素
private Element data;
// 后继节点
private Node<Element> next;
}
/**
* 无参构造方法
*/
public LinkLinearList() {
// 初始化线性表的长度
size = 0;
}
/**
* 根据位序 index，返回相应元素
* @param index 为序
* @return 元素
*/
public Element get(int index) {
if (index >= size) {
// 位序大于线性表的大小
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
// 返回指定位序节点下的数据元素
return findNode(index).data;
}
// 通过位序获取节点
public Node<Element> findNode(int index) {
// 目标节点
Node<Element> target = null;
// 遍历链表（可采用二分法进行优化）
Node<Element> node = header;
for (int i = 0; i < size; i++) {
if (i == index) {
target = node;
break;
}
node = node.next;
}
// 返回对应节点
return target;
}
/**
* 通过元素 Element，查找所在位置
* @param element 元素
* @return 所在位置
*/
public int indexOf(Object element) {
int index = 0;
Node<Element> node = header;
if (element == null) {
// 遍历链表
do {
if (node.data == null)
return index;
index++;
node = node.next;
} while (node != null);
} else {
// 遍历链表
do {
if (element.equals(node.data))
return index;
index++;
node = node.next;
} while (node != null);
}
return -1;
}
/**
* 将指定元素添加到线性表的末位
* @param element 元素
*/
public void add(Element element) {
add(size, element);
}
/**
* 在指定位序上插入一个新的元素
* @param index 位序
* @param element 元素
*/
public void add(int index, Element element) {
// 校验插入位置是否合法：位置范围必须在 0 <= index <= size 这个区间内
if (!(index >= 0 && index <= size)) {
// 位置不合法
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
// 末端插入
if (index == size) {
// 原尾部节点
Node<Element> last = tail;
// 新插入节点
Node<Element> newNode = new Node<>();
// 设置节点数据
newNode.data = element;
// 尾部节点变为新插入的节点
tail = newNode;
if (last == null) {
// 如果原尾部节点为空，则表示当前链表没有元素，新插入的节点既是头节点也是尾节点
header = newNode;
} else {
// 设置原尾部节点的下一个节点为新插入的节点
last.next = newNode;
}
}
// 头部或者中间插入
else {
// 获取 index-1 位序的节点
Node<Element> beforeNode = findNode(index-1);
// 获取原 index 位序的节点
Node<Element> originNode = findNode(index);
// 新插入节点
Node<Element> newNode = new Node<>();
// 设置节点数据
newNode.data = element;
// 设置新插入的节点的 next 为原节点
newNode.next = originNode;
if (beforeNode == null) {
// 表明在头部插入节点
header = newNode;
} else {
// 表明在中间插入节点，则原 index-1 位置上的节点 next 设置为当前插入的节点
beforeNode.next = newNode;
}
}
// 线性表大小加一
size++;
}
/**
* 删除指定位序的元素
* @param index 位序
*/
public void remove(int index) {
// 校验插入位置是否合法：位置范围必须在 0 <= index <= size 这个区间内
if (!(index >= 0 && index < size)) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
// 获取 index-1 (前)位序的节点
Node<Element> beforeNode = findNode(index-1);
// 获取原 index+1 (后)位序的节点
Node<Element> afterNode = findNode(index+1);
if (beforeNode == null) {
// 如果删除的节点没有前驱节点，则说明删除的节点为头节点，则后置节点设置为头节点
header = afterNode;
} else {
// 删除的节点不是头节点，前置节点的下一个节点设置为后置节点
beforeNode.next = afterNode;
}
// 线性表大小减一
size--;
}
/**
* 从列表中删除指定元素的第一个出现（如果存在）
* @param element 元素
*/
public void remove(Element element) {
int index = indexOf(element);
if (index != -1) {
remove(index);
}
}
/**
* 用指定的元素替换此列表中指定位置的元素
* @param index 指定位置
* @param element 指定元素
* @return 替换掉的元素
*/
public Element set(int index, Element element) {
// 校验坐标是否合法
if (index >= size || index < 0) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
Node<Element> node = findNode(index);
Element oldElement = node.data;
// 重置数据
node.data = element;
return oldElement;
}
/**
* 判断指定元素是否在线性表中
* @return true 表示存在 false 表示不存在
*/
public boolean contains(Element element) {
return indexOf(element) != -1;
}
/**
* 获取线性表大小
* @return 线性表大小
*/
public int size() {
return size;
}
/**
* 判断当前线性表是否为空
* @return true 表示为空 false 表示不为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 返回当前线性表的字符串表示
* @return 线性表字符串表示
*/
public String toString() {
StringBuilder str = new StringBuilder("[");
if (size > 0) {
// 遍历链表
Node<Element> cursor = header;
str.append(cursor.data);
while (cursor.next != null) {
cursor = cursor.next;
str.append(",").append(cursor.data);
}
}
str.append("]");
return str.toString();
}
}
2. 双链表实现
之前提到过 LinkedList 的底层就是使用双向链表实现的，与单向链表不同，双向链表的节点不仅需要记录后继节点，也需要记录前驱节点，实现方法基本类似。
（1）初始化
因为要记录前驱节点，所以相比单向链表多了一个 prev 属性来记录前驱节点，其余属性与单向链表相同
public class DoubleLinkList<Element> {
// 头节点
private Node<Element> header;
// 尾节点
private Node<Element> tail;
// 线性表的长度
private int size;
/**
* 节点
* @param <Element> 数据元素类型
*/
public static class Node<Element> {
// 数据元素
private Element data;
// 前驱节点
private Node<Element> prev;
// 后继节点
private Node<Element> next;
}
/**
* 无参构造方法
*/
public DoubleLinkList() {
// 初始化线性表的长度
size = 0;
}
}
（2）根据位序 index，查询相应的元素
与单链表的逻辑差不都，都是对链表进行遍历，但是双链表不仅可以正向遍历，也能反向遍历
/**
* 根据位序 index，返回相应元素
* @param index 为序
* @return 元素
*/
public Element get(int index) {
if (index >= size) {
// 位序大于线性表的大小
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
// 返回指定位序节点下的数据元素
return findNode(index).data;
}
// 通过位序获取节点
public Node<Element> findNode(int index) {
// 二分法查找
Node<Element> node;
if (index < (size >> 1)) {
node = header;
for (int i = 0; i < index; i++) {
node = node.next;
}
} else {
node = tail;
for (int i = size -1; i > index; i--) {
node = node.prev;
}
}
return node;
}
（3）通过元素 Element，查找所在位置
/**
* 通过元素 Element，查找所在位置
* @param element 元素
* @return 所在位置
*/
public int indexOf(Object element) {
int index = 0;
Node<Element> node = header;
if (element == null) {
// 遍历链表
do {
if (node.data == null)
return index;
index++;
node = node.next;
} while (node != null);
} else {
// 遍历链表
do {
if (element.equals(node.data))
return index;
index++;
node = node.next;
} while (node != null);
}
return -1;
}
（4）在指定位序 index 上插入一个新的元素
在双向链表中添加元素也可分为三种情况：
- 情况一：末位插入，新插入的节点
NodeX成为链表的尾节点，新节点的前驱节点prev指向原链表的尾节点Node...，原链表的尾节点Node...的后驱节点next指向新插入的节点NodeX
- 情况二：头部插入，新插入的节点
NodeX变成了头节点，所以NodeX的Next要指向原头节点Node1，NodeX的prev为null
- 情况三：中间插入，新插入的节点
NodeX的前驱节点为原指定节点的前驱节点，原指定位置上的节点变成了新插入节点的后驱节点了
/**
* 将指定元素添加到线性表的末位
* @param element 元素
*/
public void add(Element element) {
add(size, element);
}
/**
* 在指定位序上插入一个新的元素
* @param index 位序
* @param element 元素
*/
public void add(int index, Element element) {
// 校验插入位置是否合法：位置范围必须在 0 <= index <= size 这个区间内
if (!(index >= 0 && index <= size)) {
// 位置不合法
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
// 末端插入
if (index == size) {
// 原尾部节点
Node<Element> last = tail;
// 新插入节点
Node<Element> newNode = new Node<>();
// 设置节点数据
newNode.data = element;
// 尾部节点变为新插入的节点
tail = newNode;
if (last == null) {
// 如果原尾部节点为空，则表示当前链表没有元素，新插入的节点既是头节点也是尾节点
header = newNode;
} else {
// 设置原尾部节点的下一个节点为新插入的节点
last.next = newNode;
// 设置新插入节点的前驱节点为原尾部节点
newNode.prev = last;
}
}
// 头部或者中间插入
else {
// 获取原 index 位序的节点
Node<Element> originNode = findNode(index);
// 新插入节点
Node<Element> newNode = new Node<>();
// 设置节点数据
newNode.data = element;
// 设置新插入的节点的 next 为原节点
newNode.next = originNode;
// 新插入节点的 prev 为原节点的前驱节点
newNode.prev = originNode.prev;
// 判断原节点是否为头节点
if (originNode.prev == null) {
// 是，则表明在头部插入节点，新节点成为头节点
header = newNode;
} else {
// 原节点的前驱节点的后继节点为新插入的节点
originNode.prev.next = newNode;
}
// 原节点的前驱节点设置为新插入的节点
originNode.prev = newNode;
}
// 线性表大小加一
size++;
}
（5）删除指定位序 index 的元素
删除链表头部节点也需要分为两种情况去看待：
- 集合大小
= 1时，此时删除第一个节点之后，链表就没有节点了，所以链表的头节点和尾节点都需要设置为null - 集合大小
> 1时，原头节点Node1的后驱节点Next指向null，而它的下一个节点Node2变成头节点，Node2的 前驱节点Pre指向null
/**
* 删除指定位序的元素
* @param index 位序
*/
public void remove(int index) {
// 校验插入位置是否合法：位置范围必须在 0 <= index <= size 这个区间内
if (!(index >= 0 && index < size)) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
// 获取 index 处的节点
Node<Element> node = findNode(index);
// 获取该节点的前驱节点
Node<Element> prevNode = node.prev;
// 获取该节点的后继节点
Node<Element> nextNode = node.next;
if (prevNode == null) {
// 如果前驱节点为空，则说明删除的节点为头节点，则后继节点设置为头节点
header = nextNode;
nextNode.prev = null;
} else if (nextNode == null) {
// 如果后继节点为空，则说明删除的节点为尾节点，则前驱节点设置为为节点
tail = node.prev;
prevNode.next = null;
} else {
// 删除的节点不是头节点，则原前驱节点的下一个节点设置为原后继节点
prevNode.next = nextNode;
// 原后继节点的上一个节点设置为原前驱节点
nextNode.prev = prevNode;
}
// 线性表大小减一
size--;
}
/**
* 从列表中删除指定元素的第一个出现（如果存在）
* @param element 元素
*/
public void remove(Element element) {
int index = indexOf(element);
if (index != -1) {
remove(index);
}
}
（6）获取线性表的长度
/**
* 获取线性表大小
* @return 线性表大小
*/
public int size() {
return size;
}
完整代码示例：
public class DoubleLinkList<Element> {
// 头节点
private Node<Element> header;
// 尾节点
private Node<Element> tail;
// 线性表的长度
private int size;
/**
* 节点
* @param <Element> 数据元素类型
*/
public static class Node<Element> {
// 数据元素
private Element data;
// 前驱节点
private Node<Element> prev;
// 后继节点
private Node<Element> next;
}
/**
* 无参构造方法
*/
public DoubleLinkList() {
// 初始化线性表的长度
size = 0;
}
/**
* 根据位序 index，返回相应元素
* @param index 为序
* @return 元素
*/
public Element get(int index) {
if (index >= size) {
// 位序大于线性表的大小
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
// 返回指定位序节点下的数据元素
return findNode(index).data;
}
// 通过位序获取节点
public Node<Element> findNode(int index) {
// 二分法查找
Node<Element> node;
if (index < (size >> 1)) {
node = header;
for (int i = 0; i < index; i++) {
node = node.next;
}
} else {
node = tail;
for (int i = size -1; i > index; i--) {
node = node.prev;
}
}
return node;
}
/**
* 通过元素 Element，查找所在位置
* @param element 元素
* @return 所在位置
*/
public int indexOf(Object element) {
int index = 0;
Node<Element> node = header;
if (element == null) {
// 遍历链表
do {
if (node.data == null)
return index;
index++;
node = node.next;
} while (node != null);
} else {
// 遍历链表
do {
if (element.equals(node.data))
return index;
index++;
node = node.next;
} while (node != null);
}
return -1;
}
/**
* 将指定元素添加到线性表的末位
* @param element 元素
*/
public void add(Element element) {
add(size, element);
}
/**
* 在指定位序上插入一个新的元素
* @param index 位序
* @param element 元素
*/
public void add(int index, Element element) {
// 校验插入位置是否合法：位置范围必须在 0 <= index <= size 这个区间内
if (!(index >= 0 && index <= size)) {
// 位置不合法
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
// 末端插入
if (index == size) {
// 原尾部节点
Node<Element> last = tail;
// 新插入节点
Node<Element> newNode = new Node<>();
// 设置节点数据
newNode.data = element;
// 尾部节点变为新插入的节点
tail = newNode;
if (last == null) {
// 如果原尾部节点为空，则表示当前链表没有元素，新插入的节点既是头节点也是尾节点
header = newNode;
} else {
// 设置原尾部节点的下一个节点为新插入的节点
last.next = newNode;
// 设置新插入节点的前驱节点为原尾部节点
newNode.prev = last;
}
}
// 头部或者中间插入
else {
// 获取原 index 位序的节点
Node<Element> originNode = findNode(index);
// 新插入节点
Node<Element> newNode = new Node<>();
// 设置节点数据
newNode.data = element;
// 设置新插入的节点的 next 为原节点
newNode.next = originNode;
// 新插入节点的 prev 为原节点的前驱节点
newNode.prev = originNode.prev;
// 判断原节点是否为头节点
if (originNode.prev == null) {
// 是，则表明在头部插入节点，新节点成为头节点
header = newNode;
} else {
// 原节点的前驱节点的后继节点为新插入的节点
originNode.prev.next = newNode;
}
// 原节点的前驱节点设置为新插入的节点
originNode.prev = newNode;
}
// 线性表大小加一
size++;
}
/**
* 删除指定位序的元素
* @param index 位序
*/
public void remove(int index) {
// 校验插入位置是否合法：位置范围必须在 0 <= index <= size 这个区间内
if (!(index >= 0 && index < size)) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
// 获取 index 处的节点
Node<Element> node = findNode(index);
// 获取该节点的前驱节点
Node<Element> prevNode = node.prev;
// 获取该节点的后继节点
Node<Element> nextNode = node.next;
if (prevNode == null) {
// 如果前驱节点为空，则说明删除的节点为头节点，则后继节点设置为头节点
header = nextNode;
nextNode.prev = null;
} else if (nextNode == null) {
// 如果后继节点为空，则说明删除的节点为尾节点，则前驱节点设置为为节点
tail = node.prev;
prevNode.next = null;
} else {
// 删除的节点不是头节点，则原前驱节点的下一个节点设置为原后继节点
prevNode.next = nextNode;
// 原后继节点的上一个节点设置为原前驱节点
nextNode.prev = prevNode;
}
// 线性表大小减一
size--;
}
/**
* 从列表中删除指定元素的第一个出现（如果存在）
* @param element 元素
*/
public void remove(Element element) {
int index = indexOf(element);
if (index != -1) {
remove(index);
}
}
/**
* 用指定的元素替换此列表中指定位置的元素
* @param index 指定位置
* @param element 指定元素
* @return 替换掉的元素
*/
public Element set(int index, Element element) {
// 校验坐标是否合法
if (index >= size || index < 0) {
// 位置不合法
throw new RuntimeException("Index: "+index+", Size: "+size);
}
Node<Element> node = findNode(index);
Element oldElement = node.data;
// 重置数据
node.data = element;
return oldElement;
}
/**
* 判断指定元素是否在线性表中
* @return true 表示存在 false 表示不存在
*/
public boolean contains(Element element) {
return indexOf(element) != -1;
}
/**
* 获取线性表大小
* @return 线性表大小
*/
public int size() {
return size;
}
/**
* 判断当前线性表是否为空
* @return true 表示为空 false 表示不为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 返回当前线性表的字符串表示
* @return 线性表字符串表示
*/
public String toString() {
StringBuilder str = new StringBuilder("[");
if (size > 0) {
// 遍历链表
Node<Element> cursor = header;
str.append(cursor.data);
while (cursor.next != null) {
cursor = cursor.next;
str.append(",").append(cursor.data);
}
}
str.append("]");
return str.toString();
}
}
上篇：第一章、绪论
