1 线性表的定义
线性表(List)：零个或者多个数据元素的有限序列。 需要满足以下特点：
- 是一个序列。元素之间有顺序，如果元素存在多个，则第一个元素没有前驱,最后一个元素没有后驱，并且其他元素有且只有一个前驱跟后驱。
- 是有限的 可将线性表定义为：(a1,……,ai-1,ai,ai+1,……an)，则表中的ai-1领先于ai，ai领先于ai+1,称ai-1是ai的直接前驱，ai+1是ai的直接后驱。所以将线性表元素的个数n(n >= 0)定义为线性表的长度，当n = 0时，称为空表。如下图所示。
线性表主要分为两种物理结构。
- 顺序存储结构
- 链式存储结构
2 线性表的顺序存储结构
2.1 顺序存储的定义
线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。
2.2 顺序存储方式
线性表的存储结构，就是在内存中找个地方，通过占位的形式，把一定内存空间给占了，然后把相同数据类型的数据元素依次存放在这块空地中。所以可以用到一维数组来实现顺序存储结构。
线性表顺序存储结构代码如下。
// 线性表顺序结构
public class OrderLink {
// 用来保存数据的数组
private String[] orderLink;
// 数组的默认大小
private static final int DEFAULT_SIZE = 10;
// 数组大小
private int maxSize;
// 线性表大小
private int size;
public OrderLink() {
this(DEFAULT_SIZE);
}
public OrderLink(int maxSize) {
this.maxSize = maxSize;
orderLink = new String[maxSize];
}
}
我们发现描述顺序存储结构需要三个属性：
- 存储空间的起始位置：数组 'orderLink'，它的存储位置就是存储空间的存储位置。
- 线性表的最大存储容量：数组长度 'maxSize'。
- 线性表的当前长度：'size'。
2.3 地址计算方式
数组的下标是从0开始的，所以线性表第i个元素是存储在数组下标为i-1的位置。如下图：
用数组顺序存储结构意味着要分配固定大小长度的数组空间，由于线性表可以进行插入和删除操作，因此分配的数组空间要大于等于当前线性表的长度。
其实，内存中的地址，就和图书馆或者电影院的座位一样，都是有编号的。存储器中的每个存储单元都有自己的编号，这个编号就叫做地址。 假设单个数据占用的是c个存储单元，那么线性表中第i+1个数据元素的存储位置和第i个数据元素的存储位置满足下列关系（LOC表示获得存储位置的函数）。
LOC(ai+1) = LOC(ai) + c
所以对于第i个元素的存储位置可以由a1推算的来。
LOC(ai) = LOC(a1) + (i-1) * c
如下图所示：
2.4 顺序存储结构的操作
2.4.1 获得元素
查询算法思路：
- 如果 index 值不合理，抛出异常。
- 根据 index 查询出，数组中 index - 1 值
/**
* 查询
* @param index 索引
* @return 查询到的值值
*/
public String getElem(int index) {
if (maxSize == 0) {
throw new IllegalArgumentException("线性表不能为空");
}
if (index < 1) {
throw new IllegalArgumentException("index 不能小于0");
}
if (index > maxSize) {
throw new IllegalArgumentException("index 不能大于" + index);
}
return orderLink[index];
}
2.4.2 插入操作
插入算法思路：
- 如果 index 值不合理，抛出异常。
- 从最后一个元素开始向前遍历到第i个位置，分别将他们都往后移动一个位置。
- 将要插入的元素插入i处。
- 线性表长加1.
/**
* 往线性表指定位置插入数据
* @param index 指定位置
* @param value 待插入数据
*/
public void add(int index, String value) {
if (maxSize == 0) {
throw new IllegalArgumentException("线性表不能为空");
}
if (index < 1) {
throw new IllegalArgumentException("index 不能小于0");
}
if (index > maxSize) {
throw new IllegalArgumentException("index 不能大于" + index);
}
// 根据情况改变数组长度
String[] oldLink;
String[] newLink;
if (index == maxSize) {
oldLink = orderLink;
newLink = new String[(int) (maxSize * 1.5)];
for (int i = 0; i < size; i++) {
newLink[i] = oldLink[i];
}
orderLink = newLink;
maxSize = (int) (maxSize * 1.5);
}
// 直接插入到末尾
if (index == size) {
orderLink[index] = value;
size++;
return;
}
// 移动位置
for (int i = size; i > index; i--) {
orderLink[i] = orderLink[i-1];
}
// 插入数据
orderLink[index] = value;
size++;
}
2.4.3 删除操作思路
删除算法思路：
- 如果 index 值不合理，抛出异常。
- 取出删除元素。
- 从删除元素开始遍历到最后一个位置，分别将他们都向前移动一个位置。
- 线性表长减1.
/**
* 删除指定位置元素
* @param index 指定位置
* @return 删除元素
*/
public String remove(int index) {
// 验证参数
if (maxSize == 0) {
throw new IllegalArgumentException("线性表不能为空");
}
if (index < 1) {
throw new IllegalArgumentException("index 不能小于0");
}
if (index > maxSize) {
throw new IllegalArgumentException("index 不能大于" + index);
}
// 取出删除元素
String removeStr = orderLink[index - 1];
// 移动元素
for (int i = index; i < size - 1; i++) {
orderLink[i - 1] = orderLink[i];
}
orderLink[size - 1] = null;
size--;
return removeStr;
}
2.5 线性表存储结构的优缺点
线性表的顺序存储结构的优缺点如下所示： 优点：
- 无需为了表示表中元素之间的逻辑关系额外增加存储空间。
- 可以快速查询存取表中的任意一个位置元素。查询的时间复杂的是O(1)。 缺点：
- 插入和删除操作需要移动大量元素。时间复杂度是O(n)。
- 当线性表长度变化较大时，难以确定存储空间的容量。
3 线性表链式存储结构
3.1 定义
链式存储的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元是连续的，也可以是不连续的。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称为指针或链。这两个部分组成的数据元素，被称为结点。
n个结点(ai的存储映像)链结成一个链表，即为线性表的链式存储结构。
单链表的第一个结点前附设一个结点，称为头结点。链表中第一个结点的存储位置就叫做头指针。
线性表链式存储结构代码如下。
public class Node {
public int id;
public String name;
public Node next;
public Node() {
}
public Node(int id, String name, Node next) {
this.id = id;
this.name = name;
this.next = next;
}
}
public class SingleLink {
public Node header;
public SingleLink() {
header = new Node();
}
}
3.2 单链表操作
3.2.1 单链表的插入
单链表插入思路：
- 声明 tempNode 指向 header，初始化 currentIndex。
- 当 temp.next 不等于 null，并且 currentIndex<index 的时候，让 tempNode 向后移动，不断指向下一个结点，currentIndex 累加 1。
- 当到链表末尾，则判断 currentIndex>index，处理异常。
- 将 tempNode.next 赋值给 node.next。
- 将 node 赋值给 tempNode.next。
/**
* 单链表插入
* @param node 插入的值
* @param index 插入到第 index 个元素
*/
public void addNode(Node node, int index) {
int currentIndex = 0;
Node tempNode = header;
while (tempNode.next != null && currentIndex < index) {
tempNode = tempNode.next;
currentIndex ++;
}
if (currentIndex > index) {
throw new RuntimeException("超出链表范围!");
}
node.next = tempNode.next;
tempNode.next = node;
}
3.2.2 单链表的删除
单链表删除思路：
- 验证链表是否为空。
- 当 currentIndex<index 的时候，就遍历链表，让 tempNode 向后移动，不断指向下一个结点，currentIndex 累加 1。
- 如果 currentNode 为空，则说明第 index 个结点不存在。
- 查找成功，则将要删除的结点 currentNode.next 赋值给 resultNode。
- 单链表的删除语句， currentNode.next = resultNode.next。
- 返回 resultNode 结点。
/**
* 单链表删除
* @param index 删除第 index 个元素
* @return 删除的 Node
*/
public Node deleteNode(int index) {
if (header.next == null) {
throw new RuntimeException("单链表为空！");
}
Node tempNode = header;
int currentIndex = 0;
while (tempNode.next != null && currentIndex < index) {
tempNode = tempNode.next;
currentIndex++;
}
if (tempNode.next == null || currentIndex > index) {
throw new RuntimeException("元素不存在");
}
Node resultNode = tempNode.next;
tempNode.next = resultNode.next;
return resultNode;
}
3.3 线性表链式结构的优缺点
线性表的链式存储结构的优缺点如下所示： 优点：
- 不需要提取分配内存，元素个数不受限制。
- 单链表在找出位置后，时间复杂度为O(1)。 缺点：
- 查找的时间复杂度为O(n)。
3.4 单链表的常见面试题
-
- 求单链表的个数
-
- 查找单链表倒数第 k 个结点
4 单链表结构与顺序存储结构的优缺点
存储分配方式
- 顺序存储结构用一段连续存储单元依次存储线性表的数据元素
- 单链表采用链式存储结构，用一组任意的存储单元存放线性表 时间性能
- 查找
- 顺序存储结构O(1)
- 单链表O(n)
- 插入与删除
- 顺序存储结构时间复杂度为O(n)
- 单链表存储结构在找出位置的指针后，插入和删除时间复杂度为O(1)
- 空间性能
- 顺序存储结构需要预分配存储空间，分大了浪费，分小了易发生上溢
- 单链表不需要分配存储空间，只有有就可以分配，元素个数不受限
5 环形链表
约瑟夫问题:
设编号为1，2，。。。n的n个人围坐成一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m的那个人出列，然后从它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
