单向，双向，单向环形链表和约瑟夫问题

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量97 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44689277/article/details/115419529
版权

文章目录

简要概括

单向链表
  • 新建： 新建一个类用来充当链表的节点数据
  • 添加：
    • 无序的添加（插入到末尾）：定义一个一个辅助指针cur,用来找到链表的末尾，将cur的next指向你要添加到节点newNode, cur.next=newNode
    • 有序的添加（插入到链表中）：定义一个辅助指针cur，将cur指向你将要添加位置的前一个节点。先将新节点newNode指向cur的next节点。newNode.next=cur.next，再将cur.next指向新节点newNode ,cur.next=newNode。
  • 修改： 需要定义一个辅助指针找到该节点，将该节点的信息进行修改就行。
  • 删除： 定义一个辅助指针cur,将辅助指针指向你需要删除的下一个节点就可以，cur.next=cur.next.next
  • 遍历: 定义一个辅助指针cur，依次进行输出就可以了
双向链表
  • 新建： 和单向链表的数据节点一样，只是多了一个指向前一个节点的指针pre。
  • 添加：
    • 无序添加（添加到链表的末尾）： 定义一个一个辅助指针cur,用来找到链表的末尾，将cur的next指向你要添加到节点,cur.next=newNode，然后将新的节点的pre指向cur，newNode.pre=cur.
    • 有序添加（插入到链表中）： 定义一个辅助指针cur，将cur指向你将要添加位置的前一个节点。先将cur节点后的节点与新添加的节点进行关联，newNode.next=cur.next; cur.next.pre=newNode;这时会有一个异常如果你添加的一个数据正好要添加到链表的最后所以这里应该进行判断是否为空。接下来要进行cur节点与新的节点进行关联，cur.next=newNode; newNode.pre=cur;完成关联。
  • 修改：需要定义一个辅助指针找到该节点，将该节点的信息进行修改就行。
  • 删除：定义一个辅助指针cur辅助指针 指向你要删除的节点，然后将你要删除节点的前一个节点的next指向你需要删除的下一个节点，在将你要删除的下一个节点指向你要删除节点的前一个节点。这是你需要判断你删除的是否是最后一个节点。cur.next.pre=cur.pre;然后 cur.pre.next=cur.next
  • 遍历: 定义一个辅助指针cur，依次进行输出就可以了。
单向环形链表
  • 新建： 和单向链表一样。
  • 添加： 基本和单行链表一样只有在添加第一个和最后一个的时候有点区别，
    • 第一个： 因为是环形链表，第一个也需要成环，所以需要第一个的next指向自己。first.next=first
    • 最后一个: 需要将最后一个的next指向first. end.next=first
  • 修改： 同上
  • 删除： 同单向链表
  • 遍历： 同单向链表，结束条件位辅助指针的next==first;

代码实现

单向链表

新建 :

/**
 * 创建节点，每个heroNode 就是一个节点
 */
class HeroNode {
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;

    public HeroNode(int hNo, String hName, String hNickName) {
        this.no = hNo;
        this.name = hName;
        this.nickName = hNickName;
    }

    /**
     * 为了显示方便重写toString
     *
     * @return String
     */
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

添加(不考虑编号)

/**
 * 添加节点到单向链表
 * 思路: 1、当不考虑编号的顺序时
 *          1、找到当前链表的最后节点(需要一个辅助指针找到最后节点)
 *          2、将最后节点的next 指向新的节点
 *      2、考虑编号的顺序
 *          1、找到新添加节点的位置（通过辅助指针）
 *          2、新的节点的next 指向辅助指针的节点的后一个节点
 *          3、temp.next指向新的节点
 * @param heroNode 添加链表的节点
 */
public void add(HeroNode heroNode) {
    //因为head 不能动，因此需要一个辅助指针
    HeroNode temp = head;
    //遍历链表，找到最后节点
    while (temp.next != null) {
        //找到链表的最后
        temp = temp.next;
        //当退出循环时，temp就指向了最后节点
    }
    temp.next=heroNode;
}

添加(考虑编号)

/**
 * 添加节点到单向链表
 * 思路: 1、当不考虑编号的顺序时
 *          1、找到当前链表的最后节点(需要一个辅助指针找到最后节点)
 *          2、将最后节点的next 指向新的节点
 *      2、考虑编号的顺序
 *          1、找到新添加节点的位置（通过辅助指针）
 *          2、新的节点的next 指向辅助指针的节点的后一个节点
 *          3、temp.next指向新的节点
 * @param heroNode 添加链表的节点
 */
public void addByOrder(HeroNode heroNode) {
    //因为头节点不能动，需要一个辅助指针来找到需要添加到位置
    //因为时单链表，因为我们找到的temp 是位于添加位置的前一个节点，否则添加不进去
    HeroNode temp = head;
    //标志添加的编号是否存在，默认是false
    boolean flag=false;
    while (true) {
        //说明temp已经在链表的最后
        if (temp.next == null) {
            break;
        }
        //位置已经找到，就在temp 后面
        if (temp.next.no > heroNode.no) {
            break;
            //编号已经存在
        } else if (temp.next.no == heroNode.no) {
            flag = true;
            break;
        }
        temp=temp.next;
    }
    //判断flag，编号已经存在不能添加
    if (flag){
        System.out.printf("插入到英雄的编号已经存在 %d,不能在添加了\n",heroNode.no);
    }else {
        //插入到链表中
        heroNode.next=temp.next;
        temp.next=heroNode;
    }
}

修改

/**
 * 修改节点的信息,根据编号来修改，编号不能修改。
 * @param newHeroNode 修改的节点信息
 */
public void update(HeroNode newHeroNode){
    //判断链表是否为空
    if (head.next==null){
        System.out.println("链表为空");
        return;
    }
    //找到需要修改的节点
    HeroNode temp = head.next;
    //表示是否找到了你需要修改的节点
    boolean flag=false;
    while (true){
        if (temp==null){
            //已经遍历完，
            break;
        }
        if (temp.no== newHeroNode.no){
            //找到了
            flag=true;
            break;
        }
        temp=temp.next;
    }
    //根据标志位判断
    if (flag){
        temp.name= newHeroNode.name;
        temp.nickName= newHeroNode.nickName;
    }else {
        System.out.printf("没有找到编号为%d的节点\n",newHeroNode.no);
    }
}

删除

/**
 * 1、我们需要先找到待删除节点的前一个节点 temp
 * 2、temp.next=temp.next.next;
 * 3、被删除的节点将不会有其他引用指向，会被垃圾回收机制回收
 * @param no 待删除的节点
 */
public void delete(int no){
    //头节点不能动，需要一个辅助节点temp
    //我们在判断时需要用temp.next.no 和deleteHeroNode.next.no进行比较
    //找到需要修改的节点
    HeroNode temp = head;
    //表示是否找到了你需要删除的节点的上一个节点
    boolean flag=false;
    while (temp.next != null) {
        if (temp.next.no == no) {
            //找到了待删除前一个节点
            flag = true;
            break;
        }
        temp = temp.next;
    }
    if (flag){
        //可以删除
        temp.next=temp.next.next;
    }else {
        System.out.printf("要删除的节点%d不存在\n",no);
    }
}

遍历

/**
 * 显示链表
 */
public void list(){
    if (head.next==null){
        System.out.println("链表为空");
        return;
    }
    //因为头节点不能动，需要一个辅助的指针来进行遍历
    HeroNode temp =head.next;
    while (temp!=null){
        System.out.println(temp.toString());
        //将temp后移
        temp=temp.next;
    }

}
双向链表

新建

/**
 * 创建节点，每个heroNode 就是一个节点
 */
class HeroNode2 {
    public int no;
    public String name;
    public String nickName;
    public HeroNode2 next;
    public HeroNode2 pre;

    public HeroNode2(int hNo, String hName, String hNickName) {
        this.no = hNo;
        this.name = hName;
        this.nickName = hNickName;
    }

    /**
     * 为了显示方便重写toString
     *
     * @return String
     */
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

添加（不考虑编号）

/**
 * 添加节点到单向链表
 * 思路: 1、当不考虑编号的顺序时
 * 1、找到当前链表的最后节点(需要一个辅助指针找到最后节点)
 * 2、将最后节点的next 指向新的节点
 * 3、并且最后的节点指向前一个节点
 * temp.next=newNode
 * newNode.pre=temp;
 *
 * @param heroNode 添加链表的节点
 */
public void add(HeroNode2 heroNode) {
    //因为head 不能动，因此需要一个辅助指针
    HeroNode2 temp = head;
    //遍历链表，找到最后节点
    while (temp.next != null) {
        //找到链表的最后
        temp = temp.next;
        //当退出循环时，temp就指向了最后节点
    }
    //形成一个双向链表
    temp.next = heroNode;
    heroNode.pre = temp;
}

添加（考虑编号）

/**
 * 添加节点到单向链表
 * 思路: 2、考虑编号的顺序
 *          1、找到新添加节点newNode的位置(添加位置的前一个节点temp)（通过辅助指针）
 *          2、 temp.next.pre=heroNode;   temp.next=newNode.next; (先连接后面的节点)
 *              temp.next=newNode     ;   heroNode.pre=temp  (在连接前面的节点)
 *          3、但是这里会有一个问题空指针异常，需要先进性判断temp.next是否为空
 * @param heroNode 添加链表的节点
 */
public void addByOrder(HeroNode2 heroNode) {
    //因为头节点不能动，需要一个辅助指针来找到需要添加到位置
    //因为时单链表，因为我们找到的temp 是位于添加位置的前一个节点，否则添加不进去
    HeroNode2 temp = head;
    //标志添加的编号是否存在，默认是false
    boolean flag=false;
    while (true) {
        //说明temp已经在链表的最后
        if (temp.next == null) {
            break;
        }
        //位置已经找到，就在temp 后面
        if (temp.next.no > heroNode.no) {
            break;
            //编号已经存在
        } else if (temp.next.no == heroNode.no) {
            flag = true;
            break;
        }
        temp=temp.next;
    }
    //判断flag，编号已经存在不能添加
    if (flag){
        System.out.printf("插入到英雄的编号已经存在 %d,不能在添加了\n",heroNode.no);
    }else {
        if (temp.next!=null){
            temp.next.pre=heroNode;
            heroNode.next=temp.next;
        }
        temp.next=heroNode;
        heroNode.pre=temp;
    }
}

修改

/**
 * 修改节点的信息,根据编号来修改，编号不能修改。
 *
 * @param newHeroNode 修改的节点信息
 */
public void update(HeroNode2 newHeroNode) {
    //判断链表是否为空
    if (head.next == null) {
        System.out.println("链表为空");
        return;
    }
    //找到需要修改的节点
    HeroNode2 temp = head.next;
    //表示是否找到了你需要修改的节点
    boolean flag = false;
    while (true) {
        if (temp == null) {
            //已经遍历完，
            break;
        }
        if (temp.no == newHeroNode.no) {
            //找到了
            flag = true;
            break;
        }
        temp = temp.next;
    }
    //根据标志位判断
    if (flag) {
        temp.name = newHeroNode.name;
        temp.nickName = newHeroNode.nickName;
    } else {
        System.out.printf("没有找到编号为%d的节点\n", newHeroNode.no);
    }
}

/**
 * 1、我们需要先找到待删除节点 temp
 * 2、找到这个节点自我删除
 *
 * @param no 待删除的节点
 */
public void delete(int no) {
    if (head.next == null) {
        System.out.println("链表为空");
        return;
    }
    //头节点不能动，需要一个辅助节点temp
    //我们在判断时需要用temp.next.no 和deleteHeroNode.next.no进行比较
    //找到需要修改的节点
    HeroNode2 temp = head.next;
    //表示是否找到了你需要删除的节点的上一个节点
    boolean flag = false;
    while (temp != null) {
        if (temp.no == no) {
            //找到了待删除前一个节点
            flag = true;
            break;
        }
        temp = temp.next;
    }
    if (flag) {
        //可以删除
        temp.pre.next = temp.next;
        if (temp.next != null) {
            temp.next.pre = temp.pre;
        }
    } else {
        System.out.printf("要删除的节点%d不存在\n", no);
    }
}

/**
 * 显示链表
 */
public void list(){
    if (head.next==null){
        System.out.println("链表为空");
        return;
    }
    //因为头节点不能动，需要一个辅助的指针来进行遍历
    HeroNode2 temp =head.next;
    while (temp!=null){
        System.out.println(temp.toString());
        //将temp后移
        temp=temp.next;
    }

}

删除

/**
 * 1、我们需要先找到待删除节点 temp
 * 2、找到这个节点自我删除
 *
 * @param no 待删除的节点
 */
public void delete(int no) {
    if (head.next == null) {
        System.out.println("链表为空");
        return;
    }
    //头节点不能动，需要一个辅助节点temp
    //我们在判断时需要用temp.next.no 和deleteHeroNode.next.no进行比较
    //找到需要修改的节点
    HeroNode2 temp = head.next;
    //表示是否找到了你需要删除的节点的上一个节点
    boolean flag = false;
    while (temp != null) {
        if (temp.no == no) {
            //找到了待删除前一个节点
            flag = true;
            break;
        }
        temp = temp.next;
    }
    if (flag) {
        //可以删除
        temp.pre.next = temp.next;
        if (temp.next != null) {
            temp.next.pre = temp.pre;
        }
    } else {
        System.out.printf("要删除的节点%d不存在\n", no);
    }
}

遍历（正序）

/**
 * 显示链表
 */
public void list(){
    if (head.next==null){
        System.out.println("链表为空");
        return;
    }
    //因为头节点不能动，需要一个辅助的指针来进行遍历
    HeroNode2 temp =head.next;
    while (temp!=null){
        System.out.println(temp.toString());
        //将temp后移
        temp=temp.next;
    }

}

遍历（反序）

public void listRevers(){
    if (head.next==null){
        System.out.println("链表为空");
        return;
    }
    //因为头节点不能动，需要一个辅助的指针来进行遍历
    HeroNode2 temp =head;
    while (temp.next!=null){
        temp=temp.next;
    }
    //这时已经找到了最后
    while (temp.pre!=null){
        System.out.println(temp);
        temp=temp.pre;
    }
}
单向环形列表

单向环形列表用一个经典的例题进行代替。丢手绢（约瑟夫问题）

新建

/**
 * 先创建一个节点类
 */
class Boy{
    private int no;
    private Boy next;

    public Boy(int no){
        this.no=no;
    }

    @Override
    public String toString() {
        return "Boy{" +
                "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;
    }
}

添加（给定一个数nums，新建一个nums大小的环形链表）

/**
 * 创建一个环形链表
 * @param nums 创建的节点数
 */
public void addBoy(int nums){
    //判断nums 是否合法
    if (nums<1){
        System.out.println("nums不合法");
        return;
    }
    Boy curBoy = null;
    for (int i = 1; i <= nums; i++) {
        //创建你将要添加的节点
        Boy boy = new Boy(i);
        if (i==1){
            //当第一个节点也要闭环
            first=boy;
            first.setNext(first);
            curBoy=first;
        }else {
            curBoy.setNext(boy);
            boy.setNext(first);
            curBoy=boy;
        }
    }
}

编辑 和单向列表一样

删除节点（出圈）

/**
 *  * 根据用户输入输出小孩的出圈顺序
 *  * 思路： 1、定义一个辅助指针cur,和一个帮助指针helper.让cur指向开始报数的节点
 *  *        2、cur指向冲那个小孩开始报数的指针，helper.next=cur,因为删除需要前一个节点。
 *  *        3、需要移动 k-1 次。
 * @param startNo 开始的编号
 * @param countNum 数几下
 * @param nums 总共有几个
 */
public void deleteBoy(int startNo, int countNum, int nums) {
    //校验数据的合理性
    if (first == null || startNo < 1 || startNo > nums || countNum > nums) {
        System.out.println("你输入的数据不合理");
        return;
    }
    //定义辅助查询指针
    Boy cur=first;
    //让cur 指向开始报数的人
    for (int i = 0; i < startNo-1; i++) {
        cur=cur.getNext();
    }
    //定义一个删除的辅助指针
    Boy helper=first;
    while (helper.getNext()!=cur){
        helper=helper.getNext();
    }
    //循环出圈
    while (helper != cur) {
        for (int i = 0; i < countNum - 1; i++) {
            cur = cur.getNext();
            helper = helper.getNext();
        }
        //找到出圈的boy
        System.out.printf("出圈的Boy编号%d\n", cur.getNo());
        //将该Boy出圈
        cur = cur.getNext();
        helper.setNext(cur);
    }
    //圈中最后剩下的一个
    System.out.printf("最后出圈的Boy编号%d\n",cur.getNo());
    first=null;
}

测试

public class JosephDemo {
    public static void main(String[] args) {
        //测试
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.showBoy();
        circleSingleLinkedList.deleteBoy(1,2,5);
        circleSingleLinkedList.showBoy();

   }
}

结果

小孩的编号位1 
小孩的编号位2 
小孩的编号位3 
小孩的编号位4 
出圈的Boy编号2
出圈的Boy编号4
出圈的Boy编号1
出圈的Boy编号5
最后出圈的Boy编号3
链表为空~~~

最后

总结：当单向链表添加删除时，辅助指针都要指向操作的前一个节点，但是双向链表删除时可以不用指向前一个节点，因为可以自己进行删除操作不需要辅助。

当节点进行关联时，最后先和后面的节点进行关联，因为指针一般都在前面。

喝酸奶必舔瓶盖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向链表和环形链表（单向和双向）约瑟夫环实例
wardo_l的博客
03-06 467
双向链表 数组优缺点：根据下标直接查找和修改，增删需要移动后续数据，效率低。 单向链表的缺点：增删快速，查找需要从头遍历，效率低。 双线链表可以向前或向后查找。 单向链表查找的方向只能是一个方向（双向链表可以向前向后查找），且不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除节点时，总是找到temp的下一个节点来删除的（就是指temp.next.data == data，因为要对该节点的前一个节点及后一个节点操作。) 双向链表节点包含数据域data、前驱指针域prev
链表---单向链表之节点的修改和删除
BEYONDmonster的博客
08-29 1718
单向链表的修改和删除操作 一、对单向链表的节点的修改：（根据节点编号进行修改） 思路： 1.首先判断链表是否为空 2.遍历链表，查找是否存在对应编号的节点 3.如果存在该节点，则对该节点的内容进行修改 实现代码如下： public class SingleLinkedListDemo { public static void main(String[] args) { // TODO Auto...
单行链表与双向链表问题实例
12-03
link中以单向链表 改变节点指针 linked中以双向链表 来插入节点数 检查时间复杂度
数据结构（四）--------单向链表、单向循环链表
weixin_43956414的博客
09-19 190
动态链表： 在学过数组后，发现数组的存储结构有一定的缺陷。就是查找效率高，但是 增、删、改效率低， 还有就是数组的大小是不可变的。 接下来介绍一种新的数据存储结构（链表）相对于数组来说还是有一些不同的地方。 链表：是一种线性的数据结构，相比数组，链表更加灵活，通过指针去进行增、删、改查，但是链表不能通过下标去查询。 一个链表结点包含数据域和指针域。 代码实现： private class Nod...
java 实现单链表的逆序
单行线的专栏
07-19 6659
java 实现单链表的逆序
LeetCode（链表：只能通过操纵节点以及节点的next指针完成，不能修改节点的值）
weixin_44333294的博客
11-25 453
public class ListNode { int val; ListNode next; public ListNode(int x){ val=x; } //链表节点的构造函数，使用arr作为参数，创建一个链表，当前构造的ListNode为链表的头结点 public ListNode(int[] arr){ if(arr==null||arr.length==0){ throw new I..
约瑟夫双向生死游戏双向队列实现
04-06
约瑟夫双向生死游戏是一种基于环形链表或队列的经典问题，它的基本思想源于一个古老的传说：在古代，一群囚犯被围成一个圈，按照一定的规则每隔一定人数淘汰一个人，直到只剩最后一个人为止。这个过程就被称为约瑟夫...
【超全！】图解Java数据结构和算法(共195集)【资料+视频+课件+代码+笔记】
10-13
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、...
约瑟夫环leetcode-DataStructure:数据结构与算法（Java实现）
07-06
约瑟夫环 leetcode ...LinkedList双向链表实现解决约瑟夫环问题 04-栈 Stack利用java组合实现栈 05-队列 Queue队列实现 Deque双端队列实现 CircleQueue环形队列实现 CircleDeque环形双端队列实现 06-二叉树
约瑟夫环leetcode-algorithm-and-data-structure:数据结构-java版ANDleetcode刷题
07-06
约瑟夫环 leetcode data-structure 重学数据结构-java版 0. 目录 内容 ...延伸出单向环形链表 解决约瑟夫斯问题：com.imyiren.datastructure.linkedlist.JosephuQuestion 包括：环形链表的创建，节
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
单行链表寻找倒数第k个节点
leo115的专栏
09-21 1551
/** *题目介绍：给出一个单向链表，输出该链表的倒数第k个节点 *           设尾节点开始从0编号 */ 解题思路：两个指针往后移动，一定要注意边界的处理情况。此处我设置了一个头指针，头指针不存数据，仅仅作为头标志。 /** *题目介绍：给出一个单向链表，输出该链表的倒数第k个节点 * 设尾节点开始从0编号 */ #include #incl
golang 接口
m0_70982551的博客
07-24 872
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 458
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 561
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 548
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 345
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 398
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
单向链表、约瑟夫问题的代码
03-23
以下是单向链表和约瑟夫问题的代码： 单向链表： ``` class Node: def __init__(self, data): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None def append...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值