双链表__Josephu(约瑟夫、约瑟夫环) 问题
双向链表，又称为双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
单链表跟双链表的区别：
-
单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
-
单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节
点，总是找到temp,temp是待删除节点的前一个节点
1、双链表实现
public class DoubleLinkedList {
public static void main(String[] args) {
DoubleLinkedListD list = new DoubleLinkedListD();
HeroNode2 heroNode3 =new HeroNode2(4,"林冲","豹子头");
HeroNode2 heroNode = new HeroNode2(1, "宋江", "及时雨");
HeroNode2 heroNode1 = new HeroNode2(2, "卢俊义", "玉麒麟");
HeroNode2 heroNode2 =new HeroNode2(3,"吴用","智多星");
list.add(heroNode3);
list.add(heroNode);
list.add(heroNode1);
list.add(heroNode2);
list.List();
HeroNode2 heroNode4 = new HeroNode2(1, "xiaobear", "及时雨");
list.update(heroNode4);
list.delete(4);
list.List();
}
}
class DoubleLinkedListD{
private int length;
private HeroNode2 head = new HeroNode2(0,"","");
public HeroNode2 getHead(){
return head;
}
/**
* 显示链表
* 先判断为空,遍历后temp后移，否则就是死循环
*/
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.next;
}
}
/**
* 添加节点到末尾
* 不考虑编号的顺序时，找到当前链表的最后节点，将指向最后节点的next指向新的节点
* @param heroNode2
*/
public void add(HeroNode2 heroNode2){
HeroNode2 temp = head;
/**遍历temp
* 为空，结束，不为空，指向next
*/
while (true){
if (temp.next == null) {
break;
}
temp = temp.next;
}
temp.next = heroNode2;
heroNode2.pre = temp;
length++;
}
/**
* 根据newHeroNode的no来修改
* @param newHeroNode
*/
public void update(HeroNode2 newHeroNode){
if (head.next == null){
System.out.println("链表为空");
return;
}
HeroNode2 temp = head.next;
boolean result = false;
while (true) {
if (temp == null){
break;
}
if (temp.no == newHeroNode.no){
result = true;
break;
}
temp = temp.next;
}
if (result) {
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
}else {
System.out.printf("没有找到编号 %d 的节点",newHeroNode.no);
}
}
/**
*删除
* result 标志是否找到
* @param no
*/
public void delete(int no) {
if (head.next == null){
System.out.println("链表为空");
return;
}
HeroNode2 temp = head.next;
boolean result = false;
while (true) {
if (temp == null) {
break;
}
if (temp.no == no){
result = true;
break;
}
temp = temp.next;
}
if (result) {
//temp.next = temp.next.next; 单链表
temp.pre.next = temp.next;
length--;
if (temp.next != null) {
temp.next.pre = temp.pre;
}
}else {
System.out.printf("要删除的节点 %d 不存在",no);
}
}
}
/**
* next 指向后一个节点
* pre 指向前一个节点
*/
class HeroNode2 {
public int no;
public String name;
public String nickname;
public HeroNode2 next;
public HeroNode2 pre;
public HeroNode2(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
@Override
public String toString() {
return "HeroNode2{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
2、单向环形链表
Josephu(约瑟夫、约瑟夫环) 问题
Josephu 问题为：设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。提示：用一个不带头结点的循环链表来处理Josephu 问题：先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。
代码实现
public class Josephu {
public static void main(String[] args) {
CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
circleSingleLinkedList.addBoy(99);
circleSingleLinkedList.showBoy();
circleSingleLinkedList.countBoy(10,20,99);
}
}
class CircleSingleLinkedList{
private Boy first = null;
/**
* 增加小孩节点
* @param nums
*/
public void addBoy(int nums){
if (nums < 1){
System.out.println("nums的值不正确!");
return;
}
Boy current = null;
for (int i = 1; i <= nums ; i++) {
Boy boy = new Boy(i);
if(i ==1){
first = boy;
//构成环
first.setNext(boy);
//指向第一个小孩
current = first;
}else {
current.setNext(boy);
boy.setNext(first);
current = boy;
}
}
}
public void showBoy(){
if (first == null) {
System.out.println("没有小孩");
return;
}
Boy temp = first;
while (true){
System.out.printf( "小孩的编号:%d\n",temp.getNo());
if (temp.getNext() == first){
break;
}
temp = temp.getNext();
}
}
/**
*
* @param startIndex 从第几个小孩开始计数
* @param countNum 次数
* @param nums 总小孩数
*/
public void countBoy(int startIndex,int countNum,int nums){
/**
* 数据校验
*/
if (first == null || startIndex < 0 || startIndex > nums) {
System.out.println("输入参数错误，请重新输入");
return;
}
Boy temp = first;
while (true) {
if (temp.getNext() == first){
break;
}else {
temp = temp.getNext();
}
}
for (int s = 0 ; s <startIndex - 1 ; s++) {
first = first.getNext();
temp = temp.getNext();
}
while (true) {
if (temp == first){
break;
}
for (int i = 0; i <countNum-1 ; i++) {
first = first.getNext();
temp = temp.getNext();
}
System.out.printf("小孩出圈:%d\n",first.getNo());
first = first.getNext();
temp.setNext(first);
}
System.out.printf("最后留在全中的孩子编号：%d\n",first.getNo());
}
}
class Boy{
private int no;
private Boy next;
public Boy(int no) {
this.no = no;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public void setNext(Boy next) {
this.next = next;
}
public Boy getNext() {
return next;
}
}