简述双向链表和约瑟夫（小孩出圈）问题

其实我不想摆烂

于 2022-07-17 10:36:32 发布

阅读量174

点赞数

文章标签：链表数据结构

本文链接：https://blog.csdn.net/m0_49342830/article/details/125829217

版权

双向链表单向环形链表约瑟夫环链表操作数据结构

关键词由CSDN通过智能技术生成

一. 双向链表

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

双向链表有两个指针：Pre指向前一个节点，Next指向后一个节点

遍历方法和单链表一样，只是可以向前，也可以向后查找

添加（默认添加到双向链表的最后）

先找到双向链表最后的这个节点

    temp.next = newNode

    newNode.pre = temp

修改：思路和单向链表一样

删除：

因为是双向链表，因此，我们可以实现自我删除某个节点直接找到要删除的这个节点，比如temp


    temp.pre.next = temp.next

    temp.next.pre = temp.pre

双向链表的创建

    //创建一个双向链表的类
class DoubleLinkedList {
    //初始化一个头节点，头节点不要动， 不存放具体的数据
    private Node2 head = new Node2(0, "", "");

    //返回头节点
    public Node2 getHead() {
        return head;
    }
	//这里就可以有关双向链表的方法了
	
	
}
	
	//定义一个Node2，每个Node2对象就是一个节点
class Node2 {
    public int no;
    public String name;
    public String nickname;
    public Node2 next;//指向 后一个节点，默认为null
    public Node2 pre;//指向前一个节点

    //构造器
    public Node2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }
    //为了显示方便，我们重写toString

    @Override
    public String toString() {
        return "Node2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

通过序号顺序添加


    public void addByOrder(Node2 node) {
        //因为头节点不能动们，因此我们仍然通过一个辅助指针来遍历，帮助我们找到添加的位置
        //
        Node2 temp = head;
        boolean flag = false;//标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > node.no) {//位置找到，就在temp的后面插入
                break;
            } else if (temp.next.no == node.no) {
                //说明希望添加的node编号已经存在了
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;//后移，遍历当前链表
        }
        //判断flag的值
        if (flag) {
            System.out.printf("准备插入的节点的编号%d已经存在了，不能加入\n", node.no);
        } else {
            //插入到链表中，temp后面
            node.next = temp.next;
            node.pre = temp;
            temp.next = node;

        }

    }

删除节点

在双向链表中删除节点需要注意要将：
  （例如要删除的节点为temp节点）
该节点后继的前躯指针指向该节点的前躯
   temp.next.pre = temp.pre;
该节点的前躯的后继指针指向该节点的后继
   temp.pre.next = temp.next;


    //删除一个节点
    //1、对于双向链表，我们可以直接找到要删除的这个节点
    //2、找到后，自我删除即可
    public void delete(int no) {

        //判断当前链表是否为空
        if (head.next == null) {
            System.out.println("链表为空，无法删除");
            return;
        }

        Node2 temp = head.next;//辅助节点直接指向要删除的节点
        boolean flag = false;//是否找到
        while (true) {
            if (temp == null) {//这时已经遍历到链表的最后节点的next
                break;
            }
            if (temp.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的节点", no);
        }
    }

遍历

    //遍历双向链表的方法
    public void list() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要一个辅助指针来遍历
        Node2 temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }

修改

    //修改节点的信息，根据no编号来修改，既no编号不能改
    //和单向链表一样
    public void update(Node2 newnode) {
        //判断是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        Node2 temp = head.next;
        boolean flag = false;//表示是否找到该节点
        while (true) {
            if (temp == null) {
                break;//已经遍历完链表
            }
            if (temp.no == newnode.no) {
                //找到了需要修改的节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag来判断是否找到要修改的节点
        if (flag) {
            temp.name = newnode.name;
            temp.nickname = newnode.nickname;

        } else {//没有找到这个节点
            System.out.printf("没有找到编号为%d的节点", newnode.no);
        }
    }

整体代码

package com.lmh.sparsearray;

public class DoubleLinkedListDemo {
    public static void main(String[] args) {

        System.out.println("双向链表的测试====");
        Node2 node1 = new Node2(1, "老大", "老大");
        Node2 node2 = new Node2(2, "老二", "老二");
        Node2 node3 = new Node2(3, "小三", "小三");

        //创建一个双向链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
//        doubleLinkedList.add(node1);
//        doubleLinkedList.add(node2);
//        doubleLinkedList.add(node3);


        doubleLinkedList.addByOrder(node1);
        doubleLinkedList.addByOrder(node3);
        doubleLinkedList.addByOrder(node2);
        //显示
        doubleLinkedList.list();
        //修改
        Node2 newNode = new Node2(3,"老四","老四");
        doubleLinkedList.update(newNode);
        //显示
        System.out.println("修改后的链表");
        doubleLinkedList.list();
        //删除
        doubleLinkedList.delete(2);
        System.out.println("删除后的链表");
        doubleLinkedList.list();

    }
}

//创建一个双向链表的类
class DoubleLinkedList {
    //初始化一个头节点，头节点不要动， 不存放具体的数据
    private Node2 head = new Node2(0, "", "");

    //返回头节点
    public Node2 getHead() {
        return head;
    }
    //------------------------------------------


    public void addByOrder(Node2 node) {
        //因为头节点不能动们，因此我们仍然通过一个辅助指针来遍历，帮助我们找到添加的位置
        //
        Node2 temp = head;
        boolean flag = false;//标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > node.no) {//位置找到，就在temp的后面插入
                break;
            } else if (temp.next.no == node.no) {
                //说明希望添加的node编号已经存在了
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;//后移，遍历当前链表
        }
        //判断flag的值
        if (flag) {
            System.out.printf("准备插入的节点的编号%d已经存在了，不能加入\n", node.no);
        } else {
            //插入到链表中，temp后面
            node.next = temp.next;
            node.pre = temp;
            temp.next = node;

        }

    }



    //------------------------------------------

    //删除一个节点
    //1、对于双向链表，我们可以直接找到要删除的这个节点
    //2、找到后，自我删除即可
    public void delete(int no) {

        //判断当前链表是否为空
        if (head.next == null) {
            System.out.println("链表为空，无法删除");
            return;
        }

        Node2 temp = head.next;//辅助节点直接指向要删除的节点
        boolean flag = false;//是否找到
        while (true) {
            if (temp == null) {//这时已经遍历到链表的最后节点的next
                break;
            }
            if (temp.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的节点", no);
        }
    }

    //------------------------------------------


    //添加节点到双向链表
    //当不考虑编号顺序时
    //1，找到当前链表的最后节点
    //2，将最后这个节点的next指向新的节点
    public void add(Node2 node) {

        //因为node节点不能动，因此我们需要一个遍历的辅助指针
        Node2 temp = head;

        //遍历链表，找到最后
        while (true) {
            //找到链表的最后
            if (temp.next == null) {
                break;
            }
            //如果没有找到就将temp后移
            temp = temp.next;
        }
        //将退出while循环时，temp就指向来链表的最后
        //形成一个双向链表

        temp.next = node;
        node.pre = temp;
    }

    //------------------------------------------

    //修改节点的信息，根据no编号来修改，既no编号不能改
    //和单向链表一样
    public void update(Node2 newnode) {
        //判断是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        Node2 temp = head.next;
        boolean flag = false;//表示是否找到该节点
        while (true) {
            if (temp == null) {
                break;//已经遍历完链表
            }
            if (temp.no == newnode.no) {
                //找到了需要修改的节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag来判断是否找到要修改的节点
        if (flag) {
            temp.name = newnode.name;
            temp.nickname = newnode.nickname;

        } else {//没有找到这个节点
            System.out.printf("没有找到编号为%d的节点", newnode.no);
        }
    }

    //------------------------------------------

    //遍历双向链表的方法
    public void list() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要一个辅助指针来遍历
        Node2 temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }

    //------------------------------------------
}
//------------------------------------------

//定义一个Node2，每个Node2对象就是一个节点
class Node2 {
    public int no;
    public String name;
    public String nickname;
    public Node2 next;//指向 后一个节点，默认为null
    public Node2 pre;//指向前一个节点

    //构造器
    public Node2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }
    //为了显示方便，我们重写头String

    @Override
    public String toString() {
        return "Node2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

二.单向环形链表

约瑟夫问题（约瑟夫环问题）

设编号为1，2，3，。。。。，n的n个人围坐一圈，约定编号为k（1<= k <=n）的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，以此类推，直到所有人出列为止，由此产生一个出队编号的序列

n=5，既有5个人
k=1，从第1个人开始报数
m=2，数到2出列

首先我们测试构建和遍历单向环形链表：

package com.lmh.sparsearray;

public class Josepfu {
    public static void main(String[] args) {

        //测试构建和遍历
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);//加入5个小孩节点
        circleSingleLinkedList.showBoy();

    }
}

//创建一个环形单向链表
class CircleSingleLinkedList{
    //创建一个first节点，当前没有编号
    private Boy first = new Boy(-1);
    //添加小孩节点，构建成一个环形的链表
    public void addBoy(int nums){
        //nums 做一个数据校验
        if (nums < 1){
            System.out.println("nums的值不正确");
            return;
        }
        Boy curBoy = null;//辅助指针，帮助构建环形链表

        //使用for来创建我们的环形链表
        for (int i = 1; i < nums+1; 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往后移
        }
    }

}
//-------------------------------------

//创建一个Boy类，表示一个节点
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 Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }
}

注解：

1. 因为辅助指针变量是指向最后一个节点，所以当从第k个人开始报数之前我们应该要
让first指向要报数的也就是第k个小孩，让helper指针指向该小孩的前一个；
2. 当小孩报数时，我们让first和helper指针移动（m-1）次，因为这一个是在模拟报数的过程，
自己是1所以向后移动（m-1）次
3. 小孩出圈相当于链表的删除
	first = first.next;
	helper.next = first;

具体代码如下

package com.lmh.sparsearray;

public class Josepfu {
    public static void main(String[] args) {

        //测试构建和遍历
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);//加入5个小孩节点
        circleSingleLinkedList.showBoy();

        //测试小孩出圈
        circleSingleLinkedList.countBoy(1, 2, 5);

    }
}

//创建一个环形单向链表
class CircleSingleLinkedList {
    //创建一个first节点，当前没有编号
    private Boy first = new Boy(-1);

    //添加小孩节点，构建成一个环形的链表
    public void addBoy(int nums) {
        //nums 做一个数据校验
        if (nums < 1) {
            System.out.println("nums的值不正确");
            return;
        }
        Boy curBoy = null;//辅助指针，帮助构建环形链表

        //使用for来创建我们的环形链表
        for (int i = 1; i < nums + 1; 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往后移
        }
    }

    //根据用户的输入，计算出小孩出圈的顺序

    /**
     * startNo 表示从第几个小孩开始数数
     * countNum 表示数几下
     * 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;//指向下一个节点

    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;
    }
}