链表(单链表，双向链表，单向环形链表)_java实现

最新推荐文章于 2022-04-06 23:55:03 发布
最新推荐文章于 2022-04-06 23:55:03 发布
阅读量93 收藏
点赞数 1
分类专栏： java 学习 文章标签： 链表 java 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangan_/article/details/116431464
版权
学习 同时被 2 个专栏收录
31 篇文章 0 订阅
订阅专栏
java
25 篇文章 0 订阅
订阅专栏

链表

单链表

在这里插入图片描述

在这里插入图片描述

  1. 不考虑排名，直接往最后一个位置插入元素

    package com.zhangan.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(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);

        //展示
        singleLinkedList.list();

    }
}

//定义一个SingleLinkedList  管理
class SingleLinkedList {

    //初始化一个头节点
    private HeroNode head = new HeroNode(0, "", "");

    //添加节点到单向链表
    //1。找到当前链表的最后节点
    //2。将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode) {

        //头节点不能动  需要一个辅助变量来遍历链表
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true) {
            //找到了最后一个节点
            if (temp.next == null) {
                break;
            }
            //如果不是最后一个节点  temp后移
            temp = temp.next;
        }
        //循环结束，temp指向链表最后
        temp.next = heroNode;
    }


    //展示链表
    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.toString());
            temp = temp.next;
        }
    }
}


//定义一个节点
class HeroNode {

    public int no;
    public String name;
    public String nickname;
    public HeroNode next; //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 +
                '}';
    }
}

  2. 根据排名添加

     //根据英雄的排名  添加到指定位置
    public void addByOrder(HeroNode heroNode) {
        //辅助变量来找合适的添加的位置
        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;//后移
        }

        if (flag) {
            System.out.println("准备插入的英雄编号已经存在了");
        } else {
            //插入链表  temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;

        }

    }

  3. 根据编号修改

        //修改节点的信息  根据编号no来修改
    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.println("没有该英雄");
        }

    }

  4. 删除指定节点

        //删除指定节点
    public void delete(Integer id) {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("空链表，无值");
            return;
        }
        HeroNode temp = head;
        boolean flag = false;//是否找到要删除的节点
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == id) {
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag) {
            temp.next = temp.next.next;

        } else {
            System.out.println("没有该英雄");
        }
    }
双向链表

在这里插入图片描述

代码实现：

package com.zhangan.linkedlist;


//创建双向链表的节点
class Node {

    public int no;
    public String name;
    public String nickname;
    public Node next;//指向下一个节点
    public Node pre;//指向前一个结点

    public Node(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

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


class DoubleLinkedList {

    //初始化 头节点
    private Node head = new Node(0, "", "");

    public Node getHead() {
        return head;
    }

    //判断链表是否为空
    public boolean isEmpty() {
        return head.next == null;
    }

    //遍历链表
    public void list() {

        if (isEmpty()) {
            System.out.println("链表为空");
            return;
        }
        Node temp = head.next;
        while (temp != null) {
            System.out.println(temp.toString());
            temp = temp.next;
        }
    }

    //添加节点
    public void add(Node node) {
        Node temp = head;

        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = node;
        node.pre = temp;

    }

    //修改节点
    public void update(Node node) {
        if (isEmpty()) {
            System.out.println("链表为空");
            return;
        }

        Node temp = head.next;
        boolean flag = false;
        while (temp != null) {

            if (temp.no == node.no) {
                flag = true;
                break;
            }

            temp = temp.next;
        }
        if (flag) {
            temp.name = node.name;
            temp.nickname = node.nickname;
        } else {
            System.out.println("没有该数据");
        }
    }

    //删除节点
    public void delete(Integer id) {

        if (isEmpty()) {
            System.out.println("链表为空");
            return;
        }

        Node temp = head.next;
        boolean flag = false;//是否找到要删除的节点
        while (temp != null) {

            if (temp.no == id) {
                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 addByOrder(Node node) {

        Node temp = head;
        boolean flag = false;//添加的编号是否存在
        while (temp.next != null) {

            if (temp.next.no > node.no) {
                break;
            }
            if (temp.next.no == node.no) {
                flag = true;
                break;
            }

            temp = temp.next;
        }
        if (flag) {
            System.out.println("该编号存在:" + node.no);

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

    }
}

public class DoubleLinkedListDemo {


    public static void main(String[] args) {

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

        Node node1 = new Node(1, "name1", "111");
        Node node2 = new Node(2, "name2", "222");
        Node node3 = new Node(3, "name3", "333");
        Node node4 = new Node(4, "name4", "444");
        Node node5 = new Node(5, "name5", "555");

        doubleLinkedList.addByOrder(node5);
        doubleLinkedList.addByOrder(node4);
        doubleLinkedList.addByOrder(node3);
        doubleLinkedList.addByOrder(node2);
        doubleLinkedList.addByOrder(node1);

        doubleLinkedList.list();
        System.out.println("---------------------------");

        //测试修改
//        Node node5update = new Node(5, "name5修改", "555修改");
//        doubleLinkedList.update(node5update);
//        doubleLinkedList.list();

        //测试删除
//        doubleLinkedList.delete(2);
//        doubleLinkedList.list();

    }

}
单向环形链表

在这里插入图片描述

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

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

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

遍历环形链表

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

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

出圈思路：

1.需求创建一个辅助指针 helper ,事先应该指向环形链表的最后这个节点.
2.当小孩报数时，i让first和helper指针同时的移动m -1次

3．这时就可以将first指向的小孩节点出圈
first = first. Next
helper.next =first
原来first指向的节点就没有任何引用，就会被回收

代码部分：

package com.zhangan.linkedlist;

//创建一个boy  表示一个节点
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;
    }
}

//单向环形链表
class CircleSingleLinkedList {

    //创建一个first 节点
    private Boy first = null;

    //添加小孩节点  构建成环形链表
    public void addBoy(int 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; //curBoy指向第一个小孩
            } else {
                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.println("小孩的编号：" + curBoy.getNo());

            if (curBoy.getNext() == first) {//已经遍历完成
                break;
            }
            curBoy = curBoy.getNext();
        }


    }


    //根据用户输入 计算小孩出圈的顺序
    /**
     * @param startNo  第几个小孩开始数数
     * @param countNum 数几下
     * @param nums     共有多少小孩
     */
    public void outBoy(int startNo, int countNum, int nums) {

        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数有误");
            return;
        }

        Boy helper = first;
        while (true) {
            if (helper.getNext() == first) {//说明helper指向最后一个小孩节点
                break;
            }
            helper = helper.getNext();
        }

        //第几个小孩报数 first移动到该小孩 helper紧随其后
        for (int i = 0; i < startNo - 1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }

        //当小孩报数时,让first和helper指针同时的移动countNum-1次，然后出圈
        while (true) {
            if (helper == first) {//圈里只有一个人了
                break;
            }

            for (int i = 0; i < countNum - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }

            //此时first指向的节点就是要出圈的小孩
            System.out.println("小孩" + first.getNo() + "出圈");

            first = first.getNext();
            helper.setNext(first);
        }

        System.out.println("最后留在圈中的小孩是" + first.getNo());

    }


}


public class Josephus {

    public static void main(String[] args) {


        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();

        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.list();
        System.out.println("-------------------------------");


        circleSingleLinkedList.outBoy(1,2,5);
    }


}
zhang'an
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
约瑟夫问题(单向环形链表 )
qq_43783527的博客
03-14 181
约瑟夫问题的示意图  Josephu 问题 Josephu 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此 产生一个出队编号的序列。 提示 用一个不带头结点的循环链表来处理 Josephu 问题：...
单向环形链表（Josephu的java实现方式)
qq_41291067的博客
10-22 271
Josephu问题简述： Josephu问题为：设编号为1，2，… n的n个人围坐一圈，约定编号k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。（n = 5 , 即有5个人 ；k = 1, 从第一个人开始报数；m = 2, 数2下） 分析： 用一个不带头结点的循环链表来...
java模拟单向环形链表
sakuragio的博客
10-10 163
约瑟夫环问题 设编号为1-n的n个人围坐一圈，约定编号为k（1 <= k <= n）的人从1开始报数，数到m的那个人出列，他的下一位又从1开始报数，数到m的那个人出列，以此类推，产生一个出对编号的序列 使用单向环形链表 构建一个单向环形链表： 先创建一个节点，让first指向该节点，并形成环形 添加一个新节点，就把该节点加入到已有的环形链表中即可 遍历环形链表： 先让一个辅助指针变量c...
java单项环形链表
qq_61630897的博客
12-26 447
Josephu（约瑟夫环，约瑟夫）问题 在学习环形链表之前我们先了解一下约瑟夫问题，设编号为1，2，3……n。的n个人围坐一圈约定编号为k（1<=k<=n）的人从1开始报数，当数到m的那个人出列，后一个人在从1开始报数，以此类推直到最后移入出列。由此产生一个出列编号顺序。 提示：用一个不带头结点的循环链表来处理约瑟夫问题，先构成一个有n个节点的单循环链表，然后由k从1开始计数，到m时，对应的节点从链表中移除，然后被删除的节点的后一位又从1开始报数，直到最后一个节点。 ...
Java解决约瑟夫问题（单向环形链表）
LRC1062702315的博客
01-14 204
约瑟夫问题： n个人围坐一圈，约定编号为k 的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。 单向环形链表： 在单向链表的基础上将首尾连接，形成环形单向链表 思路 单向环形链表 1.创建第一个节点时，next指向本身 2.后面添加节点时，每次都要进行两次连接 Joseph问题 每次找到一个节点后，需要该节点的上一个节点和下一个节点，因此在方法内部要有两个指针，分别指向取出节点的上下两个节点 代码实现
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
doublelink.zip_DoubleLink java_双向链表实现
最新发布
09-24
在本文中，我们将深入探讨如何使用Java编程语言实现一个高效的双向链表数据结构，并通过测试用例进行验证。首先，让我们了解双向链表的基本概念。 双向链表是一种线性数据结构，其中每个节点包含两个指针，分别指向...
java实现单链表、双向链表
09-02
以上就是Java中单链表和双向链表的基本实现和操作。这些基础数据结构在许多实际编程问题中都有应用，例如在实现LRU缓存策略、模拟队列和栈等高级数据结构时。理解并熟练掌握链表是提升编程技能的重要一步。
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
单链表_单向链表的类模板_
10-03
单向链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C++中，我们可以使用类模板来创建一个通用的单向链表，以便存储不同类型的数据。下面我们将详细探讨如何设计这样一...
java实现单向循环链表_单向循环链表常用方法代码实现 | 梦溪博客
weixin_35143455的博客
02-25 513
什么是单向循环链表？将单链表中终端节点的指针端由空指针改为指向头节点，就使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表，简称循环链表。如下图所示：从上图可以看出，其循环就是尾节点的next指针域指向头节点的元素位置，头与尾相连形成循环状。节点信息单向循环链表与单链表的结构类似，没有太大变化，如下代码：附上单向循环链表的一些必要的变量head 节点记录链表的头节点;size 记录链表的大...
约瑟夫问题 java实现单向环形链表解决
m0_59516050的博客
04-06 309
约瑟夫问题 单向环形链表
java单链表和双向链表的代码实现
weixin_43991380的博客
06-24 206
链表 单链表 package com.linkedlist; import com.sun.xml.internal.bind.util.Which; import java.util.WeakHashMap; public class SingleLinkedListDemo { public static void main(String[] args) { //测试 //先创建节点 HeroNode hero1 = new HeroNode
(java)链表中单链表、双向链表、单向环形链表的原理及例子代码
fjswcjswzy的博客
10-19 268
文章目录1 链表介绍 1 链表介绍 链表是以节点的方式来存储的，是链式存储 每个节点包含data域，next域：指向下一个节点 如下图，发现链表的各个节点不一定是连续存储的 链表分带头节点的链表和没有头节点的链表，根据实际需求来确定 ...
For环结构java_图解Java数据结构之环形链表
weixin_30025473的博客
02-16 144
本篇文章介绍数据结构中的环形链表。介绍环形链表，类似于单链表，也是一种链式存储结构，环形链表由单链表演化过来。单链表的最后一个结点的链域指向NULL，而环形链表的建立，不要专门的头结点，让最后一个结点的链域指向链表结点。 简单点说链表首位相连，组成环状数据结构。如下图结构：而在环形链表中，最为著名的即是约瑟夫环问题。约瑟夫环问题问题介绍：设编号为1、2、3、… 、n的n个人围坐一圈，约定编号为k(...
java 单向循环链表_单向循环链表（Java版）
weixin_33070823的博客
02-24 625
单向循环链表(Java版)单向循环链表(Java版)前面的文章中介绍到单链表，它的尾结点(最后一个结点)的指针域next都是指向null，如下图：单链表的指针域只存储了向后的指针，到了尾结点就无法继续向后的操作。本篇文章将介绍单向循环链表，它和单链表的区别在于结尾点的指针域不是指向null，而是指向头结点，形成首尾相连的环。这种首尾相连的单链表称为单向循环链表。循环链表可以从任意一个结点出发，访问...
链表 LinkedList 单向环形链表（约瑟夫环问题，使用java代码实现）
共勉
04-23 881
约瑟夫问题为:设编号为1, 2, . n的n个人围坐一圈，约定编号为k (1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生-个出队编号的序列。 n=5,即有5个人 k=1,从第一个人开始报数 m=2,数2下 如上图所示：出队列的顺序为 2 4 1 5 3 创建单链表，实现添加节点功能...
环形链表解决约瑟夫问题
或无言的博客
01-05 225
一.问题描述 设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。 提示：用一个不带头结点的循环链表来处理Josephu 问题：先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，...
数据结构_单向循环链表的java实现
叶清逸的博客
07-27 980
这篇文章讲述的是数据结构部分的单向循环链表的java实现，如有错误或者不当之处，还望各位大神批评指正。 单向循环链表的特点 物理结构不连续逻辑结构连续 删除和添加操作方便 顺序储存随数据量的增大而增大 查询操作不方便 从任意一个节点可以访问整个链表 单向循环链表的基本操作 init:初始化顺序表 destroy：销毁数据表 clear：清空数据表中的元素 length：获取数...
理解Linux内核：list_head双向链表解析
双向链表与单向链表相比，其优势在于可以从任一方向遍历，这使得在插入和删除操作上更加灵活。在Linux内核中，`list_head`被广泛应用于各种场景，例如在内存管理、进程调度、文件系统等模块中，用于组织和管理数据。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值