链表的介绍
- 链表是以节点的方式来存储，是链式存储
- 每个节点包含data域，next域：指向下一个节点
- 上图所示：链表的各个节点不一定是连续存储
- 链表分带头结点链表和没有头节点链表，根据实际需求来确定
- 单链表（带头节点）逻辑结构图如下所示：
单链表的应用
第一种添加，直接添加到链表的尾部
第二种添加，根据编号添加（如果有这个编号，则添加失败，并给出提示）
修改节点的功能
- 先找到节点，通过遍历
- 设置一个临时变量将需要修改的内容修改即可！temp.name= heroNode.name
删除节点
代码实现如下：
//定义SingleLinkedList 管理我们的英雄
class SingleLinkedList{
//先初始化一个头结点,头结点不要动 不存放具体的数据
private HeroNode head = new HeroNode(0,"","");
public HeroNode getHead(){
return head;
}
//添加节点到单向链表
//思路：当不考虑编号顺序
//1.找到当前链表的最后节点
//2.将最后这个节点的next 指向新的节点
public void add(HeroNode heroNode){
//因为head节点不能动，所以要设置一个辅助量 tmp
HeroNode tmp = head;
//遍历链表，找到最后
while (true){
//判断节点的next 是否为空，为空就是最后的节点
if (tmp.next == null){
break;
}
//如果不为空，节点向后移
tmp = tmp.next;
}
//当退出while循环时，说明找到了最后节点
//将最后这个节点指向新的节点
tmp.next = heroNode;
}
//第二种方式添加英雄时，根据排名将英雄插入到指定位置
//（如果有这个排名，将添加失败，并给出提示）
public void addByOrder(HeroNode heroNode){
//因为头结点不能动，因此我们扔然通过一个辅助量指令来帮助找到添加的位置
//因为单链表，我们找的tmp 是位于 添加位置的前一个节点，否则添加不了
HeroNode tmp = head;
boolean flag = false;//判断要加入的英雄的编号是否存在，默认是false
while (true){
if (tmp.next == null){//说明tmp已经在链表的最后
break;
}
if (tmp.next.no > heroNode.no){ //如果发现tmp的后续节点的编号大于新加入节点的编号，说明位置找到，就在tmp和tmp.next的中间
break;
}else if (tmp.next.no == heroNode.no){ //如果节点的编号已经存在，则给出提示
flag = true;
break;
}
//如若都不符合，则节点指针后移,遍历当前链表
tmp = tmp.next;
}
//判断flag的值
if (flag){
System.out.printf("准备插入的英雄的编号%d已经存在了，不能加入\n",heroNode.no);
}else {
//将新的英雄节点添加进去
//思路：
// heroNode.next = tem.next
// tem.next = heroNode
heroNode.next = tmp.next;
tmp.next = heroNode;
}
}
//修改节点的信息，根据编号来修改，即编号不能改
public void update(HeroNode heroNode){
//判断链表是否为空
if (head.next == null){
System.out.println("链表为空");
}
//找到需要修改的节点，根据no编号
//定义一个辅助变量
HeroNode tmp = head.next;
boolean flag = false;//表示是否找到节点
while (true){
if (tmp == null){
break;//到链表的最后,已经遍历完链表
}
if (tmp.no == heroNode.no){
//找到了
flag = true;
break;
}
tmp = tmp.next;
}
//根据flag，判断是否找到要修改的节点
if(flag){
tmp.name = heroNode.name;
tmp.nickName = heroNode.nickName;
}else {//没有找到
System.out.printf("没有找到编号 %d 的节点，不能修改\n",heroNode.no);
}
}
/**
* 删除节点
* 思路：
* 1.head节点不能动，因此需要一个tmp辅助节点找到待删除节点的前一个节点
* 2.说明我们在比较时，是tmp.next.no 和 需要删除的节点的no比较
* @return
*/
public void deleteByNo(int no){
HeroNode tmp = head;
boolean flag = false;//标志是否找到待删除的节点
while (true){
if (tmp.next == null){
break;//已经到达链表的最后
}
if(tmp.next.no == no){
flag = true;//找到了待删除节点的前一个节点的tmp
break;
}
tmp = tmp.next;//指针后移，遍历
}
//判断flag
if (flag) {//找到
tmp.next = tmp.next.next;
}else {
System.out.printf("要删除的节点 %d 不存在",no);
}
}
//显示链表
public void list(){
//判断链表是否为空
if (head.next == null){
System.out.println("链表为空");
return;
}
//因为头结点不能动，所以我们需要一个辅助量来进行遍历,之所以将tmp赋值为head.next
//是因为上面我们进行了判断，链表不为空，则至少有一个数据
HeroNode tmp = head.next;
while (true){
//判断是否到链表的最后
if (tmp == null){
break;
}
//输出节点信息
System.out.println(tmp);
//将next 一定要后移
tmp = tmp.next;
}
}
}
//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode{
public int no;
public String name;
public String nickName;
public HeroNode next; //指向下一个节点
public HeroNode(int no,String name,String nickName){
this.no = no;
this.name = name;
this.nickName = nickName;
}
//为了显示方法，重新写toString
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName + '\'' +'}';
}
双向链表应用实例
使用带head头的双向链表实现——水浒传英雄排行榜管理单向链表的缺点分析：
- 单向链表，查找方向只能是一个方向，而双向链表可以向前或者向后查找
- 单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面的单链表删除节点，总是找到temp的下一个节点来删除的（temp是待删除节点的前一个节点）
分析双向链表的遍历、添加、修改、删除的操作思路
- 遍历方法和单链表一样，只是可以向前，也可以向后
- 添加（默认添加到双向链表的最后）
- 先找到双向链表的最后这个节点
- temp.next = newHeroNode
- newHeroNode.pre = temp;
- 修改思路和原理和单链表一样
- 删除
- 因为是双向链表，因此，我们可以实现自我删除某个节点
- 直接找到要删除的这个节点，比如temp
- temp.pre.next = temp.next
- temp.next.pre = temp.pre
//创建一个双向链表
class DoubleLinkedList {
//创建一个双向链表
HeroNode2 head = new HeroNode2(0,"","");
public HeroNode2 getHead(){
return head;
}
//遍历双向链表
public void list(){
if (head.next == null){
System.out.println("双向链表为null");
return;
}
HeroNode2 temp = head.next;
while (true){
//判断是否到达链表的最后
if (temp == null){
break;
}
//输出节点信息
System.out.println(temp);
//节点后移
temp = temp.next;
}
}
//添加操作
public void add(HeroNode2 heroNode){
//因为head节点不能动，所以需要一个辅助节点
HeroNode2 temp = head;
while (true){
if (temp.next == null){
break;
}
//如果没有找到最后，将节点后移
temp = temp.next;
}
//当退出while循环时，temp就指向了链表的最后
//形成一个双向链表
temp.next = heroNode;
heroNode.pre = temp;
}
//修改一个节点的内容
public void update(HeroNode2 heroNode){
//判断链表是否为空
if (head.next == null){
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据no修改
//定义一个辅助节点
HeroNode2 temp = head.next;
//表示是否找到该节点
boolean flag = false;
while (true){
if (temp == null){
break;//已经遍历完链表
}
if (temp.no == heroNode.no){
flag = true;
break;
}
//节点后移
temp = temp.next;
}
//根据flag判断是否找到需要修改的节点
if (flag){
temp.name = heroNode.name;
temp.nickName = heroNode.nickName;
}else {
System.out.println("链表中没有需要修改的节点");
}
}
//从双向链表中删除一个节点
//说明
//1. 对于双向链表，我们可以直接找到要删除的这个节点
//2. 找到后，自我删除即可！
public void delete(int no){
//判断链表当前是否为null
if(head.next == null){
System.out.println("链表为null");
return;
}
HeroNode2 temp = head.next;//辅助变量
boolean flag = false;
while (true){
if (temp == null){
break;
}
if (temp.no == no){
flag = true;
break;
}
temp = temp.next;
}
//判断flag
if (flag){
temp.pre.next = temp.next;
//如果是最后一个节点，则不需要执行下面这句代码,否则出现空指针
if (temp.next != null){
temp.next.pre = temp.pre;
}
}else {
System.out.println("未找到该删除的节点");
}
}
}
//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode2{
public int no;
public String name;
public String nickName;
public HeroNode2 next; //指向下一个节点。默认为null
public HeroNode2 pre;//指向前一个节点
public HeroNode2(int no,String name,String nickName){
this.no = no;
this.name = name;
this.nickName = nickName;
}
//为了显示方法，重新写toString
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName + '\'' +'}';
}
}
单向环形链表应用场景
Josephu（约瑟夫、约瑟夫环）问题
Josephu问题为：设编号为1，2，....n的n个人围坐在一圈，约定编号为k(1<=k<=n)的人开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人出列，以此类推，直到所有人出列为止，由此产生一个出队列编号的序列
提示：
用一个不带头节点的循环链表来处理Josephu问题，先构成一个有n个节点的单循环链表，然后由k节点起从1开始计数，计到m时，对应节点从链表中删除，然后再从被删除的节点的下一个节点又从1开始计数，直到最后一个节点从链表中删除算法结束！
构建一个单向的环形链表的思路：
1. 先创建一个节点，让first指向该节点，并形成环形
2. 后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可！
遍历环形链表：
1. 先让一个辅助指针（遍历）curBoy，指向first节点
2. 然后通过一个while循环遍历该环形链表即可 curBoy.next == first 结束
代码实现如下：
//创建一个环形的单向链表
static class CircleSingleLinkedList{
//创建一个first节点，当前没有编号
private Boy first = null;
//添加小孩节点，构建一个环形链表
public void addBoy(int nums){
//nums做一个数据校验
if (nums < 2){
System.out.println("nums的值不正确！");
return;
}
Boy curBoy = null;//辅助指针，帮助构建环型链表
//使用for来创建我们的环型链表
for (int i = 1; i <= nums; i++) {
//根据编号创建小孩
Boy boy = new Boy(i);
//如果是第一个小孩
if (i ==1){
first = boy;
first.setNext(first); //构成环
curBoy = first;//让curBoy指向第一个小孩
}else {
curBoy.setNext(boy);
boy.setNext(first);
curBoy = boy;
}
}
}
//遍历当前的环型链表
public void showBoy(){
//判断链表是否为null
if (first == null){
System.out.println("没有任何小孩！");
}
//因为first不能动，因此我们仍然使用一个辅助指针完成遍历
Boy curBoy = first;
while (true){
System.out.printf("小孩的编号%d\n",curBoy.getNo());
if (curBoy.getNext() == first){//说明遍历完毕
break;
}
curBoy = curBoy.getNext();//curBoy后移
}
}
}
//创建一个Boy类，表示一个节点
static class Boy{
private int no; //编号
private Boy next; // 指向下一个节点，默认为null
public Boy(int no){
this.no = no;
}
public int getNo(){
return no;
}
public void setNo(int no){
this.no = no;
}
public Boy getNext(){
return next;
}
public void setNext(Boy next){
this.next = next;
}
}
代码实现如下：
/**
* 根据用户的输入，计算出出圈的顺序
* @param startNo 表示从第几个小孩开始数数
* @param countNum 表示数几下
* @param nums 表示最初有多少小孩在圈中
*/
public void countBoy(int startNo,int countNum,int nums){
//先对数据进行校验
if (first == null || startNo<1 || startNo > nums){
System.out.println("参数输入有误！");
return;
}
//创建一个辅助指针，帮助小孩出圈
Boy helper = first;
//需要创建一个辅助指针（变量）helper,事先应该指向环型链表的最后这个节点
while (true){
if (helper.getNext() == first){//说明helper指向最后小孩节点
break;
}
helper = helper.getNext();
}
//小孩报数前，先让first 和 helper移动k - 1次
for (int i = 0; i < startNo - 1; i++) {
first = first.getNext();
helper = helper.getNext();
}
//当小孩报数时，让first 和 helper指针同时的移动m -1 次，然后出圈
//这里是一个循环操作，直到圈中只有一个节点
while (true){
if (helper == first){//说明圈中只有一个节点
break;
}
//让first 和 helper 指针同时 的移动 countNum - 1,然后出圈
for (int i = 0; i < countNum - 1; i++) {
first = first.getNext();
helper = helper.getNext();
}
//这时first指向的节点，就是要出圈的小孩节点
System.out.printf("小孩%d出圈\n",first.getNo());
//这时将first指向的小孩节点出圈
first = first.getNext();
helper.setNext(first);
}
System.out.printf("最后留在圈中的小孩编号%d\n",first.getNo());
}
链表的学习到此结束！为自己加油！
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
