Java实现链表

最新推荐文章于 2024-03-05 18:08:33 发布
最新推荐文章于 2024-03-05 18:08:33 发布
阅读量645 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jxiao_linbei/article/details/123565519
版权

目录

单链表

使用带head头的单向链表实现 --- 水浒英雄排行榜管理

单链表面试题:

1. 求单链表中有效节点的个数

2. 查找单链表中倒数第k个节点 [ 新浪面试题 ]

3. 单链表反转 [ 腾讯面试题 ]

4. 从尾到头打印单链表 [ 百度, 要求方式1: 反向遍历. 方式2: Stack栈 ]

5. 合并两个有序的单链表, 合并之后的链表依然有序

双向链表

单向环形链表

单链表

  1. 链表是以节点方式来存储, 是链式存储
  2. 每个节点包含data域, next域: 指向下一个节点
  3. 如图: 链表的各个节点不一定是连续存放的
  4. 链表分带头节点的链表和没有头节点的链表, 根据实际的需求来确定

使用带head头的单向链表实现 --- 水浒英雄排行榜管理

1)完成对英雄人物的增删改查操作

2)第一种方法在添加英雄时, 直接添加到链表尾部

3)第二种方式在添加英雄时,根据排名将英雄插入到指定位置(如果有这个排名, 则添加失败,并给出提示)

在最后添加英雄:

  1. 先创建一个head头节点，作用就是表示单链表的头
  2. 后面我们每添加一个节点，就直接加入到链表的最后

按照编号的顺序添加:

  1. 首先找到新添加的节点的位置, 是同各国辅助变量(指针)
  2. 新的节点 .next=temp.next
  3. 将temp.next=新的节点
package com.bei.linkedlist;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        // 测试
        //先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");

        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        //加入
//        singleLinkedList.add(hero1);
//        singleLinkedList.add(hero4);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);

        //加入按照编号的顺序
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        //显示
        singleLinkedList.list();

        //修改节点的代码
        HeroNode heroNode = new HeroNode(2, "玉麒麟", "小鹿");
        singleLinkedList.update(heroNode);

        singleLinkedList.delete(4);

        System.out.println("修改后的链表情况~");
        //显示
        singleLinkedList.list();
    }
}


//定义一个SingleLinkedList 管理我们的英雄
class SingleLinkedList {
    //先初始化一个头节点,头节点不要动
    public HeroNode head = new HeroNode(0,"","");

    //添加节点到单向链表
    // 当不考虑编号的顺序时:
    public void add(HeroNode heroNode){
        // 1. 首先找到最后一个节点
        // 2. 让最后一个节点的next指向添加的新节点
        //因为 head节点不能动, 因此我们需要一个辅助遍历 temp
        HeroNode temp = head;
        //遍历链表, 找到最后
        while (true){
            //找到链表的最后
            if (temp.next==null){
                break;
            }
            //如果没有找到最后, 就将temp后移
            temp = temp.next;
        }
        // 当退出while循环时吗temp就指向了链表的最后
        //让最后一个节点的next指向添加的新节点
        temp.next = heroNode;
    }

    //第二种方式在添加英雄时, 根据排名将英雄插入到指定位置
    //(如果有这个排名, 则添加失败, 并给出提示)
    public void addByOrder(HeroNode heroNode){
        //因为头节点不能动, 我们仍然通过辅助变量来找到添加的位置
        //因为单链表, 因为我们找的temp是位于添加位置的前一个节点, 否则插入不了
        HeroNode temp = head;
        boolean flag = false;
        while(true){
            if (temp.next == null){//说明temp已经在链表的最后
                break;
            }
            if (temp.next.no>heroNode.no){//位置找到, 在temp的后面插入
                break;
            }else if (temp.next.no==heroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;//后移, 遍历当前链表
        }
        //判断flag的值
        if (flag){//不能添加, 说明编号存在
            System.out.println("准备插入的英雄的编号"+heroNode.no+"已经存在了,不能加入");
        }else {
            //插入到链表中, temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点的信息, 根据编号来修改, 即no编号不能改
    //说明
    //1. 根据newHeroNode的no来修改即可
    public void update(HeroNode newHeroNode){
        //判断是否为空
        if(head.next==null){
            System.out.println("链表为空~");
            return;
        }
        //找到需要修改的结点, 根据no编号
        //定义一个辅助变量
        HeroNode 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.println("没有找到编号为"+newHeroNode.no+"的节点");
        }
    }

    //删除一个节点
    public void delete(int no){
        HeroNode temp = head;
        boolean flag = false;//是否找到待删除的结点
        while (true){
            if (temp.next==null){
                break;
            }else if (temp.next.no==no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next = temp.next.next;
        }else {
            System.out.println("要删除的节点不存在");
        }
    }

    //显示链表: 遍历
    //通过辅助变量来遍历
    public void list(){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动, 因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true){
            //判断是否到链表的最后
            if (temp==null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }

}

    //定义HeroNode, 每个HeroNode 对象就是一个节点
class HeroNode{
    public int no;  //编号
    public String name;   //名字
    public String nickname;    //昵称
    public HeroNode next;

    //构造器
    public HeroNode(int No, String Name, String Nickname){
        this.no = No;
        this.name = Name;
        this.nickname = Nickname;
    }

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

单链表面试题:

1. 求单链表中有效节点的个数

/*
      求单链表中有效节点的个数
 */
public class LinkedListTest01 {

    // 获取到单链表的节点个数(如果是带头节点的链表, 需求: 不统计头节点)

    /**
     *
     * @param head :链表的头节点
     * @return : 有效节点的个数
     */
    public int getLength(HeroNode head){
        if (head.next==null){
            return 0;
        }
        int length =  0;
        //没有统计头节点
        HeroNode temp = head.next;
        while (temp != null){
            length++;
            temp = temp.next;

        }
        return length;
    }

}

2. 查找单链表中倒数第k个节点 [ 新浪面试题 ]

/*
   查找单链表中倒数第k个节点 [ 新浪面试题 ]
 */
public class LinkedListTest02 {
    // 1. 编写一个方法接收head节点, 同时接收一个index
    // 2. index 表示是倒数第index个节点
    // 3. 先把链表从头到尾遍历, 得到链表的总长度
    // 4. 得到size后, 我们从链表的第一个开始遍历(size-index)个, 就可以得到
    // 5. 如果找到了则返回该节点, 否则返回空
    public HeroNode findLastIndexNode(HeroNode head, int index){
        //判断如果链表为空, 返回null
        if (head.next == null){
            return null;
        }
        //第一次遍历得到链表的长度
        int size =  0;
        //没有统计头节点
        HeroNode temp = head.next;
        while (temp != null){
            size++;
            temp = temp.next;

        }
        //第二次遍历 size-index 位置, 就是我们的倒数第k个节点
        //先做一个index校验
        if (index<=0||index>size){
            return null;
        }
        //定义一个辅助变量
        HeroNode cur = head.next;
        for (int i = 0; i < size - index; i++) {
            cur = cur.next;
        }
        return cur;
    }
}

3. 单链表反转 [ 腾讯面试题 ]

/*
      单链表反转 [ 腾讯面试题 ]
 */
public class LinkedListTest03 {

    //1. 先定义一个节点 reverseHead = new HeroNode();
    //2. 从头到尾遍历原来的链表, 每遍历一个节点, 就将其取出, 并放在新的链表的最前端
    //3. 原来的链表的head.next = reverseHead.next

    public HeroNode reverseList(HeroNode head){

        if (head.next==null || head.next.next==null){
            return head;
        }

        HeroNode temp = head.next;
        HeroNode next = null;

        HeroNode reverseHead = new HeroNode(0,"","");

        //遍历原来的链表
        //并从头到位遍历原来的链表，每遍历一个节点就将其取出， 并放在新的链表reverseHead的最前端
        while(temp != null){
            next = temp.next;//保存当前节点的下一个节点， 后面使用
            temp.next = reverseHead.next;//将temp的下一个节点指向新的链表的最前端
            reverseHead.next = temp;//将temp连接到新的链表上
            temp = next; //让temp后移
        }
        head.next = reverseHead.next;

        return head;
    }


}

4. 从尾到头打印单链表 [ 百度, 要求方式1: 反向遍历. 方式2: Stack栈 ]

/*
  从尾到头打印单链表
  1. 先反转再打印， 不建议， 会破坏原本的链表
  2. 可以利用栈这个数据结构， 将各个节点压入到栈中， 然后利用栈先进后出的特点来实现逆序打印
  3. 使用递归
 */

import java.util.Stack;

public class LinkedListTest04 {

    public void reversePrint(HeroNode head){
        if (head.next==null){
            return;
        }
        HeroNode temp = head.next;
        Stack<HeroNode> print = new Stack();
        while(true){
            if (temp==null){
                break;
            }
            print.add(temp);
            temp = temp.next;
        }

        while(print.size()>0){
            System.out.println(print.pop().toString());
        }

    }

    //递归写法
    public void reversePrint1(HeroNode head){
        if (head.next==null){
            return;
        }
        head = head.next;
        reversePrint1(head);
        System.out.println(head.toString());
    }

}

5. 合并两个有序的单链表, 合并之后的链表依然有序

/*
 合并两个有序链表， 合并后依然有序
 */
public class LinkedListTest05 {
    public static void main(String[] args) {
        Test05 t1 = new Test05(3);
        Test05 t2 = new Test05(46);
        Test05 t3 = new Test05(343);
        Test05 t4 = new Test05(56);
        Test05 t5 = new Test05(7);
        Test05 t6 = new Test05(98);
        Test05 t7 = new Test05(34);
        Link05 link1 = new Link05();
        link1.add(t1);
        link1.add(t2);
        link1.add(t3);
        link1.add(t4);
        link1.add(t5);
        link1.add(t6);
        link1.add(t7);
        link1.list();
        System.out.println("-----------------------------");
        Test05 tt1 = new Test05(33);
        Test05 tt2 = new Test05(36);
        Test05 tt3 = new Test05(323);
        Test05 tt4 = new Test05(16);
        Test05 tt5 = new Test05(17);
        Test05 tt6 = new Test05(28);
        Test05 tt7 = new Test05(64);
        Link05 link2 = new Link05();
        link2.add(tt1);
        link2.add(tt2);
        link2.add(tt3);
        link2.add(tt4);
        link2.add(tt5);
        link2.add(tt6);
        link2.add(tt7);
        link2.list();
        System.out.println("-----------------------------");
        Test05 merge = merge(link1.getHead(), link2.getHead());
        while (merge.next!=null){
            System.out.println(merge.next.no);
            merge = merge.next;
        }
    }

    public static Test05 merge(Test05 head1, Test05 head2){
        if (head1.next==null){
            return head2;
        }else if(head2.next==null){
            return head1;
        }
        Test05 head = new Test05(0);
        Test05 temp1 = head1.next;
        Test05 temp2 = head2.next;
        Test05 temp3 = head;

        //难点： 保存下一个节点，不然会丢失指向
        Test05 next1 = null;
        Test05 next2 = null;

        while (temp1!=null&&temp2!=null){
            if (temp1.no<=temp2.no){
                next1 = temp1.next;
                temp3.next = temp1;
                temp1 = next1;
            }else if (temp1.no>=temp2.no){
                next2 = temp2.next;
                temp3.next = temp2;
                temp2 = next2;
            }
            temp3 = temp3.next;
        }
        if (temp1==null){
            temp3.next = temp2;
        }
        if (temp2==null){
            temp3.next = temp1;
        }

        return head;
    }
}

class Link05{

    public Test05 head = new Test05();

    public Test05 getHead() {
        return head;
    }

    public Link05(Test05 head) {
        this.head = head;
    }

    public Link05() {
    }

    //添加
    public void add(Test05 t){
        boolean flag = false;
        Test05 temp = head;
        while (true){
            if (temp.next==null){
                break;
            }else if (temp.next.no>t.no){
                break;
            }else if (temp.next.no==t.no){
                flag=true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            System.out.println("节点 "+t.no+" 已存在，无法插入");
        }else {
            t.next=temp.next;
            temp.next=t;
        }
    }

    //遍历
    public void list(){
        if (head.next==null){
            System.out.println("该链表没有存数据");
            return;
        }
        Test05 temp = head.next;
        while (temp!=null){
            System.out.println(temp.no);
            temp=temp.next;
        }
    }
}

class Test05{
    int no;
    Test05 next;

    @Override
    public String toString() {
        return "Test05{" +
                "no=" + no +
                ", next=" + next +
                '}';
    }

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

    public Test05() {
    }
}

双向链表

  1. 双向链表可以向前或向后查找
  2. 双向链表可以自我删除

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

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

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

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

        (2) temp.next = newHeroNode

        (3) newHeroNode.pre = temp;

3) 修改 思路和 原来的单向链表一样.

4) 删除

        (1) 因为是双向链表，因此，我们可以实现自我删除某个节点

        (2) 直接找到要删除的这个节点，比如temp

        (3)  temp.pre.next = temp.next

        (4) temp.next.pre = temp.pre;

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

        //测试
        DoubleHeroNode hero1 = new DoubleHeroNode(1, "宋江", "及时雨");
        DoubleHeroNode hero2 = new DoubleHeroNode(2, "卢俊义", "玉麒麟");
        DoubleHeroNode hero3 = new DoubleHeroNode(3, "吴用", "智多星");
        DoubleHeroNode hero4 = new DoubleHeroNode(4, "林冲", "豹子头");

        //创建双向链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
//        doubleLinkedList.add(hero2);
//        doubleLinkedList.add(hero1);
//        doubleLinkedList.add(hero3);
//        doubleLinkedList.add(hero4);
        doubleLinkedList.addByOrder(hero2);
        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero4);

        System.out.println("查看列表-----------------------");
        doubleLinkedList.list();

        System.out.println("查看修改后的列表-------------------");
        //修改
        DoubleHeroNode newhero = new DoubleHeroNode(3, "new吴用", "new智多星");
        doubleLinkedList.update(newhero);
        doubleLinkedList.list();

        System.out.println("删除序号1-----------------------");
        //删除
        doubleLinkedList.delete(1);
        doubleLinkedList.list();
    }
}
class DoubleLinkedList{

    //先初始化一个头节点,头节点不要动
    public DoubleHeroNode head = new DoubleHeroNode(0,"","");

    public DoubleHeroNode getHead(){
        return head;
    }


    // 添加到双向链表
    public void add(DoubleHeroNode heroNode){
        DoubleHeroNode temp = head;
        //遍历链表, 找到最后
        while (true){
            //找到链表的最后
            if (temp.next==null){
                break;
            }
            //如果没有找到最后, 就将temp后移
            temp = temp.next;
        }
        // 当退出while循环时吗temp就指向了链表的最后

        temp.next = heroNode;
        heroNode.pre = temp;
    }

    //(如果有这个排名, 则添加失败, 并给出提示)
    public void addByOrder(DoubleHeroNode heroNode){
        //因为头节点不能动, 我们仍然通过辅助变量来找到添加的位置
        DoubleHeroNode temp = head;
        boolean flag = false;
        while(true){
            if (temp.next == null){//说明temp已经在链表的最后
                break;
            }
            if (temp.next.no>heroNode.no){//位置找到, 在temp的后面插入
                break;
            }else if (temp.next.no==heroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;//后移, 遍历当前链表
        }
        //判断flag的值
        if (flag){//不能添加, 说明编号存在
            System.out.println("准备插入的英雄的编号"+heroNode.no+"已经存在了,不能加入");
        }else {
            //插入到链表中, temp的后面
            if (temp.next!=null){
                temp.next.pre = heroNode;
                heroNode.pre = temp;
            }
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点的信息, 根据编号来修改, 即no编号不能改
    public void update(DoubleHeroNode newHeroNode){
        //判断是否为空
        if(head.next==null){
            System.out.println("链表为空~");
            return;
        }
        //找到需要修改的结点, 根据no编号
        //定义一个辅助变量
        DoubleHeroNode 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.println("没有找到编号为"+newHeroNode.no+"的节点");
        }
    }

    //删除一个节点
    //对于双向链表我们可以找到要删除的节点
    //找到后自我删除
    public void delete(int no){

        if (head.next==null){
            System.out.println("链表为空无法删除");
        }
        DoubleHeroNode temp = head.next;
        boolean flag = false;//是否找到待删除的结点
        while (true){
            if (temp==null){
                break;
            }else 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.println("要删除的节点不存在");
        }
    }

    //显示链表: 遍历
    //通过辅助变量来遍历
    public void list(){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动, 因此我们需要一个辅助变量来遍历
        DoubleHeroNode temp = head.next;
        while (true){
            //判断是否到链表的最后
            if (temp==null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }


}
//定义HeroNode, 每个HeroNode 对象就是一个节点
class DoubleHeroNode{
    public int no;  //编号
    public String name;   //名字
    public String nickname;    //昵称
    public DoubleHeroNode next;
    public DoubleHeroNode pre;

    //构造器
    public DoubleHeroNode(int No, String Name, String Nickname){
        this.no = No;
        this.name = Name;
        this.nickname = Nickname;
    }



    @Override
    public String toString() {
        return "HeroNode{" +
                "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开始计数，直到最后一个结点从链表中删除算法结束。 

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

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

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

遍历环形链表

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

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

public class Josepfu {

    public static void main(String[] args) {
        // 测试一把看看构建环形链表，和遍历是否ok
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(125);// 加入5个小孩节点
        circleSingleLinkedList.showBoy();

        //测试一把小孩出圈是否正确
        circleSingleLinkedList.countBoy(10, 20, 125); // 2->4->1->5->3
        //String str = "7*2*2-5+1-5+3-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;
    }

}

1128bei
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现链表
09-24
链表是一种物理存储单元上非连续、非顺序的存储结构。 java代码实现单链表，插入，删除和遍历等功能。 链表能够灵活的进行插入和删除操作，时间复杂度为O（1）,链表的查找时间复杂度为O（n）。
Java中链表的实现(超详细)
m0_74000148的博客
05-24 3075
在这个示例中，我们创建了一个。在Java中，链表可以通过。 在这个示例中，我们创建了一个 LinkedList 类，它包含一个 Node 类和一些方法来操作链表。我们可以使用 push() 方法在链表的头部插入节点，使用 insertAfter() 方法在链表中间插入节点，使用 append() 方法在链表尾部插入节点，使用 deleteNode() 方法删除链表中的给定节点，并使用 printList() 方法打印链表。
Java链表数据结构原理与使用教程
最新发布
My_wife_QBL的博客
03-05 370
链表作为一种基础的数据结构，在Java中有着广泛的应用。它代表了一系列元素的集合，每个元素都指向下一个，形成一个链。在Java中，链表主要通过LinkedList类实现，而了解其原理和使用规范是提高编程能力的关键。
数据结构之链表(java语言实现)
LNsupermali的博客
12-28 2645
数据结构之链表(java语言实现)
数据结构——单链表（Java实现）
m0_52861211的博客
03-26 1810
单链表增删改查，排序，反转，倒序打印，两条单链表合并
JAVA实现链表面试题
09-03
主要介绍了JAVA相关实现链表的面试题，代码实现非常详细，每一个方法讲解也很到位，特别适合参加Java面试的朋友阅读。
java实现链表操作
10-24
用java实现了数据结构中的链表，作为新手学习数据结构和java的资料。
java实现链表增删改查
01-07
用java实现链表增删改查
LinkedList:使用 Java 实现链表
06-13
链表 使用 Java 实现链表
Java中的链表实现介绍
cnds123的专栏
02-18 1526
Java中的链表实现介绍。本文仅以单链表为例介绍。采用两种方式实现：一、使用Java.util 包的LinkedList类实现；二、自定义实现类实现。
花10分钟用Java来自己实现链表吧（图解）
java.util.Man的博客
09-23 1143
先声明：我比较懒，所以没有画图，不理解代码的请自行百度或者查看相关书籍???? 链表是最常用的一种数据结构，作为线性表的一种，与数组相比，链表在插入修改操作多的环境中有着非常大的优势。下面我们用Java实现一个完整的链表。 链表是有多个节点构成的，每个节点应当包含 数据域（用来存放数据）和 next指针（Java中是下一个节点的引用）两部分。 同时需要提供以下操作链表的方法： 初始化链表 判断链表是否为空 清空链表 获取第i个位置的元素 根据对应的值查找元素的位置 插入新元素（头插法和尾插法） 删除元素
超详细！java实现链表
qq_63255075的博客
03-05 388
小白用的java链表
数据结构-单链表（Java实现，通俗易懂）
m0_62468521的博客
12-08 1085
单链表（Java实现，通俗易懂）
自己实现链表的基本操作方法（详细）（Java实现）
AwwzJ_0821的博客
10-19 2454
因为链表类也实现了线性表接口的方法，所以链表的基本操作方法和顺序表一样。这里我们定义链表中的元素类型为包装类（体现对象的形式而不是基本类型）这里提前定义了 MyNode 类，其中的属性为：Long val；三个属性，一个元素值 val ，一个指向前一个结点的引用 prev，一个指向后一个结点的引用 next。在 MyLinkedList 类（自定义链表类）中实现自定义基本方法，其中包括属性 MyNode head；int size；
数据结构之实现单链表(Java实现)
weixin_47851265的博客
12-22 3102
数据结构之单链表的实现
java中链表如何实现_java如何实现链表
weixin_42365141的博客
02-24 1711
展开全部链表是一种重要的数据结构，在程序设计中占有很32313133353236313431303231363533e59b9ee7ad9431333330343832重要的地位。C语言和C＋＋语言中是用指针来实现链表结构的，由于Java语言不提供指针，所以有人认为在Java语言中不能实现链表，其实不然，Java语言比C和C＋＋更容易实现链表结构。Java语言中的对象引用实际上是一个指针(本文中的...
Java实现链表数据结构
10-09
Java实现链表数据结构可以通过创建一个Node类和一个LinkedList类来实现。下面是一个简单的示例代码： ```java // Node类表示链表中的节点 class Node { int data; Node next; public Node(int data) { this.data = data; this.next = null; } } // LinkedList类表示链表 class LinkedList { Node head; public LinkedList() { this.head = null; } // 在链表末尾添加一个节点 public void add(int data) { Node newNode = new Node(data); if (head == null) { head = newNode; } else { Node current = head; while (current.next != null) { current = current.next; } current.next = newNode; } } // 打印链表中的所有节点 public void display() { Node current = head; while (current != null) { System.out.print(current.data + " "); current = current.next; } System.out.println(); } } // 测试链表的实现 public class Main { public static void main(String[] args) { LinkedList list = new LinkedList(); list.add(1); list.add(2); list.add(3); list.display(); } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值