2. 链表
2.1 链表原理介绍
链表是有序的列表,他在内存中的存储如下:
- 链表是以节点的方式存储
- 每个节点包含data域,next域:指向下一个节点
- 如图:发现链表的各个节点不一定是连续存储
- 链表分带头节点的链表和没有头节点的链表,根据实际的需求来确定
单链表(带头结点)逻辑结构示意图:最后指向null表示链表结束
2.2 代码实现
- 这个并没有考虑顺序,直接添加到链表的尾部。
package DataStructures;
public class SingleLinkedListDemo {
public static void main(String[] args) {
//进行测试
//先创建节点
HeroNode hero1 = new HeroNode(1,"松江","及时雨");
HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
HeroNode hero3 = new HeroNode(3,"吴用","智多星");
HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
//创建链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
//加入数据
singleLinkedList.add(hero1);
singleLinkedList.add(hero2);
singleLinkedList.add(hero3);
singleLinkedList.add(hero4);
//显示一下
singleLinkedList.list();
}
}
//定义SingleLinkedList管理我们的英雄
class SingleLinkedList{
//先初始化一个头节点,头节点不动,不存放具体的数据
private HeroNode head = new HeroNode(0,"","");
//添加节点到单向链表
/*
* 思路:当不考虑编号顺序时
* 1. 找到当前链表的最后节点
* 2. 将最后这个节点的next 指向新的节点
* */
public void add(HeroNode heroNode){
//因为head节点不能动,因此我们需要一个遍历的temp
HeroNode temp = head;
//遍历链表,找到最后
while(true){
//找到链表的最后
if (temp.next == null){
break;
}
//如果没有找到最后,将temp后移
temp = temp.next;
}
//当退出while循环时,temp就指向了链表的最后
//将最后这个节点的next 指向新的节点
temp.next = heroNode;
}
//显示链表【遍历】
public void list(){
//判断链表是否为空
if (head.next == null){
System.out.println("链表为空");
return;
}
//因为头节点,不能动,因此我们需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true){
//判断是否到链表的最后
if (temp == null){
break;
}
//输出节点信息
System.out.println(temp);
//将temp后移,一定小心
temp = temp.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 + ", nickename=" + nickname + "]";
}
}
运行结果
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
- 第二种方式,根据排名将英雄插入到指定位置,(如果有这个排名,则添加失败,并给出提示)
代码实现
package DataStructures;
public class SingleLinkedListDemo {
public static void main(String[] args) {
//进行测试
//先创建节点
HeroNode hero1 = new HeroNode(1,"松江","及时雨");
HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
HeroNode hero3 = new HeroNode(3,"吴用","智多星");
HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
//创建链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
//加入数据
// singleLinkedList.add(hero1);
// singleLinkedList.add(hero4);
// singleLinkedList.add(hero3);
// singleLinkedList.add(hero2);
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero2);
//显示一下
singleLinkedList.list();
}
}
//定义SingleLinkedList管理我们的英雄
class SingleLinkedList{
//先初始化一个头节点,头节点不动,不存放具体的数据
private HeroNode head = new HeroNode(0,"","");
//添加节点到单向链表
/*
* 思路:当不考虑编号顺序时
* 1. 找到当前链表的最后节点
* 2. 将最后这个节点的next 指向新的节点
* */
public void add(HeroNode heroNode){
//因为head节点不能动,因此我们需要一个遍历的temp
HeroNode temp = head;
//遍历链表,找到最后
while(true){
//找到链表的最后
if (temp.next == null){
break;
}
//如果没有找到最后,将temp后移
temp = temp.next;
}
//当退出while循环时,temp就指向了链表的最后
//将最后这个节点的next 指向新的节点
temp.next = heroNode;
}
public void addByOrder(HeroNode heroNode){
//因为指针节点不能动,因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//因为是单链表,我们找的temp 是位于添加位置的前一个节点,否则插入失败
HeroNode temp = head;
boolean flag = false;//flag 标志添加的编号是否存在,默认为false
while (true){
if (temp.next == null){
//说明temp已经在链表的最后
break;
}
if (temp.next.no > heroNode.no){
//位置找到,就在temp的后面插入
break;
}else if (temp.next.no == heroNode.no){
//说明希望添加的heroNode的编号已经存在
flag = true;//说明编号已存在
break;
}
temp = temp.next;//后移,遍历当前链表
}
//判断flag的值
if (flag){
//不能添加说明编号存在
System.out.printf("准备插入的英雄的编号 %d 已经存在了,不能加入\n",heroNode.no);
}else {
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//显示链表【遍历】
public void list(){
//判断链表是否为空
if (head.next == null){
System.out.println("链表为空");
return;
}
//因为头节点,不能动,因此我们需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true){
//判断是否到链表的最后
if (temp == null){
break;
}
//输出节点信息
System.out.println(temp);
//将temp后移,一定小心
temp = temp.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 + ", nickename=" + nickname + "]";
}
}
运行结果
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
- 修改链表的数据
//修改节点的信息,根据no编号来修改,即no编号不嫩改
//说明:根据newHeroNode的no来修改即可
public void update(HeroNode newHeroNode){
//判断为空
if (head.next == null){
System.out.println("链表为空~~~");
return;
}
//找到需要修改的节点,根据no编号
//定义一个辅助变量
HeroNode temp = head.next;
boolean flag = false;//表示是否找到该节点
while(true){
if (temp == null){
break;//已经遍历完链表
}
if (temp.no == newHeroNode.no){
//找到
flag = true;
break;
}
temp = temp.next;
}
//根据flag 判断是否找到想要修改的节点
if (flag){
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
}else {
//没有找到
System.out.printf("没有找到编号 %d 的节点,不能修改\n",newHeroNode.no);
}
}
运行结果
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
修改后的链表情况~~
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=小卢, nickename=玉麒麟~~]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
- 删除链表的节点
//删除节点
/*
* 1. head不能栋,因此我们需要一个temp辅助节点找到待删除节点的前一个节点
* 2. 说明我们在比较时,是temp.next.no和需要删除的节点的no 比较
* */
public void dal(int no){
HeroNode temp = head;
boolean flag = false; //标志是否找到待删除的节点
while (true){
if (temp.next == null){
//已经到了链表的最后
break;
}
if (temp.next.no == no){
//找到的待删除节点的前一个节点temp
flag = true;
break;
}
temp = temp.next; //temp后移,遍历
}
//判断flag
if (flag){
//找到,可以删除
temp.next = temp.next.next;
}else{
System.out.printf("要删除的 %d 几点不存在\n",no);
}
}
运行结果
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
修改后的链表情况~~
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=小卢, nickename=玉麒麟~~]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
删除后的链表情况~~~~
HeroNode [no=2, name=小卢, nickename=玉麒麟~~]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
2.3 面试题
- 求单链表中有效节点的个数
- 查找单链表中的倒数第k个节点【新浪面试题】
- 单链表的反转【腾讯面试题】
- 从尾到头打印单链表【百度,要求方式1:反向遍历。方式2:Stack栈】
- 合并两个有序的单链表,合并之后依然有序【课后练习】
2.3.1 第一题
代码的实现:
//方法:获取到单链表的节点的个数(如果是带头节点的链表,不需要统计头节点
public static int getLength(HeroNode head){
if (head.next == null){
return 0;
}
int length = 0;
//定义一个辅助变量,这里我们没有统计头节点
HeroNode cur = head.next;
while(cur != null){
length++;
cur = cur.next;
}
return length;
}
因为头节点是私有的,所以我们需要自己重新写一个方法来实现:
//这是一个私有属性,我们需要写一个返回方法
public HeroNode getHead(){
return head;
}
运行的结果如下:
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
修改后的链表情况~~
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=小卢, nickename=玉麒麟~~]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
删除后的链表情况~~~~
HeroNode [no=2, name=小卢, nickename=玉麒麟~~]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
有效的节点个数=3
2.3.2 第二道题
代码:
//查找单链表的倒数第k个节点
/*
* 思路:
* 1. 编写一个方法,接受head节点,同时接收一个index
* 2. index表示是倒数第index个节点
* 3. 先把链表从头到尾遍历,得到链表的总的长度getLength
* 4. 得到size 后,我们从链表的第一个开始遍历(size-index)个,就可以得到
* 5. 如果找到了,则返回该节点,否则返回null
* */
public static HeroNode findLastIndexNode(HeroNode head, int index){
//判断如果链表为空,返回null
if (head.next == null){
return null;
}
//第一个遍历得到的链表的长度(节点个数)
int size = getLength(head);
//第二次遍历 size - index 位置,就是我们倒数第k个节点
//先做一个index的校验
if (index <= 0 || index > size){
return null;
}
//定义给辅助变量,for 循环定位到倒数Index
HeroNode cur = head.next;
for (int i = 0;i < size - index; i++){
cur = cur.next;
}
return cur;
}
运行的结果是:
删除后的链表情况~~~~
HeroNode [no=2, name=小卢, nickename=玉麒麟~~]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
有效的节点个数=3
res=HeroNode [no=4, name=林冲, nickename=豹子头]
2.3.3 第三道题
//将单链反转
public static void reverseList(HeroNode head){
//如果当前链表为空,或者只有一个节点,无需反转,直接返回
if (head.next == null || head.next.next == null){
return;
}
//定义一个辅助的指针(变量),帮助我们遍历原来的链表
HeroNode cur = head.next;
HeroNode next = null; //指向当前节点[cur]的下一个节点
HeroNode reverseHead = new HeroNode(0,"","");
//遍历原来的链表,每遍历一个节点,就将其取出,并放在新的链表reversrHead的最前端
while (cur != null){
next = cur.next; //先暂时保存当前节点的下一个节点,因为后面需要使用
cur.next = reverseHead.next; //将cur的下一个节点指向新的链表的最前端
reverseHead.next = cur; //将cur连接到新的链表上
cur = next; //让cur后移
}
//将head.next 指向reverseHead.next ,实现单链表的反转
head.next = reverseHead.next;
}
结果:
原来的链表情况~~~
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=4, name=林冲, nickename=豹子头]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
反转单链表~~~
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
HeroNode [no=1, name=松江, nickename=及时雨]
代码分析
1.cur:在原始表中的当前节点,这个节点要转移到新的reverseHead链表中。
2.next:next是cur的下一个节点,它存在的意义就是让cur知道自己接下来要搞哪个节点,因为本身的cur会被转移走。
2.3.4 第四题
代码实现:
//使用方式 2:可以利用这个数据结构,将各个节点压入栈中,然后利用栈的先进后出的特点,就实现了逆序打印的效果
public static void reversePrint(HeroNode head){
if (head.next == null){
return;//空链表,不能打印
}
//创建一个栈,将各个节点压入栈
Stack<HeroNode> stack = new Stack<HeroNode>();
HeroNode cur = head.next;
//将链表的所有节点压入栈
while(cur != null){
stack.push(cur);
cur = cur.next; //cur后移,这样就可以压入下一个节点
}
//将栈中的节点进行打印,pop出栈
while(stack.size() > 0){
System.out.println(stack.pop());
}
}
结果显示:
原来的链表情况~~~
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=4, name=林冲, nickename=豹子头]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
测试逆序打印单链表,没有改变链表的结构~~~
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
HeroNode [no=1, name=松江, nickename=及时雨]
代码分析
就是使用栈这个高级的方法。其实代码一般般吧。
2.4 双向链表
单向链表的缺点分析:
- 单向链表,查找的方向只能是一个方向,而双向链表可以向前或者向后。
- 单向链表不能自我删除,需要靠辅助节点,而双向节点链表,则可以自我删除,所以前面我们单链表删除节点,总是找到temp的下一个节点来删除的(认真体会)。
增删改代码
package DataStructures;
public class DoubleLinkedListDemo {
public static void main(String[] args) {
//进行测试
System.out.println("双向链表的测试");
//先创建节点
HeroNode2 hero1 = new HeroNode2(1, "松江", "及时雨");
HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");
//创建一个双向链表
DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
doubleLinkedList.add(hero1);
doubleLinkedList.add(hero2);
doubleLinkedList.add(hero3);
doubleLinkedList.add(hero4);
doubleLinkedList.list();
//修改
HeroNode2 newHeroNode = new HeroNode2(4,"公孙胜","入云龙");
doubleLinkedList.update(newHeroNode);
System.out.println("修改后的链表情况~~~");
doubleLinkedList.list();
//删除
doubleLinkedList.dal(3);
System.out.println("删除后的链表情况~~~");
doubleLinkedList.list();
}
}
class DoubleLinkedList{
//先初始化一个头节点,头节点不动,不存放具体的数据
private HeroNode2 head = new HeroNode2(0,"","");
//这是一个私有属性,我们需要写一个返回方法
public HeroNode2 getHead(){
return head;
}
//显示链表【遍历】
public void list(){
//判断链表是否为空
if (head.next == null){
System.out.println("链表为空");
return;
}
//因为头节点,不能动,因此我们需要一个辅助变量来遍历
HeroNode2 temp = head.next;
while (true){
//判断是否到链表的最后
if (temp == null){
break;
}
//输出节点信息
System.out.println(temp);
//将temp后移,一定小心
temp = temp.next;
}
}
//添加一个节点到双向链表的最后
public void add(HeroNode2 heroNode){
//因为head节点不能动,因此我们需要一个遍历的temp
HeroNode2 temp = head;
//遍历链表,找到最后
while(true){
//找到链表的最后
if (temp.next == null){
break;
}
//如果没有找到最后,将temp后移
temp = temp.next;
}
//当退出while循环时,temp就指向了链表的最后
//形成一个双向链表
temp.next = heroNode;
heroNode.pre = temp;
}
//修改一个节点的内容,可以看到双向链表的节点内容和单向链表一样
public void update(HeroNode2 newHeroNode){
//判断为空
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 == newHeroNode.no){
//找到
flag = true;
break;
}
temp = temp.next;
}
//根据flag 判断是否找到想要修改的节点
if (flag){
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
}else {
//没有找到
System.out.printf("没有找到编号 %d 的节点,不能修改\n",newHeroNode.no);
}
}
//从一个双向链表中删除一个节点
/*
* 1. 对于双向链表,我i们可以直接找到要删除的这个节点
* 2. 找到后,自我删除即可
* */
public void dal(int no){
//判断当前链表是否为空
if (head.next == null){
System.out.println("链表为空,无法删除~~~");
return;
}
HeroNode2 temp = head.next;
boolean flag = false; //标志是否找到待删除的节点
while (true){
if (temp == null){
//已经到了链表的最后节点的next
break;
}
if (temp.no == no){
//找到的待删除节点的前一个节点temp
flag = true;
break;
}
temp = temp.next; //temp后移,遍历
}
//判断flag
if (flag){
//找到,可以删除
temp.pre.next = temp.next;
//这里需要注意:如果是最后一个节点,就不需要执行下面这句话,否者会出现空指针异常,null.pre
if (temp.next != null){
temp.next.pre = temp.pre;
}
}else{
System.out.printf("要删除的 %d 几点不存在\n",no);
}
}
}
//定义HeroNode, 每个HeroNode对象就是一个节点
class HeroNode2{
public int no;
public String name;
public String nickname;
public HeroNode2 next; //指向下一个节点,默认为null
public HeroNode2 pre; //指向前一个节点,默认为null
//构造器
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 + ", nickename=" + nickname + "]";
}
}
运行结果
双向链表的测试
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
修改后的链表情况~~~
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=公孙胜, nickename=入云龙]
删除后的链表情况~~~
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=4, name=公孙胜, nickename=入云龙]
顺序添加的代码
public void addByOrder(HeroNode2 heroNode){
//因为指针节点不能动,因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//因为是单链表,我们找的temp 是位于添加位置的前一个节点,否则插入失败
HeroNode2 temp = head;
boolean flag = false;//flag 标志添加的编号是否存在,默认为false
while (true){
if (temp.next == null){
//说明temp已经在链表的最后
break;
}
if (temp.next.no > heroNode.no){
//位置找到,就在temp的后面插入
break;
}else if (temp.next.no == heroNode.no){
//说明希望添加的heroNode的编号已经存在
flag = true;//说明编号已存在
break;
}
temp = temp.next;//后移,遍历当前链表
}
//判断flag的值
if (flag){
//不能添加说明编号存在
System.out.printf("准备插入的英雄的编号 %d 已经存在了,不能加入\n",heroNode.no);
}else {
temp.next = heroNode;
heroNode.pre = temp;
}
}
运行的结果
双向链表的测试
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=林冲, nickename=豹子头]
修改后的链表情况~~~
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=公孙胜, nickename=入云龙]
删除后的链表情况~~~
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=4, name=公孙胜, nickename=入云龙]
顺序添加~~~
HeroNode [no=1, name=松江, nickename=及时雨]
HeroNode [no=2, name=卢俊义, nickename=玉麒麟]
HeroNode [no=3, name=吴用, nickename=智多星]
HeroNode [no=4, name=公孙胜, nickename=入云龙]
注意事项:
- 添加需要记住的代码是:
temp.next = heroNode;
heroNode.pre = temp;
- 删除需要记住的代码是:
temp.pre.next = temp.next;
if (temp.next != null){
temp.next.pre = temp.pre;
}
2.5 单向环形链表
Josephu问题
设编号为1,2,… n的n个人围坐一圈,约定编号为k(1<=k<=n)的人从1开始报数,数到 m 的那个人出列,它的下一位又从1开始报数,数到 m 的那个人又出列,依次类推,直到所有人出列为止,由此产生一个出队编号的序列。
算法的实现
用一个不带头结点的循环链表来处理Josephu 问题:先构成一个有n个结点的单循环链表,然后由k结点起从1开始计数,计到m时,对应结点从链表中删除,然后再从被删除结点的下一个结点又从1开始计数,直到最后一个结点从链表中删除算法结束。
代码的实现
package DataStructures;
public class Josephu {
public static void main(String[] args) {
//测试一下
CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
circleSingleLinkedList.addBoy(5);
circleSingleLinkedList.showBoy();
}
}
//创建一个环形的单向链表
class CircleSingleLinkedList {
//创建一个first节点,当前没有编号
private Boy first = new Boy(-1);
//添加小孩节点,构建一个环形的链表
public void addBoy(int nums){
//nums做一个数据校验
if (nums < 1){
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(){
//判断链表是否为空
if (first == null){
System.out.println("没有任何小孩~~~");
return;
}
//因为first不能动,因此我们仍然使用一个辅助指针完成遍历
Boy curBoy = first;
while(true){
System.out.printf("小孩的编号 %d \n",curBoy.getNo());
if (curBoy.getNext() == first){
//说明遍历已经完毕
break;
}
curBoy = curBoy.getNext();//curboy后移
}
}
}
//创建一个Boy类,表示一个节点
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;
}
}
运行结果
小孩的编号 1
小孩的编号 2
小孩的编号 3
小孩的编号 4
小孩的编号 5
小孩出圈的顺序代码
//根据用户的输入,计算出几个小孩的出圈顺序
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 j = 0; j < startNo - 1; j++){
first = first.getNext();
helper = helper.getNext();
}
//当小孩报数时,让first 和 helper 移动 m-1 次,然后出圈
//这是一个循环操作,知道圈中只有一个节点
while (true){
if (helper == first){
//说明圈中只有一个节点
break;
}
//让first 和 helper 移动 countNum - 1 次
for (int j = 0;j < countNum -1;j++ ){
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());
}
结果的运行
小孩 2 出圈
小孩 4 出圈
小孩 1 出圈
小孩 5 出圈
最后留在圈中的小孩编号3