《恋上数据结构第1季》单向循环链表、双向循环链表以及约瑟夫环问题

最新推荐文章于 2023-04-21 13:39:13 发布
最新推荐文章于 2023-04-21 13:39:13 发布
阅读量1.6k 收藏 2
点赞数 1
分类专栏： # 《恋上数据结构》 文章标签： java 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43734095/article/details/104652079
版权

循环链表（CircleList）

数据结构与算法笔记目录：《恋上数据结构》 笔记目录

想加深 Java 基础推荐看这个： Java 强化笔记目录

链表的接口设计

在这里插入图片描述
由于链表的大部分接口和动态数组一致，我们抽取出一个共同的 List 接口；

package com.mj;

public interface List<E> {
	static final int ELEMENT_NOT_FOUND = -1;
	/**
	 * 清除所有元素
	 */
	void clear();

	/**
	 * 元素的数量
	 * @return
	 */
	int size();

	/**
	 * 是否为空
	 * @return
	 */
	boolean isEmpty();

	/**
	 * 是否包含某个元素
	 * @param element
	 * @return
	 */
	boolean contains(E element);

	/**
	 * 添加元素到尾部
	 * @param element
	 */
	void add(E element);

	/**
	 * 获取index位置的元素
	 * @param index
	 * @return
	 */
	E get(int index);

	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	E set(int index, E element);

	/**
	 * 在index位置插入一个元素
	 * @param index
	 * @param element
	 */
	void add(int index, E element);

	/**
	 * 删除index位置的元素
	 * @param index
	 * @return
	 */
	E remove(int index);

	/**
	 * 查看元素的索引
	 * @param element
	 * @return
	 */
	int indexOf(E element);
}

再将一些通用的字段与方法放到一个抽象类中，无论是动态数组还是链表都只需要继承这个抽象类即可。

package com.mj;

public abstract class AbstractList<E> implements List<E>{
	
	protected int size;
	
	// 下标越界抛出的异常
	protected void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
	}
	// 检查下标越界(不可访问或删除size位置)
	protected void rangeCheck(int index){
		if(index < 0 || index >= size){
			outOfBounds(index);
		}
	}
	// 检查add()的下标越界(可以在size位置添加元素)
	protected void rangeCheckForAdd(int index) {
		if (index < 0 || index > size) {
			outOfBounds(index);
		}
	}
	
	@Override
	public boolean contains(E element) {
		return indexOf(element)!=ELEMENT_NOT_FOUND;
	}
	
	@Override
	public int size() {
		return size;
	}

	@Override
	public boolean isEmpty() {
		return size == 0;
	}
	
	@Override
	public void add(E element) {
		add(size, element);
	}

}

单向循环链表

在这里插入图片描述
单向循环链表 - 只有1个节点的情况：
在这里插入图片描述

单向循环链表完整源码

package com.mj.circle;

import com.mj.AbstractList;

/**
 * 单向循环链表
 * 
 * @author yusael
 */
public class SingleCircleLinkedList<E> extends AbstractList<E> {

	private Node<E> first;

	private static class Node<E> {
		E element;
		Node<E> next;

		public Node(E element, Node<E> next) {
			this.element = element;
			this.next = next;
		}

		@Override
		public String toString() {
			StringBuilder sb = new StringBuilder();
			sb.append(element).append("_").append(next.element);
			return sb.toString();
		}
	}

	@Override
	public void clear() {
		size = 0;
		first = null;
	}

	@Override
	public E get(int index) {
		return node(index).element;
	}

	@Override
	public E set(int index, E element) {
		Node<E> node = node(index);
		E old = node.element;
		node.element = element;
		return old;
	}

	@Override
	public void add(int index, E element) {
		rangeCheckForAdd(index);

		if (index == 0) {
			Node<E> newFirst = new Node<>(element, first);
			// 拿到最后一个节点, 上面先不要直接改first, 否则下面找节点会出现问题
			Node<E> last = (size == 0) ? newFirst : node(size - 1);
			last.next = newFirst;
			first = newFirst;
		} else {
			Node<E> prev = node(index - 1);
			prev.next = new Node<>(element, prev.next);
		}
		size++;
	}

	@Override
	public E remove(int index) {
		rangeCheck(index);

		Node<E> node = first;
		if (index == 0) {
			if (size == 1) {
				first = null;
			} else {
				Node<E> last = node(size - 1);
				first = first.next;
				last.next = first;
			}
		} else {
			Node<E> prev = node(index - 1);
			node = prev.next;
			prev.next = node.next;
		}
		size--;
		return node.element;
	}

	@Override
	public int indexOf(E element) {
		if (element == null) {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element == element) return i;
				node = node.next;
			}
		} else {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element.equals(element)) return i;
				node = node.next;
			}
		}
		return ELEMENT_NOT_FOUND;
	}

	/**
	 * 根据索引找到节点
	 */
	private Node<E> node(int index) {
		rangeCheck(index);
		Node<E> node = first;
		for (int i = 0; i < index; i++) {
			node = node.next;
		}
		return node;
	}

	@Override
	public String toString() {
		StringBuilder string = new StringBuilder();
		string.append("[size=").append(size).append(", ");
		Node<E> node = first;
		for (int i = 0; i < size; i++) {
			if (i != 0) {
				string.append(", ");
			}
			string.append(node.element);
			node = node.next;
		}
		string.append("]");
		return string.toString();
	}

}

双向循环链表

在这里插入图片描述
双向循环链表 - 只有1个节点的情况：
在这里插入图片描述

双向循环链表完整源码

package com.mj.circle;

import com.mj.AbstractList;

/**
 * 双向循环链表
 * @author yusael
 */
public class CircleLinkedList<E> extends AbstractList<E> {

	private Node<E> first;
	private Node<E> last;
	private Node<E> current; // 指针访问当前节点

	private static class Node<E> {
		E element;
		Node<E> prev;
		Node<E> next;

		public Node(Node<E> prev, E element, Node<E> next) {
			this.prev = prev;
			this.element = element;
			this.next = next;
		}

		@Override
		public String toString() {
			StringBuilder sb = new StringBuilder();
			if (prev != null) {
				sb.append(prev.element);
			} else {
				sb.append("null");
			}
			sb.append("_").append(element).append("_");
			if (next != null) {
				sb.append(next.element);
			} else {
				sb.append("null");
			}

			return sb.toString();
		}
	}

	public void reset() {
		current = first;
	}

	public E next() {
		if (current == null) return null;
		current = current.next;
		return current.element;
	}

	/**
	 * 删除 current 节点
	 */
	public E remove() {
		if (current == null) return null;
		Node<E> next = current.next;
		E element = remove(current);
		if(size == 0){
			current = null;
		}else{
			current = next;
		}
		return element;
	}

	@Override
	public void clear() {
		size = 0;
		first = null;
		last = null;
	}

	@Override
	public E get(int index) {
		return node(index).element;
	}

	@Override
	public E set(int index, E element) {
		E old = node(index).element;
		node(index).element = element;
		return old;
	}

	@Override
	public void add(int index, E element) {
		rangeCheckForAdd(index);

		if (index == size) { // 往最后面添加元素
			Node<E> oldLast = last;
			last = new Node<>(oldLast, element, first);
			if (oldLast == null) { // 这是链表添加的第一个元素
				first = last;
				first.next = first;
				first.prev = first;
			} else {
				oldLast.next = last;
				first.prev = last;
			}
		} else { // 正常添加元素
			Node<E> next = node(index);
			Node<E> prev = next.prev;
			Node<E> node = new Node<>(prev, element, next);
			next.prev = node;
			prev.next = node;
			if (next == first) { // index==0
				first = node;
			}
		}
		size++;
	}

	@Override
	public E remove(int index) {
		rangeCheck(index);
		return remove(node(index));
	}

	public E remove(Node<E> node) {
		if (size == 1) {
			first = null;
			last = null;
		} else {
			Node<E> prev = node.prev;
			Node<E> next = node.next;
			prev.next = next;
			next.prev = prev;

			if (node == first) { // index == 0
				first = next;
			}

			if (node == last) { // index == size - 1
				last = prev;
			}
		}
		size--;
		return node.element;
	}

	@Override
	public int indexOf(E element) {
		if (element == null) {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element == element)
					return i;
				node = node.next;
			}
		} else {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element.equals(element))
					return i;
				node = node.next;
			}
		}
		return ELEMENT_NOT_FOUND;
	}

	/**
	 * 根据索引找到节点
	 */
	private Node<E> node(int index) {
		rangeCheck(index);

		if (index < (size >> 1)) { // 索引小于一半从前往后找
			Node<E> node = first;
			for (int i = 0; i < index; i++) {
				node = node.next;
			}
			return node;
		} else { // 索引大于一半从后往前找
			Node<E> node = last;
			for (int i = size - 1; i > index; i--) {
				node = node.prev;
			}
			return node;
		}
	}

	@Override
	public String toString() {
		StringBuilder string = new StringBuilder();
		string.append("[size=").append(size).append(", ");
		Node<E> node = first;
		for (int i = 0; i < size; i++) {
			if (i != 0) {
				string.append(", ");
			}
			string.append(node);
			node = node.next;
		}
		string.append("]");
		return string.toString();
	}

}

双向循环链表解决约瑟夫环问题

在这里插入图片描述

public class Main {
	public static void josephus(){
		CircleLinkedList<Integer> list = new CircleLinkedList<>();
		for(int i = 1; i <= 8; i++){
			list.add(i);
		}
		list.reset(); // current->1
		while(!list.isEmpty()){
			list.next();
			list.next();
			System.out.println(list.remove());
		}
	}
	
	public static void main(String[] args) {
		josephus();
	}
}

如何发挥循环链表的最大威力？

可以考虑增设1个成员变量、3个方法：

  • current ：用于指向某个节点
  • void reset() ：让 current 指向头结点 first
  • E next()：让 current 往后走一步，也就是 current = current.next
  • E remove() ：删除 current 指向的节点，删除成功后让 current 指向下一个节点
    在这里插入图片描述

静态链表

前面所学习的链表，是依赖于指针（引用）实现的，有些编程语言是没有指针的，比如早期的 BASIC、FORTRAN 语言，没有指针的情况下，如何实现链表？

  • 可以通过数组来模拟链表，称为静态链表
  • 数组的每个元素存放 2 个数据：值、下个元素的索引
  • 数组 0 位置存放的是头结点信息
    在这里插入图片描述

思考：如果数组的每个元素只能存放 1 个数据呢？

  • 那就使用 2 个数组，1 个数组存放索引关系，1 个数组存放值
萌宅鹿同学
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
PHP实现的基于单向链表解决约瑟夫环问题示例
12-20
本文实例讲述了PHP实现的基于单向链表解决约瑟夫环问题。分享给大家供大家参考，具体如下： 约瑟夫环问题：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活
数据结构 用双向链表实现约瑟夫环
11-07
数据结构大作业，c++用双向链表实现约瑟夫环，内含.h与.cpp
用单向循环链表模拟约瑟夫环
04-16
用C语言编写的约瑟夫环问题解决程序，利用单向循环链表存储结构模拟此过程
单向循环链表实现约瑟夫环.zip
12-05
单向循环链表实现约瑟夫环.zip
单向循环链表解决约瑟夫问题
05-12
用单向循环链表解决约瑟夫问题。使用c++语言，结构体，链表的操作。
约瑟夫问题（利用双向循环链表）
布朗慢运动的博客
08-04 619
约瑟夫问题问题：解决问题的思路源代码List接口抽象类AbstractList双向循环链表测试代码总结 问题： M个人围成一圈，从第一个开始报数，第N个将被杀掉，最后剩下一个，其余人都将被杀掉。例如M=6，N=5，被杀掉的顺序是：5，4，6，2，3。 解决问题的思路 利用环形链表的闭合性，移动链表指针并删除元素，直至最后一个元素。 源代码 List接口 package com.zarek; public interface List<E> { static final int ELEMEN
数据结构学习3-单向链表、双向链表以及使用链表解决约瑟夫环
sssdal19995的博客
02-13 231
链表学习笔记 链表是一种使用十分频繁的数据结构，它的优点在于可以将大量的数据存储在分散的空间内，当需要插入或修改节点的时候，只需要修改节点之间的指针即可。 与之相反，数组的存储则需要连续的空间，当需要向数组中插入数据或者修改顺序的时候，需要对整个空间进行处理。 所以：我们常说 如果查找的比较频繁就使用数组，如果修改比较频繁那么建议使用链表 链表是以节点的方式来进行数据存储的，它分为带头节点的链表和不带头节点的链表 单向链表 每一个节点中都分为data域和next域 ，data域存放数据 ，next域指向
Java使用单向循环链表解决Josephu(约瑟夫、约瑟夫环)问题
mfx7700429的博客
09-25 724
一、Josephu(约瑟夫、约瑟夫环)问题的介绍： 1.Josephu(约瑟夫、约瑟夫环)问题为：设编号为1，2，3，…n-1，n的n个人围坐一圈，约定编号为k的人从1开始报数，数到m的那个人出列，他的下一位又从1开始报数，数到m的那个人又出列，以此类推，知道所有的人都出列为止，由此产生一个出列编号 2.问题解决思路：用一个不带头结点的单向循环链表来处理JosePhu问题：先构成用一个单向循环链表，然后由K节点起从1开始计数，计数到m时，将对应的节点从链表中删除，然后再从被删除的节点的下一个节点起从1开始计
数据结构：单、双链表解决约瑟夫问题
weixin_61448242的博客
04-21 173
直接上图展示，初始化状态：假设n=6，总共有6个人，k=1,从第一个人开始报数，m=5,每次数五个。第二次报数：从被杀死的五号的下一位开始报数，也就是六号，数五个数，6-1-2-3-4，数数完毕，四号被杀死，第二次报数后，剩余人数如下。第三次报数：从被杀死的四号的下一位开始报数，同样是六号，数五个数，6-1-2-3-6，数数完毕，六号被杀死，第三次报数后，剩余人数如下。第四次报数：从被杀死的六号的下一位开始报数，也就是一号，数五个数，1-2-3-1-2，数数完毕，二号被杀死，第四次报数后，剩余人数如下。
Java使用双向循环队列实现约瑟夫环
weixin_46626325的博客
11-15 402
Java使用双向循环队列实现约瑟夫环
【Java数据结构与算法】环形链表及约瑟夫问题
12-21
单向环形链表应用场景 单向环形链表介绍 Josephu（约瑟夫，约瑟夫环）问题 Josephu问题为： 设编号为1，2，…n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m的那个人出列，他的下一位又从1开始报数，数到m的那个人又出列，以此类推，直到所有人出列位置，由此产生一个出队编号的序列。 思路分析： 用一个不带头结点的循环链表来处理Josephu问题，先构成一个有n个节点的单循环链表，然后由k节点起从1开始计数，计到m时，对应节点从链表中删除，然后再从被删除节点的下一个节点又从1开始计数，直到最后一个节点从链表中删除算法结束。 代码思路： 先创建第一个节点，让f
用单向循环链表解决约瑟夫问题的算法优劣性分析.doc
05-30
用单向循环链表解决约瑟夫问题的算法优劣性分析.doc
双向循环链表解决约瑟夫环问题
10-01
用双向循环链表解决约瑟夫环问题的程序清单
双向链表实现约瑟夫环
06-11
已知N个人（以编号1,2,3...n分别表示）围成一个圈。 从编号为K的人开始报数，数到M的那个人出列，他的下一个人又从1开始报数，依照此规律重复下去，直到圆圈中的人全部出列。 问题：请打印出这N个的人出列的编号。 双向链表实现的
恋上数据结构完整笔记（第1季 + 第2季）
热门推荐
萌宅鹿的技术小屋
03-13 2万+
Java 数据结构目录 整理一下。。。 【动态扩容数组】动态扩容数组 ArrayList实现源码（Java、C++） 【链表List】单向链表 SingleLinkedList、双向链表 LinkedList 实现源码 【循环链表CircleList】单向循环链表、双向循环链表以及约瑟夫环问题 【队列Queue】队列 Queue、双端队列 DeQueue、循环队列 CircleQueue、双端循环...
《恋上数据结构第1季》动态扩容数组原理及实现
萌宅鹿的技术小屋
03-01 5467
动态扩容数组接口设计Java实现int型动态数组Java实现泛型动态数组Java实现泛型动态数组优化C++实现动态数组 接口设计 int size(); // 元素的数量 boolean isEmpty(); // 是否为空 boolean contains (E element); // 是否包含某个元素 void add (E element); // 添加元素到最后面 E get (int...
《恋上数据结构第1季》单向链表、双向链表
萌宅鹿的技术小屋
03-02 3740
单向链表java实现泛型单向链表List.java 接口AbstractList.javaLinkedList.java java实现泛型单向链表 List.java 接口 public interface List<E> { static final int ELEMENT_NOT_FOUND = -1; /** * 清除所有元素 */ void clear(); ...
【恋上数据结构】排序算法前置知识及代码环境准备
萌宅鹿的技术小屋
03-26 3719
排序准备工作何为排序？何为稳定性？何为原地算法？时间复杂度的知识写排序算法前的准备项目结构Sort.javaAsserts.javaIntegers.javaTimes.javaStudent.java排序算法测试BubbleSort1.javaMain.java 感谢小码哥的恋上数据结构，记录课程笔记。 建议先看一下这篇博客： 复杂度知识以及LeetCode刷题指南。 何为排序？ 排序前：3...
【恋上数据结构】复杂度知识以及LeetCode刷题指南
萌宅鹿的技术小屋
03-26 3677
基础知识什么是算法？如何评判一个算法的好坏？大O表示法（Big O）对数阶的细节常见的复杂度多个数据规模的情况LeetCode刷题指南斐波那契数列复杂度分析斐波那契数列-递归斐波那契数列-循环fib函数的时间复杂度分析斐波那契的线性代数解法-特征方程算法的优化方向 什么是算法？ 算法是用于解决特定问题的一系列的执行步骤。 以下算法是为了解决两数相加的问题。 // 计算a和b的和 public st...
约瑟夫问题C++单向循环链表分文件数据结构
最新发布
06-07
好的，我可以帮你解答这个问题。 首先，让我们来了解一下约瑟夫问题的背景。约瑟夫问题是一个经典的问题，据传是由古代历史学家约瑟夫斯(Josephus)提出的。问题的具体描述如下： 有n个人围成一圈，从第一个人开始报数，报到m的人出圈，剩下的人继续从1开始报数，直到剩下最后一个人。求出最后一个出圈的人的编号。 为了解决这个问题，我们可以使用单向循环链表来实现。下面是一个简单的C++单向循环链表的实现，包含了三个文件：Node.h、List.h和List.cpp。 首先是Node.h文件，用来定义节点类： ```cpp // Node.h #ifndef NODE_H #define NODE_H class Node { public: int data; Node* next; Node(int data) { this->data = data; next = nullptr; } }; #endif ``` 然后是List.h文件，用来定义链表类： ```cpp // List.h #ifndef LIST_H #define LIST_H #include "Node.h" class List { public: List(); ~List(); void insert(int data); void remove(Node* node); Node* getHead(); Node* getNext(Node* node); private: Node* head; }; #endif ``` 最后是List.cpp文件，用来实现链表类的方法： ```cpp // List.cpp #include "List.h" List::List() { head = nullptr; } List::~List() { Node* curr = head; while (curr != nullptr) { Node* temp = curr; curr = curr->next; delete temp; } } void List::insert(int data) { Node* node = new Node(data); if (head == nullptr) { head = node; head->next = head; } else { Node* curr = head; while (curr->next != head) { curr = curr->next; } curr->next = node; node->next = head; } } void List::remove(Node* node) { Node* curr = head; if (node == head) { head = head->next; } else { while (curr->next != node) { curr = curr->next; } curr->next = node->next; } delete node; } Node* List::getHead() { return head; } Node* List::getNext(Node* node) { return node->next; } ``` 现在我们就可以使用这个单向循环链表来解决约瑟夫问题了。下面是一个简单的解决方案： ```cpp #include <iostream> #include "List.h" int josephus(int n, int m) { List list; for (int i = 1; i <= n; i++) { list.insert(i); } Node* curr = list.getHead(); while (n > 1) { for (int i = 1; i < m; i++) { curr = list.getNext(curr); } Node* temp = curr; curr = list.getNext(curr); list.remove(temp); n--; } return list.getHead()->data; } int main() { int n = 5; int m = 3; int result = josephus(n, m); std::cout << "The last person is " << result << std::endl; return 0; } ``` 这个程序将输出： ``` The last person is 4 ``` 这就是使用C++单向循环链表解决约瑟夫问题的一个简单的例子。希望能对你有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

萌宅鹿同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值