链表-单链表内存结构、逻辑结构、特点、定义、遍历、尾插、按顺序插入、修改、删除；有效节点个数、倒数第k个元素、单链表反转、合并2个有序单链表。双向链表-定义、增删改查。单向环形链表-Joseph

最新推荐文章于 2022-10-06 18:08:00 发布

Tony-1fan

最新推荐文章于 2022-10-06 18:08:00 发布

阅读量1.4k

点赞数 2

分类专栏： java数据结构文章标签：数据结构 java 算法

本文链接：https://blog.csdn.net/qq_39497997/article/details/109687538

版权

java数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1. 单链表介绍

1.1 内存结构

从内存上看：链表的空间不连续（有别于数组）

1.2 逻辑结构

逻辑上来看：链表属于线性结构

1.3 链表特点

链表是以节点的方式来储存的，是链式结构
节点分为数据域（data）和地址域（next）；data域存放数据，next域指向下一个节点
链表分带头结点的链表和没有头结点的链表，根据实际需求确定

2. 链表定义与使用

2.1 链表节点定义

no：英雄编号
name：英雄名字
nickName：英雄昵称
next：指向下一个HeroNode节点

//定义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
	public String toString(){
		return "HeroNode[no="+no+",name="+name+",nickName="+nickName+"]";
	}
}

2.2 链表定义

head：头结点，不存放数据，仅作为当前链表的入口
head的值不能改变，一旦改变，就会丢失整个链表的入口

//定义SingleLinkedList管理我们的英雄
class SingleLinkedList{
	//初始化头结点，不存放具体数据，且不能动
	private HeroNode head = new HeroNode(0,"","");
	
	//返回头结点
	public HeroNode getHead(){
		return head;
	}
}

2.3 链表遍历

2.3.1 思路分析

定义辅助变量temp，相当于一个指针，指向head.next
遍历结束条件：temp == null；表示当前节点为null，到了链表结尾
遍历方法：temp = temp.next, 每次输出节点信息之后，temp后移

2.3.2 代码实现

	//遍历链表
	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;
		}
	}

2.4 尾部插入

2.4.1 思路分析

定义辅助变量temp，指向head
尾插方法：
1.首先遍历找到链表的最后一个节点，即temp.next == null
2.然后在temp节点后插入节点，即temp.next = heroNode

2.4.2 代码实现

在链表尾部插入节点

	// 添加节点到单向链表
	// 思路，当不考虑编号顺序时
	// 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;
	}

测试代码

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();
	}
}

在这里插入图片描述

2.5 按顺序插入

2.5.1 思路分析

定义辅助变量temp，指向head
遍历链表，找到编号大于待加heroNode.no的节点，把heroNode加入到这个节点之前。（temp.next.no>heroNode.no）

2.5.2 代码实现

	// 添加节点到单向链表
	// 思路，当不考虑编号顺序时
	// 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;
	}

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.addByOrder(hero3);
		singleLinkedList.addByOrder(hero2);
		singleLinkedList.addByOrder(hero4);
		singleLinkedList.addByOrder(hero1);
		
		//显示链表
		singleLinkedList.list();
	}
}

在这里插入图片描述

2.6 修改节点信息

2.6.1 思路分析

定义辅助变量temp，指向head.next
找指定节点方法：temp.no = newHeroNode.no

2.6.2 代码实现

// 修改节点的信息, 根据no编号来修改，即no编号不能改.
// 说明
// 1. 根据 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);
    }
}

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.addByOrder(hero3);
		singleLinkedList.addByOrder(hero2);
		singleLinkedList.addByOrder(hero4);
		singleLinkedList.addByOrder(hero1);
		
		//显示链表
		singleLinkedList.list();
		
		//测试修改节点
		HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
		singleLinkedList.update(newHeroNode);
		
		System.out.println("修改之后的链表：");
		singleLinkedList.list();
	}
}

在这里插入图片描述

2.7 删除节点

2.7.1 思路分析

定义辅助变量 temp，指向head.next

2.7.2 代码实现

// 删除节点
// 思路
// 1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
// 2. 说明我们在比较时，是temp.next.no 和 需要删除的节点的no比较
public void del(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);
    }
}

在这里插入图片描述

2.8 总结

对于插入、删除节点来说，需要知道当前待操作的节点（heroNode）前一个节点的地址（指针），如果直接定位至当前待操作的节点 heroNode ，那没得玩。。。因为不知道heroNode 前一个节点的地址，无法进行插入、删除操作，所以 while 循环中的条件使用 temp.next 进行判断
对于更新、遍历操作来说，我需要的仅仅就只是当前节点的信息，所以 while 循环中的条件使用 temp进行判断

3. 单链表面试题

3.1 求单链表中有效节点的个数

3.1.1 思路分析

遍历链表

3.1.2 代码实现

	//求链表中有效数据个数
	public 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;
	}

	//测试有效个数
		int num = singleLinkedList.getLength(singleLinkedList.getHead());
		System.out.println("有效数据有"+num+"个");

在这里插入图片描述

3.2 查找单链表中倒数第k个节点

3.2.1 思路分析

获取链表有效元素的个数size
使用for循环定位至倒数第index个节点，返回即可
for循环条件　　for(int i = 0;i<size - index;i++)

3.2.2 代码实现

	// 查找单链表中的倒数第k个结点 【新浪面试题】
	// 思路
	// 1. 编写一个方法，接收head节点，同时接收一个index
	// 2. index 表示是倒数第index个节点
	// 3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
	// 4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
	// 5. 如果找到了，则返回该节点，否则返回null
	public HeroNode findLastIndexNode(HeroNode head,int index){
		//判空
		if(head.next == null){
			return null;// 没有找到
		}
		
		//调用getLength获取节点个数
		int size = getLength(head);
		//遍历到size-index位置
		//索引有效性校验
		if(index > size || index <= 0){
			return null;
		}
		//定义辅助变量
		HeroNode cur = head.next;
		for(int i = 0; i < size - index; i++){
			cur = cur.next;
		}
		return cur;
	}

		//测试倒数第k个节点
		HeroNode node = singleLinkedList.findLastIndexNode(singleLinkedList.getHead(),2);
		System.out.println("node"+node);

在这里插入图片描述

3.3 单链表的反转

3.3.1思路分析

定义一个新的头节点reverseHead
在原链表中每读取一个节点（cur），先保存其下一个节点（next），然后将cur节点放到新链表的最前面，执行遍历：cur=next,即指针后移
原来链表的head.next = reverseHead.next

将cur放到新链表的最前面操作：
cur.next = reverseHead.next;
reverseHead.next = cur;
while循环中止条件
cur == null;表示已经遍历到了原链表的尾部

3.3.2 代码实现

	//反转链表(方法一)
	public void reversetList(HeroNode head) {
		// 如果当前链表为空，或者只有一个节点，无需反转，直接返回
	    if (head.next == null || head.next.next == null) {
	        return;
	    }
	    
	    //定义一个辅助变量cur
	    HeroNode cur = head.next;
	    HeroNode next = null;// 指向当前节点[cur]的下一个节点
	    HeroNode reverseHead = new HeroNode(0,"","");
	    //遍历原链表,每遍历一个节点，将其取出，放在新链表reverseHead的前边
	    while(cur != null) {
	    	next = cur.next;
	    	cur.next = reverseHead.next;
	    	reverseHead.next = cur;
	    	cur = next;
	    }
	    // 将head.next 指向 reverseHead.next , 实现单链表的反转
	    head.next = reverseHead.next;
	}

	//测试单链表的反转
	singleLinkedList.reversetList(singleLinkedList.getHead());
	System.out.println("反转之后的链表：");
	singleLinkedList.list();

结果截图

3.4 反转打印单链表

3.4.1 思路分析

方式一：先将单链表进行反转操作，然后再遍历输出，问题：破坏原链表结构，不可取
方式二：遍历链表，去除节点压入栈中，利用栈先进后出的特点，实现逆序打印

3.4.2 代码实现

	//从尾到头打印单链表-方式一 先反转，再打印。缺点会破坏链表结构
	//故采用方式二 利用栈的特性（FILO）
	public 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 = cur.next;
		}
		//将栈中的节点进行打印
		while(stack.size()>0) {
			//出栈打印
			System.out.println(stack.pop());
		}
	}

	//测试链表反转打印（栈）
	System.out.println("反转打印结果：");
	singleLinkedList.reversePrint(singleLinkedList.getHead());

在这里插入图片描述

4 双向链表

4.1 与单向链表的比较

单向链表，查找的方向只能是一个方向，而双向链表可以向前或向后查找
单向链表不能自我删除，需要利用辅助变量，而双向链表可以自我删除

4.2 双向链表节点的定义

在单向链表节点的基础上，增加 pre ，用于指向前一个节点

public class HeroNode {
	public int no;
	public String name;
	public String nickname;
	public HeroNode next; // 指向下一个节点, 默认为null
	public HeroNode pre; // 指向前一个节点, 默认为null
	
	// 构造器
	public HeroNode(int no, String name, String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}

	// 为了显示方法，我们重写toString
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}

}

4.3 链表定义

定义整个链表的头结点，作为链表的入口

public class DoubleLinkedList {
	// 先初始化一个头结点，头结点不能动，不存放具体数据
	private HeroNode head = new HeroNode(0, "", "");

	// 返回头结点
	public HeroNode getHead() {
		return head;
	}
}

4.4 遍历链表

4.4.1 思路分析

定义辅助变量 temp ，HeroNode temp = head.next;
何时停止 while 循环？temp == null ：已经遍历至链表尾部

4.4.2 代码实现

// 遍历双向链表
	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;
		}
	}

4.5 尾插

4.5.1 思路分析

定义辅助变量： HeroNode temp = head;
找到链表最后一个节点
temp.next 指向新的尾节点 heroNode ：temp.next = heroNode;
heroNode .pre 指向旧的尾节点 temp ：heroNode.pre = temp;

4.5.2 代码实现

	// 尾插
	public void add(HeroNode heroNode) {
		// 因为头结点不能动，创建一个辅助变量
		HeroNode temp = head;
		// 遍历链表，找到最后
		while (true) {
			if (temp.next == null) {
				break;
			}
			// 没有找到就后移
			temp = temp.next;
		}
		// 插入新节点,形成双向链表
		temp.next = heroNode;
		heroNode.pre = temp;
	}

4.6 按顺序插入

4.6.1 思路分析

定义辅助变量temp:HeroNode temp = head;
新节点插入到temp之后。判断条件：temp.next.no > heroNode.no ，即 temp 的下一个节点的值比 heroNode 节点的值大，所以需要将 heroNode 插入到 temp 节点之后
while中止条件。

temp.next == null ：temp 节点已经是链表的尾节点
temp.next.no > heroNode.no ：heroNode 节点的值介于 temp 节点的值和 temp 下一个节点的值之间
temp.next.no == heroNode.no ：heroNode 节点的值等于 temp 下一个节点的值，不能进行插入

插入方法：

	//heroNode节点指向temp节点
	heroNode.next = temp.next;
	temp.next.pre = heroNode;
	
	// temp 节点指向 heroNode 节点
	temp.next = heroNode;
	heroNode.pre = temp;

但存在一个问题：如果temp是最后一个节点，即temp.next=null，那么temp.next.pre = heroNode;就执行不了。

		heroNode.next = temp.next;
		if (temp.next != null) {
			temp.next.pre = heroNode;
		}

		// temp 节点指向 heroNode 节点
		temp.next = heroNode;
		heroNode.pre = temp;

4.6.2 代码实现

	// 按顺序插入
	public void addByOrder(HeroNode heroNode) {
		// 因为头结点不能动，创建一个辅助变量
		HeroNode temp = head;
		// 标志位，记录是否找到代插入位置
		boolean flag = false;
		// 遍历链表，找到最后
		while (true) {
			if (temp.next == null) {// 说明temp已经在链表的最后
				break;
			} else if (temp.next.no > heroNode.no) {// 位置找到，就在temp的后面插入
				break;
			} else if (temp.next.no == heroNode.no) {
				flag = true;
				break;
			}
			// 没有找到就后移
			temp = temp.next;
		}
		if (flag) {
			System.out.println("待插入的节点已经存在，无法插入");
		} else {
			// 插入新节点,形成双向链表
			// heroNode 指向 temp 节点的下一个节点
			heroNode.next = temp.next;
			if (temp.next != null) {
				temp.next.pre = heroNode;
			}

			// temp 节点指向 heroNode 节点
			temp.next = heroNode;
			heroNode.pre = temp;
		}
	}

4.7 修改节点信息

4.7.1 思路分析

定义辅助节点：HeroNode temp = head.next;
找到待修改的节点
temp.no=no

4.7.2 代码实现

	// 修改一个节点的内容, 可以看到双向链表的节点内容修改和单向链表一样
	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.println("没有找到 编号"+newHeroNode.no+"的节点，不能修改");
		}
	}

在这里插入图片描述

4.8 删除节点

4.8.1 思路分析

定义辅助变量，HeroNode temp = head.next;
定位至待删除的节点 temp ，由于temp 节点有其前一个节点和后一个节点的信息，所以可实现自我删除

temp 的前一个节点的 next 域指向 temp 的后一个节点：temp.pre.next = temp.next;
temp 的后一个节点的 pre 域指向 temp 的前一个节点：temp.next.pre = temp.pre;

有个地方需要注意，如果 temp 已经是链表尾节点，temp 已经没有下一个节点
这时只需要将 temp 的前一个节点的 next 指向 null 即可
所以 temp.next.pre = temp.pre; 执行的前提条件是 temp.next != null

4.8.2 代码实现

	// 从双向链表中删除一个节点,
	// 说明
	// 1 对于双向链表，我们可以直接找到要删除的这个节点
	// 2 找到后，自我删除即可
	public void del(int no) {
		// 判断当前链表是否为空
		if (head.next == null) {// 空链表
			System.out.println("链表为空，无法删除");
			return;
		}

		// 辅助变量，这里和单链表不一样，因为双向链表可以自我删除，所以定位到待删除节点
		HeroNode temp = head.next;
		boolean flag = false; // 标志是否找到待删除节点的
		while (true) {
			if (temp == null) { // 已经到链表的最后
				break;
			}
			if (temp.no == no) {
				// 找到的待删除节点的前一个节点temp
				flag = true;
				break;
			}
			temp = temp.next; // temp后移，遍历
		}
		// 判断flag
		if(flag) {
			//可以删除
			temp.pre.next = temp.next;
			// 如果是最后一个节点，就不需要执行下面这句话，否则出现空指针
			if(temp.next != null) {
				temp.next.pre = temp.pre;
			}
		}else {
			System.out.println("要删除的节点不存在");
		}
	}

在这里插入图片描述

5 单向环形链表

5.1 joseph问题

设编号为 1， 2， … n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
在这里插入图片描述

5.2 思路分析

用一个不带头结点的循环链表来处理 Josephu 问题：

先构成一个有 n 个结点的单循环链表
然后由 k 结点起从 1 开始计数，计到 m 时，对应结点从链表中删除，
然后再从被删除结点的下一个结点又从 1 开始计数，直到最后一个结点从链表中删除算法结束。

5.3 环形链表的构建与遍历

5.3.1 Boy节点的定义

Boy 节点就是个普普通通的单向链表节点

//创建一个Boy类，表示一个节点
public 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;
	}
}

5.3.2 单向循环链表的定义

first 节点为单向循环链表的首节点，是真实存放数据的节点，不是头结点

// 创建一个环形的单向链表
class CircleSingleLinkedList {
	// 创建一个first节点,当前没有编号
	private Boy first = null;
    
    // ...
}

5.3.3 构建单向循环链表

思路分析
定义一个辅助变量curBoy： Boy curBoy = null;

长度为1的情况：

新创建的Boy节点就是首节点：first=boy；
自封闭（自己构成环形链表）：first.setNext(first);
此时的first既是首节点，又是尾结点，辅助指针指向first：curBoy = first；

长度不为1的情况：

将boy节点添加至环形链表的最后：curBoy.setNext(boy)。注意：curBoy节点永远是环形链表的尾结点。
构成环形链表：boy.setNext(first);
辅助指针后移，指向环形链表的尾结点;curBoy = boy;
代码实现

	// 添加小孩节点，构建成一个环形的链表
	public void addBoy(int 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 节点
				first.setNext(first);//构成环
				curBoy = first;
			}else {
				curBoy.setNext(boy);// 将 boy 节点加到链表尾部
				boy.setNext(first); // 构成环
	            curBoy = boy; // curBoy 指针后移
			}
			
		}
	}

5.3.4 遍历单向循环链表

定义辅助变量curBoy，Boy curBoy = first;
while中止条件：当 curBoy 已经指向环形链表的尾节点：curBoy.getNext() == first

	// 遍历当前的环形链表
	public void showBoy() {
	    // 判断链表是否为空
	    if (first == null) {
	        System.out.println("没有任何小孩~~");
	        return;
	    }
	    // 因为first不能动，因此我们仍然使用一个辅助指针完成遍历
	    Boy curBoy = first;
	    while (true) {
			System.out.println("小孩的编号" + curBoy.getNo());
	        if (curBoy.getNext() == first) {// 说明已经遍历完毕
	            break;
	        }
	        curBoy = curBoy.getNext(); // curBoy后移
	    }
	}

5.4 解决Joseph 问题

5.4.1 思路分析

辅助变量 helper ：helper 永都指向环形链表的尾节点，环形链表的尾节点永远都指向首节点，可得出：helper.getNext() == first
如何将 helper 定位至环形链表的尾节点？
　　1. 初始化时，让 helper = first ，此时 helper 指向环形链表的首节点
　　2. while 循环终止条件？helper.getNext() == first ：此时 helper 已经移动至环形链表的尾节点
如何定位至第 startNo 个节点？如果想要定位至第 2 个节点，那么则需要让 first 和 helper 都移动 1 步，所以让 first 和 helper 都移动 (startNo - 1)步即可
如何数 nums 下？让 first 和 helper 都移动 (nums - 1)步即可
如何实现出圈？
　　1. 我们需要将 first 指向的节点出圈，first 前一个节点的地址在 helper 中存着（环形链表）
　　2. 先让 first 后移一步：first = first.getNext;
　　3. 出圈：helper.setNext(first); ，原来的 first 节点由于没有任何引用，便会被垃圾回收机制回收
while 循环终止条件？圈中只剩一人：helper == first

5.4.2 代码实现

	// 根据用户的输入，计算出小孩出圈的顺序
	/**
	 * 
	 * @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 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.println("小孩"+first.getNo()+"出圈");
			// 这时将first指向的小孩节点出圈
			first = first.getNext();
			helper.setNext(first); 

		}
		System.out.println("最后留在圈中的小孩编号"+first.getNo());
	}

5.5 Joseph 问题测试

public class CircleLinkedListDemo {

	public static void main(String[] args) {
		// 测试一把看看构建环形链表，和遍历是否ok
		CircleLinkedList circleLinkedList = new CircleLinkedList();
		circleLinkedList.addBoy(5);// 加入5个小孩节点
		circleLinkedList.showBoy();

	    // 测试一把小孩出圈是否正确
		circleLinkedList.countBoy(1, 2, 3); // 2->4->1->5->3
	}

}

在这里插入图片描述

Tony-1fan

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
链表-单链表内存结构、逻辑结构、特点、定义、遍历、尾插、按顺序插入、修改、删除；有效节点个数、倒数第k个元素、单链表反转、合并2个有序单链表。双向链表-定义、增删改查。单向环形链表-Joseph

1. 单链表介绍1.1 内存结构从内存上看：链表的空间不连续（有别于数组）1.2 逻辑结构逻辑上来看：链表属于线性结构1.3 链表特点链表是以节点的方式来储存的，是链式结构节点分为数据域（data）和地址域（next）；data域存放数据，next域指向下一个节点链表分带头结点的链表和没有头结点的链表，根据实际需求确定2. 链表定义与使用2.1 链表节点定义no：英雄编号name：英雄名字nickName：英雄昵称next：指向下一个HeroNode节点//
复制链接

扫一扫