双向链表
使用带head头的双向链表实现-水浒英雄排行榜管理单向链表的缺点分析:
1)单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
2)单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp,temp是待删除节点的前一个节点(认真体会).
3)示意图帮助理解删除
实现思路：
分析双向链表的遍历，添加，修改，删除的操作思路===》代码实现
1)遍历方式和单链表一样，只是可以向前，也可以向后查找
2)添加(默认添加到双向链表的最后)
(1)先找到双向链表的最后这个节点
(2) temp.next=newHeroNode
newHeroNode.pre =temp;
3**)修改思路和原理的单向链表一样.**
4)删除
(1)因为是双向链表，因此，我们可以实现自我删除某个节点
(2)直接找到要删除的这个节点，比如temp
(3) temp.pre.next =temp.next
(4) temp.next.pre=temp.pre;
水浒英雄排名代码实现：
package com.iswhl.linkedlist;
public class DoubleLinkedListDemo {
public static void main(String[] args) {
// 先创建节点
HeroNode2 heroNode1 = new HeroNode2(1, "宋江", "及时雨");
HeroNode2 heroNode2 = new HeroNode2(2, "卢俊义", "玉麒麟");
HeroNode2 heroNode3 = new HeroNode2(3, "吴用", "智多星");
HeroNode2 heroNode4 = new HeroNode2(4, "林冲", "豹子头");
DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
doubleLinkedList.add(heroNode1);
doubleLinkedList.add(heroNode2);
doubleLinkedList.add(heroNode3);
doubleLinkedList.add(heroNode4);
System.out.println("遍历节点：");
doubleLinkedList.list();
System.out.println("添加节点：");
HeroNode2 heroNode5 = new HeroNode2(5, "周洁", "小绵羊");
doubleLinkedList.add(heroNode5);
doubleLinkedList.list();
System.out.println("修改节点：");
HeroNode2 heroNode6 = new HeroNode2(5, "周小洁", "小绵羊");
doubleLinkedList.update(heroNode6);
doubleLinkedList.list();
System.out.println("删除节点：");
doubleLinkedList.delete(5);
doubleLinkedList.list();
}
}
//定义双向链表
class DoubleLinkedList{
public HeroNode2 getHead() {
return head;
}
public void setHead(HeroNode2 head) {
this.head = head;
}
//初始化头节点
private HeroNode2 head = new HeroNode2(0,"","");
//遍历链表
public void list(){
//判断链表是否为空
if (head.next == null){
System.out.println("当前链表为空");
}
//因为头节点，不使用所以应该从头节点的下一个节点开始遍历
HeroNode2 temp = head.next;
while (true){
//判断当前链表是否为空，若非空则输出
if (temp == null){
break;
}
//输出当前的节点
System.out.println(temp);
//输出后将当前节点后移
temp = temp.next;
}
}
//将节点添加到双向链表的尾部
public void add(HeroNode2 heroNode){
HeroNode2 temp = head;//定义一个辅助节点，用来指向当前的头节点
while (true){
//判断当前节点是否有下一个节点，即是否为最后一个节点
//如果是的则结束循环
if (temp.next == null){
break;
}
//如果不是则找到，当前节点的下一个节点
temp = temp.next;
}
//此时temp为当前链表的最后的位置
//让添加进来的最后一个节点，与链表中的最后一个节点进行双向的指向，形成双向链表
temp.next = heroNode;
heroNode.pre = temp;
}
//双向链表修改节点，与单链表修改节点相同（只是节点类型的修改）
public void update(HeroNode2 heroNode){
HeroNode2 temp = head.next;
boolean flag = false;
while (true){
if (temp == null){
break;
}
if (temp.no == heroNode.no){
//表示找到了该节点
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.name = heroNode.name;
temp.nickname = heroNode.nickname;
}
}
//双向链表，删除节点
//说明：
//1.双向链表删除节点可以直接找到要删除的节点进行删除
public void delete(int i) {
HeroNode2 temp = head.next;
boolean flag = false;
while (true) {
if (temp == null) {
System.out.println("链表为空，无法删除");
break;
}
if (temp.no == i) {
//表示找到了该节点
flag = true;
break;
}
temp = temp.next;
}
//此时根据上面的结果temp就是要删除的节点
if (flag) {
temp.pre.next = temp.next;
//这里需要判断是否为链表的最后一个节点
//否则会出现空指针异常
if (temp.next != null){
temp.next.pre = temp.pre;
}
}
}
}
//节点
class HeroNode2{
public int no;
public String name;
public String nickname;
HeroNode2 next;//指向下一个节点默认为null
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 "{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
Josephu（约瑟夫）问题
Josephu问题为:
设编号为1，2，… n的n个人围坐一圈，约定编号为k (1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
提示
用一个不带头结点的循环链表来处理Josephu问题:先构成一个有n个结点的单循环链表,然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。
示意图说明
Josephu问题为:
设编号为1，2， …n的n个人围坐一圈，约定编号为k(1<=k=n〉的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
n= 5,即有5个人
k = 1,从第一个人开始报数
m=2,数2下
具体实现思路:
- 构建一个单向的环形链表思路
1.先创建第一个节点,让first指向该节点,并形成环形
2.后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可.
- 遍历环形链表
1.先让一个辅助指针(变量)curBoy，指向first节点
2.然后通过一个while循环遍历该环形链表即可curBoy.next == first结束
- 小孩出圈的顺序
根据用户的输入，生成一个小孩出圈的顺序
n = 5,即有5个人
k = 1,从第一个人开始报数
m=2,数2下
1.需求创建一个辅助指针(变量) helper ,事先应该指向环形链表的最后这个节点.
**补充:**小孩报数前，先让first和helper移动k-1次
2.当小孩报数时，让first和helper指针同时的移动m -1次
3.这时就可以将first指向的小孩节点出圈
first = first.next
helper.next =first
原来first指向的节点就没有任何引用，就会被回收
出圈的顺序
2->4->1->5->3
实现代码:
package com.iswhl.linkedlist;
public class Josephu {
public static void main(String[] args) {
CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
circleSingleLinkedList.create(5);
circleSingleLinkedList.list();
//验证出圈顺序
System.out.println("出圈顺序为：");
circleSingleLinkedList.countBoy(1,2,5);
}
}
//定义一个环形单链表
class CircleSingleLinkedList{
//定义第一个节点,用来当作头节点
private Boy first = null;//用来当作链表的头节点
private Boy curboy = null;//用来当作辅助指针
//创建环形来链表
public void create(int nums){
//判断nums是否符合逻辑
if (nums < 1){
System.out.println("人数要求要大于1");
return;
}
for (int i = 1; i <= nums; i++) {
Boy boy = new Boy(i);
if (i == 1){
first = boy;//让first指向头节点
first.setNext(first);//当个节点形成环形链表
curboy = boy;//辅助指针
}if (i > 1){
curboy.setNext(boy);//辅助指针指向下一个新增的节点
boy.setNext(first);//新增的节点的下一个指向头节点形成环状
curboy = boy;//辅助节移动到当前新增的节点上
}
}
}
//遍历环形链表
public void list(){
//判断链表是否为空
if (first == null){
System.out.println("链表为空，无法遍历");
return;
}
Boy curboy = first;//先找到头节点
while (true){
System.out.printf("序号为 %d \n",curboy.getNo());
if (curboy.getNext() == first){
return;
}
curboy = curboy.getNext();
}
}
//约瑟夫出圈
/**
*
* @param starnum 第一个开始的小孩编号
* @param countnum 每次要循环的值
* @param nums 一共有多少小孩
*/
public void countBoy(int starnum,int countnum,int nums){
if (starnum < 1 || starnum > nums){
return;
}
//先定义一个辅助指针
Boy curboy = first;//开始让这个辅助指针指向，头节点
while (true){
if (curboy.getNext() == first){
break;
}
curboy = curboy.getNext();
}
//经过上面的循环，让curboy找到最后一个节点
for (int i = 0; i < starnum - 1; i++) {
first = first.getNext();
curboy = curboy.getNext();
}
while (true){
//说明此时环形队列中只有一个节点了
if (first == curboy){
System.out.printf("最后序号 %d \n",first.getNo());
break;
}
for (int i = 0; i < countnum - 1; i++) {
first = first.getNext();
curboy = curboy.getNext();
}
System.out.printf("序号 %d \n",first.getNo());
//此时first就是要出圈的小孩序号
first = first.getNext();
curboy.setNext(first);
}
}
}
//创建节点
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;
}
}
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;
}
}
扫一扫
3653
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
