二、链表
1、介绍
链表是一个有序的列表，上一个数据连接下一个数据，通过链表指针连接，顺序不可改变。
看一下链表在内存中的存储结构：
1. 链表是以节点的形式存储在内存空间中，是链式存储；
2. 每个节点包括data域（存储数据）和next域（存储指向下一节点的地址值）；
3. 虽然节点是有顺序的，但是在内存中去不是连续的，通过各个节点的连接实现有序存储；
4. 链表分为有头节点和无头节点，头节点内只存储next域，指向链表的第一个节点。
1.1 链表的初始化
// 定义节点，每个LinkedNode对象就是一个节点
class LinkedNode {
int val;
String name;
LinkedNode next; // 指向下一个节点
// 构造器
public LinkedNode(int val, String name) {
this.val = val;
this.name = name;
}
// 重写toString
@Override
public String toString() {
return "LinkedNode{" +
"val=" + val +
", name=" + name +
'}';
}
}
1.2 链表的添加
class SingleLinkedList {
// 定义一个头节点
LinkedNode headNode = new LinkedNode(0,"");
public LinkedNode getHead() {
return head;
}
// 添加节点到单向链表
// 1.找到当前列表的最后节点
// 2.将这个节点的next域指向要添加的节点
public void add(LinkedNode linkedNode) {
// 因为head节点永远指向第一个节点处，一旦移动的话就会找不到第一个节点
// 因此我们需要一个辅助节点
// 添加链表所以存在链表为空的情况，所以将temp设为头节点
LinkedNode temp = headNode;
while (true) {
// 因为temp此时是头节点，所以要判断.next是否为空
if (temp.next == null) {
break;
}
temp = temp.next;
}
temp.next = linkedNode;
}
// 遍历链表
public void showList() {
if (headNode.next == null) {
System.out.println("链表为空");
return;
}
// 同样的原因
// 因为上面已经判断了链表为空，所以这里可以直接将temp设置为第一个节点
LinkedNode temp = headNode.next;
while (true) {
// 这里的边界条件就可以直接判断temp是否为空了
if (temp == null) {
break;
}
System.out.println(temp.toString());
temp = temp.next;
}
}
}
这里我想谈一下本人之前对于辅助节点temp的一个错误认识：我之前的理解在于既然新建了一个辅助节点temp，那么之后的每一个temp = temp.next就是在重构了一个链表。
但现在有了新的理解，原先链表保持不变，改变的仅仅是temp，仅仅从temp的next域获得下一节点的地址，每一次temp = temp.next，就是把temp节点移动到正确的位置上，temp仅仅是原链表内部节点的映射。temp内部包含所映射节点的所有信息，包括data域和next域。
1.3链表的有序添加
首先我们需要遍历链表，找到待添加节点linkedNode的正确添加位置。存在三种情况：位置在链表末尾；在链表中间；链表中已存在待添加节点。在末尾和已存在的情况较为好处理，我们来看下在链表中间情况。
假设我们已遍历找到节点temp的next节点比待添加节点linkedNode大，那么意味着待添加节点linkedNode应该位于temp和temp.next之间。所以我们让linkedNode指向temp.next，temp指向linkedNode即可。
public void addOrder(LinkedNode linkedNode) {
// 因为head节点永远指向第一个节点处，一旦移动的话就会找不到第一个节点
// 因此我们需要一个辅助节点
// 添加链表所以存在链表为空的情况，所以将temp设为头节点
LinkedNode temp = headNode;
boolean flag = false; // flag定义为链表内是否存在即将添加的节点
while (true) {
if(temp.next == null) { // 表示遍历结束，节点可直接添加在链表尾部
break;
}
if(temp.next.val == linkedNode.val) { // 表示已存在待添加节点
flag = true;
break;
}else if(temp.next.val > linkedNode.val) { // 表示已经找到位置，具体分析看图示
break;
}
temp = temp.next;
}
if(flag) {
System.out.println("要添加的节点已经存在了");
}else {
linkedNode.next = temp.next;
temp.next = linkedNode;
}
}
1.4 单链表节点的修改
思路就是遍历链表，找到对应节点，然后将新节点的内容重新赋值给旧的节点。
public void update(LinkedNode linkedNode) {
// 先判断链表是否为空
if (headNode.next == null) {
System.out.println("链表为空");
return;
}
LinkedNode temp = headNode.next;
boolean flag = false;
while (true) {
if(temp == null) {
break;
}
if(temp.val == linkedNode.val) {
flag =true;
break;
}
temp = temp.next;
}
if(flag) {
temp.name = linkedNode.name;
}esle {
System.out.println("未找到对应节点");
}
}
1.5 单链表节点的删除
思路依旧是遍历链表，找到待删除的节点temp.next。既然要删除temp.next，意思就是temp指向的是temp.next.next。
public void deletData(LinkedNode linkedNode) {
// 先判断链表是否为空
if (headNode.next == null) {
System.out.println("链表为空");
return;
}
LinkedNode temp = headNode;
boolean flag = false;
while (true) {
if(temp.next == null) {
break;
}
if(temp.next.val == linkedNode.val) {
flag =true;
break;
}
temp = temp.next;
}
if(flag) {
temp.next = temp.next.next;
}esle {
System.out.println("未找到对应节点");
}
}
2、双向链表的简单叙述
2.1 双向链表的初始化
// 定义节点，每个LinkedNode对象就是一个节点
class LinkedNode2 {
int val;
String name;
LinkedNode2 next; // 指向下一个节点
LinkedNode2 pre; // 指向前一个节点
// 构造器
public LinkedNode2(int val, String name) {
this.val = val;
this.name = name;
}
// 重写toString
@Override
public String toString() {
return "LinkedNode2{" +
"val=" + val +
", name=" + name +
'}';
}
}
2.2 双向链表的添加
class DoubleLinkedList {
// 定义一个头节点
LinkedNode2 headNode = new LinkedNode2(0,"");
// 添加节点到单向链表
// 1.找到当前列表的最后节点
// 2.将这个节点的next域指向要添加的节点
public void add(LinkedNode2 linkedNode) {
// 因为head节点永远指向第一个节点处，一旦移动的话就会找不到第一个节点
// 因此我们需要一个辅助节点
// 添加链表所以存在链表为空的情况，所以将temp设为头节点
LinkedNode2 temp = headNode;
while (true) {
// 因为temp此时是头节点，所以要判断.next是否为空
if (temp.next == null) {
break;
}
temp = temp.next;
}
temp.next = linkedNode;
linkedNode.pre = temp;
}
// 遍历链表
public void showList() {
if (headNode.next == null) {
System.out.println("链表为空");
return;
}
// 同样的原因
// 因为上面已经判断了链表为空，所以这里可以直接将temp设置为第一个节点
LinkedNode2 temp = headNode.next;
while (true) {
// 这里的边界条件就可以直接判断temp是否为空了
if (temp == null) {
break;
}
System.out.println(temp.toString());
temp = temp.next;
}
}
}
2.3 双向链表的修改
与单向链表的遍历一致
public void updata(LinkedNode2 linkedNode) {
if(headNode.next == null) {
System.out.println("链表为空");
return;
}
LinkedNode2 temp = headNode.next;
boolean flag = false;
while(true) {
if(temp == null) {
return;
}
if(temp.val == linkedNode.val) {
flag =true;
break;
}
temp = temp.next;
}
if(flag) {
temp.name = linkedNode.name;
}else {
System.out.println("为找到对应节点");
}
}
2.4 双向链表的删除
public void deletData(LinkedNode2 linkedNode) {
// 先判断链表是否为空
if (headNode.next == null) {
System.out.println("链表为空");
return;
}
LinkedNode2 temp = headNode.next;
boolean flag = false; // 标志是否找到待删除节点
while (true) {
if(temp == null) {
break;
}
if(temp.val == linkedNode.val) {
flag =true;
break;
}
temp = temp.next;
}
if(flag) { // 找到节点
// 将temp前一节点指向temp后一节点
temp.pre.next = temp.next;
// 如果是最后一个节点，则无法将后一个节点指向前一个节点，需要判断
if(temp.next != null) {
temp.next.pre = temp.pre;
}
}esle {
System.out.println("未找到对应节点");
}
}
3、Joseph问题
约瑟夫环问题（Joseph）又称丢手绢问题：已知 m 个人围坐成一圈，由某人起头，下一个人开始从 1 递增报数，报到数字 n 的那个人出列，他的下一个人又从 1 开始报数，数到 n 的那个人又出列；依此规律重复下去，直到 m 个人全部出列约瑟夫环结束。如果从 0 ~ (m-1) 给这 m 个人编号，请输出这 m 个人的出列顺序。
3.1 环形链表的初始化
class BoyLinkedNode {
int id;
BoyLinkedNode next;
public BoyLinkedNode(int id) {
this.id = id;
}
@Override
public String toString() {
return "BoyLinkedNode{" +
"id=" + id +
'}';
}
}
3.2 环形链表的添加
class BoyLinkedList {
private BoyLinkedNode first = null;
/**
* 创建约瑟夫环
* @param num 表示有num个人
*/
public void addNode(int num) {
// 判断输入是否合理
if (num < 1) {
System.out.println("人数太少");
return;
}
// 同样first节点不可移动，需要一个辅助节点
BoyLinkedNode curBoy = null;
// for循环往链表中增加节点
for (int i = 1; i <= num; i++) {
BoyLinkedNode boy = new BoyLinkedNode(i);
// 第一个节点需要单独添加
// 便于将头结点映射给first节点
if (i == 1) {
first = boy;
first.next = first; // 一个节点也需要成环形链表
curBoy = first; // 映射辅助节点
}
curBoy.next = boy;
boy.next = first;
curBoy = boy;
}
}
}
3.3 约瑟夫环的游戏部分
/**
*
* @param startId 表示从哪个节点开始数
* @param countNum 表示数几下
* @param num 表示一共有几个节点
*/
public void countBoy(int startId, int countNum, int num) {
// 先判断输入的合理性
if (startId < 1 || startId > num || num < 1) {
System.out.println("重新输入");
return;
}
// 需要一个辅助节点helperBoy与first配合，first寻找出局节点，helperBoy负责将出局节点的前后节点连接
// 不再需要原链表，所以first可以移动
BoyLinkedNode helperBoy = first;
// helperBoy节点到达指定节点
while (true) {
if (helperBoy.next == first) {
break;
}
helperBoy = helperBoy.next;
}
// first节点到达开始读数节点位置，helperBoy跟随
for (int i = 0; i < startId-1; i++) {
first = first.next;
helperBoy = helperBoy.next;
}
while (true) {
// 跳出循环条件，helperBoy==first
if (helperBoy == first) {
break;
}
// for循环寻找出局节点，
for (int i = 0; i < countNum-1; i++) {
first = first.next;
helperBoy = helperBoy.next;
}
System.out.printf("%d出队
",first.id);
helperBoy.next = first.next; // 节点出局
first = first.next;
}
System.out.printf("%d出队
",first.id);
}