个人中心
gpt4 book ai didi

Java数据结构与算法之双向链表、环形链表及约瑟夫问题深入理解

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 33 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java数据结构与算法之双向链表、环形链表及约瑟夫问题深入理解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、双向链表

使用带head头的双向链表实现 - 水浒英雄排行榜管理单向链表的缺点分析:

  1. 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
  2. 单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除节点时，总是找到temp,temp时待删除节点的前一个节点(认真体会)。

Java数据结构与算法之双向链表、环形链表及约瑟夫问题深入理解

分析双向链表的遍历，添加，修改，删除的操作思路 。

1.遍历和单链表一样只是可以向前，也可以向后查找 。

2.添加(默认添加到双向链表的最后) 。

  • 先找到双向链表的最后这个节点
  • temp.next = newHeroNode
  • newHeroNode.pre = temp

3.修改思路和原理与单向链表一样 。

4.删除 。

  • 因为时双向链表，因此，我们可以实现自我删除某个节点
  • 直接找到要删除的这个节点，比如temp
  • temp.pre.next = temp.next
  • temp.next.pre = temp.pre
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
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.del( 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;
     }
     // 修改一个节点的内容，双向链表的节点内容修改和单向链表一样
     // 只是节点类型改成HeroNode2
     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. 对于双向链表，我们可以直接找到要删除的这个节点
     // 2. 找到后，自我删除即可
     public void del( int no) {
         // 判断当前链表是否为空
         if (head.next == null ) { // 空链表
             System.out.println( "链表为空，无法删除" );
             return ;
         }
         HeroNode2 temp = head.next; // 辅助变量(指针),指向第一个节点(与单向链表不同)
         boolean flag = false ; // 标志是否找到待删除节点
         while ( true ) {
             if (temp.next == null ) { // 已经到链表的最后节点的next
                 break ;
             }
             if (temp.next.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.printf( "要删除的 %d 节点不存在\n" , no);
         }
     }
}
//定义HeroNode2,每个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 "HeroNode2 [no=" + no + ", name=" + name + ", nickname=" + nickname + "]" ;
     }
}

2、环形链表及其应用：约瑟夫问题

Java数据结构与算法之双向链表、环形链表及约瑟夫问题深入理解

环形链表图示

Java数据结构与算法之双向链表、环形链表及约瑟夫问题深入理解

构建一个单向的环形链表思路

1.先创建第一个节点，让 first 指向该节点，并形成环形 。

2.后面当我们每创建一个新的节点，就把该节点加入到已有的环形链表中即可.

遍历环形链表

1.先让一个辅助指针(变量)curBoy,指向 first 节点 。

2.然后通过一个 while 循环遍历该环形链表即可 cur.Boy.next == first 结束 。

约瑟夫问题

1.创建一个辅助指针(变量)helper,事先应该指向环形链表的最后这个节点.

2.小孩报数前，先让 first 和 helper 移动 k -1次（移动到报数的小孩） 。

3.当小孩报数时，让 first 和 helper 指针同时的移动 m - 1次 。

4.这时就可以将 first 指向的小孩节点出圈 。

first = first.next 。

helper.next = first 。

原来 first 指向的节点就没有任何引用，就会被回收 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
public class Josepfu {
     public static void main(String[] args) {
         // 测试看看构建环形链表，和遍历是否ok
         CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
         circleSingleLinkedList.addBoy( 5 ); // 加入5个小孩节点
         circleSingleLinkedList.showBoy();
         // 测试小孩出圈是否正确
         circleSingleLinkedList.countBoy( 1 , 2 , 5 ); // 2->4->1->5->3
     }
}
//创建一个环形的单向链表
class CircleSingleLinkedList {
     // 创建一个first节点，当前没有编号
     private Boy first = null ;
 
     // 添加小孩节点，构建一个环形的链表
     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后移
         }
     }
     // 根据用户的输入，计算出小孩出圈的顺序
     /**
      * @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.printf( "小孩%d出圈\n" , first.getNo());
             // 这时将first指向的小孩节点出圈
             first = first.getNext();
             helper.setNext(first);
         }
         System.out.printf( "最后留在圈中的小孩编号%d \n" , first.getNo());
     }
}
//创建一个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;
     }
}

到此这篇关于Java数据结构与算法之双向链表、环形链表及约瑟夫问题深入理解的文章就介绍到这了,更多相关Java数据结构与算法内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://blog.csdn.net/weixin_49329785/article/details/120238278 。

最后此篇关于Java数据结构与算法之双向链表、环形链表及约瑟夫问题深入理解的文章就讲到这里了,如果你想了解更多关于Java数据结构与算法之双向链表、环形链表及约瑟夫问题深入理解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

33 4 0
文章推荐： phpmyadmin在宝塔面板里进不去的解决方案
文章推荐： Python画图工具Matplotlib库常用命令简述
文章推荐： 详解PHP中的8个魔术常量
文章推荐： python实例小练习之Turtle绘制南方的雪花
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com