(三)循环链表以及循环链表应用

最新推荐文章于 2021-10-06 11:47:58 发布
最新推荐文章于 2021-10-06 11:47:58 发布
阅读量3.8k 收藏 10
点赞数 1
分类专栏： 数据结构与算法(JAVA篇) 文章标签： 链表 数据结构 算法 循环链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fangfully/article/details/12293177
版权

单向循环链表

单向循环链表是单链表的另一种形式，其结构特点是链表中最后一个结点的指针不再是结束标记，而是指向整个链表的第一个结点，从而使单链表形成一个环。和单链表相比，循环单链表的长处是从链尾到链头比较方便。当要处理的数据元素序列具有环型结构特点时，适合于采用循环单链表。

与单链表相同，循环单链表也有带头结点结构和不带头结点结构两种，带头结点的循环单链表实现插入和删除操作时，算法实现较为方便。
带头结点的循环单链表结构如下：


带头结点的循环单链表的操作实现方法和带头结点的单链表的操作实现方法类同，差别仅在于：

（1）在构造函数中，要加一条head.next = head 语句，把初始时的带头结点的循环单链表设计成图2-11 （a）所示的状态。

（2）在index(i)成员函数中，把循环结束判断条件current != null改为current != head。(见上篇博客)

public interface List {
	// 获得线性表长度
	public int size();

	// 判断线性表是否为空
	public boolean isEmpty();

	// 插入元素
	public void add(int index, Object obj) throws Exception;

	// 删除元素
	public void delete(int index) throws Exception;

	// 获取指定位置的元素
	public Object get(int index) throws Exception;
}
//节点类
public class Node {
	Object element; // 数据域
	Node next; // 指针域
	//头结点的构造方法
	public Node(Node nextval){
		this.next=nextval;
	}
    //非头结点的构造方法
	public Node(Object obj,Node nextval){
		this.element=obj;
		this.next=nextval;
	}
	public Object getElement() {
		return element;
	}
	public void setElement(Object element) {
		this.element = element;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	public String toString()
	{
	   return this.element.toString();	
	}
}
public class CycleLinkedList implements List {
	Node head; // 头指针
	Node current;// 当前结点对象
	int size;// 结点个数
	public CycleLinkedList(){
		//初始化头结点，让头指针指向头结点。并且让当前结点对象等于头结点。
		this.head = current = new Node(null);
		this.size =0;//单向链表，初始长度为零。
		this.head.next =this.head;
	}
	//定位函数，实现当前操作对象的前一个结点，也就是让当前结点对象定位到要操作结点的前一个结点。
	public void index(int index) throws Exception{
		if(index<-1||index>this.size-1){
			throw new Exception("参数错误！");
		}
		if(index==-1){
			return;
		}
		this.current=this.head.next;
		int j=0;
		while(this.current!=this.head&&j<index){
			this.current=this.current.next;
			j++;
		}
	}
	@Override
	public int size() {
		// TODO Auto-generated method stub
		return this.size;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return this.size == 0;
	}

	@Override
	public void add(int index, Object obj) throws Exception {
		// TODO Auto-generated method stub
		if (index < 0 || index > this.size) {
			throw new Exception("参数错误！");
		}
		this.index(index - 1);
		this.current.setNext(new Node(obj, this.current.next));
		this.size++;
	}

	@Override
	public void delete(int index) throws Exception {
		// TODO Auto-generated method stub
		// 判断链表是否为空
		if (isEmpty()) {
			throw new Exception("链表为空，无法删除！");
		}
		if (index < 0 || index > size) {
			throw new Exception("参数错误！");
		}
		this.index(index-1);
		this.current.setNext(this.current.next.next);
		this.size--;
	}

	@Override
	public Object get(int index) throws Exception {
		// TODO Auto-generated method stub
		if(index <-1 || index >size-1)
		{
			throw new Exception("参数非法！");
		}
		this.index(index);
		
		return this.current.getElement();
	}

}

双向循环链表

双向链表是每个结点除后继指针外还有一个前驱指针。和单链表类同，双向链表也有带头结点结构和不带头结点结构两种，带头结点的双向链表更为常用；另外，双向链表也可以有循环和非循环两种结构，循环结构的双向链表更为常用。
在双向链表中，每个结点包括三个域，分别是element域、next域和prior域，其中element域为数据元素域，next域为指向后继结点的对象引用，prior域为指向前驱结点的对象引用。下图为双向链表结点的图示结构。

如下图是带头结点的循环双向链表的图示结构。循环双向链表的next和prior各自构成自己的循环单链表。

在双向链表中，有如下关系：设对象引用p表示双向链表中的第i个结点，则p.next表示第i+1个结点，p.next.prior仍表示第i个结点，即p.next.prior== p；同样地，p.prior表示第i-1个结点，p.prior.next仍表示第i个结点，即p.prior.next ==p。下图是双向链表上述关系的图示。 

循环双向链表的插入过程如下图所示。图中的指针p表示要插入结点的位置，s表示要插入的结点，①、②、③、④表示实现插入过程的步骤。

循环双向链表的删除过程如下图所示。图中的指针p表示要插入结点的位置，①、②表示实现删除过程的步骤。 

public interface List {
	// 获得线性表长度
	public int size();

	// 判断线性表是否为空
	public boolean isEmpty();

	// 插入元素
	public void add(int index, Object obj) throws Exception;

	// 删除元素
	public void delete(int index) throws Exception;

	// 获取指定位置的元素
	public Object get(int index) throws Exception;
}
public class Node {
	Object element; // 数据域
	Node next; // 后继指针域
	Node prior; // 前驱指针域

	Node(Node nextval){
		this.next=nextval;
	}
	Node(Object obj,Node nextval){
		this.next=nextval;
		this.element=obj;
	}
	// 获得当前结点的后继结点
	public Node getNext() {
		return this.next;
	}

	// 获得当前结点的前驱结点
	public Node getPrior() {
		return this.prior;
	}

	// 获得当前的数据域的值
	public Object getElement() {
		return this.element;
	}

	// 设置当前结点的后继指针域
	public void setNext(Node nextval) {
		this.next = nextval;
	}

	// 设置当前结点的前驱指针域
	public void setPrior(Node priorval) {
		this.prior = priorval;
	}

	// 设置当前结点的数据域
	public void setElement(Object obj) {
		this.element = obj;
	}

	public String toString() {
		return this.element.toString();
	}
}

public class DoubleCycleLinkedList implements List {
	Node head; // 头指针
	Node current;// 当前结点对象
	int size;// 结点个数
	public DoubleCycleLinkedList(){
		//初始化头结点，让头指针指向头结点。并且让当前结点对象等于头结点。
		this.head = current = new Node(null);
		this.size =0;
		this.head.next =this.head;
		this.head.prior=this.head;
	}
	//定位函数，实现当前操作对象的前一个结点，也就是让当前结点对象定位到要操作结点的前一个结点。
	public void index(int index) throws Exception{
		if(index<-1||index>this.size-1){
			throw new Exception("参数错误！");
		}
		if(index==-1){
			return;
		}
		this.current=this.head.next;
		int j=0;
		while(this.current!=this.head&&j<index){
			this.current=this.current.next;
			j++;
		}
	}
	@Override
	public int size() {
		// TODO Auto-generated method stub
		return this.size;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return this.size == 0;
	}

	@Override
	public void add(int index, Object obj) throws Exception {
		// TODO Auto-generated method stub
		if (index < 0 || index > this.size) {
			throw new Exception("参数错误！");
		}
		this.index(index - 1);
		this.current.setNext(new Node(obj, this.current.next));
		this.current.next.setPrior(this.current);
		this.current.next.next.setPrior(this.current.next);
		this.size++;
	}

	@Override
	public void delete(int index) throws Exception {
		// TODO Auto-generated method stub
		// 判断链表是否为空
		if (isEmpty()) {
			throw new Exception("链表为空，无法删除！");
		}
		if (index < 0 || index > size) {
			throw new Exception("参数错误！");
		}
		this.index(index-1);
		this.current.setNext(this.current.next.next);
		this.current.next.setPrior(current);
		this.size--;
	}

	@Override
	public Object get(int index) throws Exception {
		// TODO Auto-generated method stub
		if(index <-1 || index >size-1)
		{
			throw new Exception("参数非法！");
		}
		this.index(index);
		
		return this.current.getElement();
	}
}
循环链表应用
游戏规则：N个人围成一个圈，从第一个人开始传花，当数到M时，该人退出游戏，直到剩下最后一个人。 
//游戏类
public class Game {

	//单向循环链表
	CycleLinkedList list = new CycleLinkedList();
	//总人数
	int num;
	//数到几退出
	int key;
	
	//游戏初始化方法
	public Game(int num,int key)
	{
	   this.num = num;
	   this.key = key;
	}
	
	public void play() throws Exception
	{
	   for(int i=0;i<num;i++)
	   {
		   list.add(i, i);  
	   }
       
	   System.out.println("\n-------游戏开始之前---------\n");
	   for(int i=0;i<list.size();i++)
	   {
		   System.out.print(list.get(i)+" ");
	   }
	   System.out.println("\n-------游戏开始---------\n");
	   int iCount=num; //开始等于总人数num
	   int j=0; //累加器，计算是否能被key整除。
	   
	   Node node = list.head;
	   while(iCount!=1)
	   {
		  if(node.getElement()!=null&& Integer.parseInt(node.getElement().toString())!=-1)
		  {
			j++;  
			if(j%key==0)
			{
				node.setElement(-1);
				iCount--;
				System.out.println();
				for(int i=0;i<list.size();i++)
				{
				   System.out.print(list.get(i)+" ");
				}
			}
		  } 
	      node = node.next;
	   }
	   System.out.println("\n-------游戏结束---------\n");
	   for(int i=0;i<list.size();i++)
	   {
		   System.out.print(list.get(i)+" ");
	   }
	}
	
}

靠谱的混蛋
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言循环链表的简单应用
07-25
### C语言循环链表的简单应用 #### 一、引言 在计算机科学中，链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据元素和指向链表中下一个节点的指针。循环链表是链表的一种特殊形式，其中最后一个...
链表-使用C语言实现循环链表应用之解决约瑟夫问题.zip
最新发布
03-13
本项目专注于使用C语言实现循环链表，并将其应用于解决著名的约瑟夫问题。 约瑟夫问题（Josephus Problem）源于一个古老的故事，它涉及到在圆形排列的人群中，按照一定的间隔（通常为3或4）剔除一个人，直到剩下...
数据结构之循环链表的应用
红莲灭的博客
08-24 416
文章目录循环链表构建循环链表约瑟夫问题解题思路代码实现 循环链表 链表整体要形成一个圆环状，在单向链表中，最后一个节点的指针为null，不指向任何结点，因为没有下一个元素了，要实现循环链表，即最后一个结点指向头结点。 构建循环链表 public class ForLinkList { public static void main(String[] args) { Node<Integer> first = new comparable.link.No
循环链表的使用
dml1048147924的博客
07-28 294
可以把链表的两头连接，使其成为了一个环状链表，通常称为循环链表。 循环链表解决约瑟夫环问题， 约瑟夫环问题，是一个经典的循环链表问题，题意是：已知 n 个人（分别用编号 1，2，3，…，n 表示）围坐在一张圆桌周围，从编号为 k 的人开始顺时针报数，数到 m 的那个人出列；他的下一个人又从 1 开始，还是顺时针开始报数，数到 m 的那个人又出列；依次重复下去，直到圆桌上剩余一个人。 #include <stdio.h> #include <stdlib.h> #include<
循环链表及其应用
厚积薄发的博客
08-09 1268
1.什么是循环链表？循环链表与单链表的区别? 循环链表是首尾相接的链表，普通链表是尾指针为空。 2.循环链表的应用有哪些？ 约瑟夫环，报数游戏，现在k个人，1,2,3...n报数 比如每次报2的出圈，然后重新报数。 解决方案: 方案1 标记+报数 数组模拟 方案2 基础结构使用循环链表 代码如下 public static void main(String[] args) { ...
数据结构：循环链表的使用
Rain的博客
05-10 4911
循环链表 循环链表：将单链表中终端结点的指针端由空指针改为指向头结点，就使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表，简称循环链表。如图所示: 非空的循环链表如图： 循环链表与单链表的主要差异在于循环的判断上，原来是判断p->next是否为空，现在则是p->next不等于头结点，则循环未结束。 单循环链表的定义与实现： (1)头文件： 代码实现： #pragma o...
循环链表
止步听风的博客
10-19 375
在某些情况下可能会用到循环链表，其中的节点组成一个环：链表的长度是有限的，每个节点都有后继节点。 在循环单向链表的实现中，即使对链表的操作需要访问尾部节点及其头部节点，也可以只固定一个固定指针 tail。 用 C++ 进行对单指针的循环链表进行构建为： // linked_lists.h #ifndef LINKED_LIST_H #define LINKED_LIST_H using ...
05.循环链表仿真链表以及循环链表应用
03-02
05.循环链表仿真链表以及循环链表应用
单向循环链表
01-20
循环链表 循环链表是一种特殊的单链表。实际上，循环链表也很简单。它跟单链表唯一的区别就在尾结点。我们知道，单链表的尾结点指针指向空地址，表示这就是最后的结点了。而循环链表的尾结点指针是指向链表的头结点...
三元组、循环链表以及二叉查找树.zip_三元_三元组_二叉查找树_循环链表
09-21
本压缩包中的内容涉及了三个核心的数据结构概念：三元组、循环链表和二叉查找树，它们在编程和算法设计中都有着重要的应用。 首先，我们来看三元组（Triple）。三元组是一种用于表示三个元素的集合，常用于数据库...
循环链表(1) - 介绍以及应用
水草的专栏
06-15 3925
循环链表(1) - 介绍以及应用
循环单链表的应用
qq_58299006的博客
10-06 450
题目内容 已知由一个线性链表表示的线性表中含有三类字符的数据元素（如字母字符、数字字符、其他字符），试编写算法将该线性链表分割为三个循环链表，其中每个循环链表表示的线性表中均只含一类字符。 算法分析 首先建立三个只有头结点的单循环链表，分别是其他字符单链表A、数字单链表B、字母单链表C。然后从已知单链表中读取结点，如果结点的值域为其他字符，则将其插入到字符单循环链表中；如果结点的值域是字母，则插入到字母单循环链表；如果结点的值域为数字，则插入到数字单循环链表。最后一定要记得设置每个链表的最后一个结点的..
单向循环链表简单应用
_
09-21 585
如题，给出n，s，m三个整数。n个人围成一圈，从第s个人开始从1数数，数到第m的人退出圈子，然后从下一个人又开始从1数数，数到第m的人退出。如此循环下去，输出这n个人退出的顺序。 解决的一种方法就是应用单项循环链表，进行模拟。代码如下： #include #include #include #include using namespace std; #define pnode st
循环链表的作用
qq_42092076的博客
07-26 4568
作用是循环链表是无须增加存储量，仅对表的链接方式稍作改变，即可使得表处理更加方便灵活。 ①循环链表中没有NULL指针。涉及遍历操作时，其终止条件就不再是像非循环链表那样判别p或p-＞next是否为空，而是判别它们是否等于某一指定指针，如头指针或尾指针等。 ②在单链表中，从一已知结点出发，只能访问到该结点及其后续结点，无法找到该结点之前的其它结点。而在单循环链表中，从任一结点出发都可访问到表中所...
循环链表的应用
weixin_43471422的博客
09-22 777
所谓的循环链表就是在单链表的基础上，将尾结点的指针指向第一个结点，实现链表的可循环处理。 约瑟夫环就是循环链表的一个实践，内容：假设有N个人站成一圈，每个人手里都有一个随机密码，开始有一个初始密码M，第一个人按顺时针从1开始报数，直到M值，该人即出列。然后取出该人的密码当做M值，从他的下一位开始报数，一直重复，直到所有人出列完毕。 #include<stdio.h> #inclu...
循环链表应用
szk1234567890的博客
10-05 633
循环双链表应用 strong>span style="font-size:18px;">问题描述：设非空线性表ha和hb都用带头节点的循环双链表表示。设计一个算法Insert(ha,hb,i)。       其功能是：i=0时，将线性表hb插入到线性表ha的最前面；当i>0时，      将线性表hb插入到线性表ha中第i个节点的后面；当i大于等于线性表ha的长度时，   
约瑟夫问题(单向循环链表应用实例)
是我
05-07 1691
据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人
循环链表的简单应用
沧浪之水清兮
11-04 421
#include #include #include typedef int DataType; typedef struct Node { DataType data; struct Node* next; }ListNode, *LinkList; LinkList CreateCycList(int n);//创建循环单链表 void DisplayCycLis
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值