第四章、链表(单链表、双链表、约瑟夫问题)

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

单链表 双链表 约瑟夫问题 数据结构 算法
关键词由CSDN通过智能技术生成

文章目录

单链表

节点定义

public class HeroNode {
    public int no; //序号
    public String name;
    public String nickName;
    public HeroNode next;

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

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

单链表

public class SingleLinkedList {
    private HeroNode head = new HeroNode(0, "", "", null);

    public HeroNode getHead() {
        return head;
    }

    //添加元素
    public void add(HeroNode heroNode){
        HeroNode temp = head;

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

        temp.next = heroNode;
    }

    //显示元素
    public void show(){
        if (head.next == null){
            System.out.println("单链表为空");
        }

        HeroNode temp = head.next;
        while (temp != null){
            System.out.println(temp);
            temp = temp.next;
        }
    }

    //按照顺序添加元素
    public void addByOrder(HeroNode heroNode){
        HeroNode temp = head;
        while (temp.next != null){
            if (temp.next.no > heroNode.no){
                break;
            } else if (temp.next.no == heroNode.no) {
                System.out.println("编号" + heroNode.no + "已经存在，添加失败");
                return;
            }

            temp = temp.next;
        }

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

    //根据编号no修改单链表中的元素
    public void update(HeroNode heroNode){
        HeroNode temp = head.next;
        if (temp == null){
            System.out.println("单链表为空，修改失败");
            return;
        }

        while (temp != null){
            if (temp.no == heroNode.no)
                break;
            else
                temp = temp.next;
        }
        if (temp == null) {
            System.out.println("没有找到编号为：" + heroNode.no + "的元素");
            return;
        }
        else{
            temp.name = heroNode.name;
            temp.nickName = heroNode.nickName;
        }
    }

    //删除节点
    public void delete(HeroNode heroNode){
        HeroNode temp = head;
        if (temp.next == null){
            System.out.println("单链表为空，删除失败");
            return;
        }

        while (temp.next != null){
            if (temp.next.no == heroNode.no)
                break;
            else
                temp = temp.next;
        }

        if (temp.next == null){
            System.out.println("没找到编号为：" + heroNode.no + "的元素，删除失败");
            return;
        }else
            temp.next = temp.next.next;
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        //创立单链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

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

        //添加节点
//        singleLinkedList.add(hero1);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);
//        singleLinkedList.add(hero4);

        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);

        singleLinkedList.show();
        System.out.println();

        //删除节点
        //HeroNode newhero = new HeroNode(2, "小卢", "玉麒麟。。", null);
        //singleLinkedList.update(newhero);
        HeroNode newhero = new HeroNode(2, "卢俊义", "玉麒麟", null);
        singleLinkedList.delete(newhero);


        singleLinkedList.show();

        //查找元素个数
        System.out.println();
        System.out.println("单链表的节点个数 = " + getlenth(singleLinkedList.getHead()));

        //查找倒数第k个元素
        System.out.println();
        int Index = 4;
        HeroNode indexNode = findLastIndexNode(singleLinkedList.getHead(), Index);
        System.out.println(indexNode);
        if (indexNode == null)
            System.out.println("没有找到倒数第：" + Index + "个元素");
        else {
            System.out.println("倒数第：" + Index + "个元素为：");
            System.out.println(indexNode);
        }

        //反转单链表
        System.out.println();
        reverse(singleLinkedList.getHead());
        singleLinkedList.show();

        //逆序打印
        System.out.println();
        reversePrint(singleLinkedList.getHead());

        //合并两个单链表
        System.out.println();
        SingleLinkedList s1 = new SingleLinkedList();
        HeroNode h1 = new HeroNode(1, "孙悟空", "小孙", null);
        HeroNode h3 = new HeroNode(3, "猪八戒", "小猪", null);
        s1.addByOrder(h1);
        s1.addByOrder(h3);

        System.out.println();
        SingleLinkedList s2 = new SingleLinkedList();
        HeroNode h2 = new HeroNode(2, "唐僧", "小唐", null);
        HeroNode h4 = new HeroNode(4, "沙悟净", "小沙", null);
        s2.addByOrder(h2);
        s2.addByOrder(h4);

        merge(s1.getHead(), s2.getHead());
        s1.show();

    }

    //合并两个有序的单链表，合并后仍然有序
    public static void merge(HeroNode head1, HeroNode head2){
        HeroNode head3 = new HeroNode(0, "", "", null);
        HeroNode temp1 = head1.next;
        HeroNode temp2 = head2.next;
        HeroNode temp3 = head3;

        while (temp1 != null && temp2 != null){
            if (temp1.no <= temp2.no){
                head1.next = temp1.next;
                temp3.next = temp1;
                temp3 = temp1;
                temp1 = head1.next;
            }else {
                head2.next = temp2.next;
                temp3.next = temp2;
                temp3 = temp2;
                temp2 = head2.next;
            }
        }

        if (temp1 != null)
            temp3.next = temp1;

        if (temp2 != null)
            temp3.next = temp2;

        head1.next = head3.next;
    }

    //实现逆序打印
    public static void reversePrint(HeroNode head){
        if (head == null){
            System.out.println("单链表为空，不能打印");
            return;
        }

        Stack<HeroNode> stack = new Stack<>();
        HeroNode temp = head.next;
        while (temp != null){
            stack.push(temp);
            temp = temp.next;
        }

        while (stack.size() > 0)
            System.out.println(stack.pop());
    }


    //单链表的反转
    public static void reverse(HeroNode head){
        if (head.next == null || head.next.next == null)
            return;

        HeroNode reverseHead = new HeroNode(0, "", "", null);
        HeroNode temp = head.next;
        while (temp != null){
            head.next = temp.next;
            temp.next = reverseHead.next;
            reverseHead.next = temp;
            temp = head.next;
        }

        head.next = reverseHead.next;
    }

    /**
     * 方法：查找倒数第k个节点
     * @param head 头结点
     * @param Index 倒数第Index个节点的索引
     * @return
     */
    public static HeroNode findLastIndexNode(HeroNode head, int Index){
        int num = getlenth(head);
        if (num < Index)
            return null;
        HeroNode temp = head.next;
        for (int i = 0; i < (num - Index); i++) {
            temp = temp.next;
        }
        return temp;
    }

    /**
     * 方法：求单链表中元素个数
     * @param head 头结点
     * @return
     */
    public static int getlenth(HeroNode head){
        if (head.next == null)
            return 0;

        HeroNode temp = head.next;
        int length = 0;
        while (temp != null){
            length++;
            temp = temp.next;
        }
        return length;
    }
}

双链表

节点定义

public class HeroNode {
    public int no; //序号
    public String name;
    public String nickName;
    public HeroNode next;
    public HeroNode pre;

    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 + '\'' +
                '}';
    }
}

双链表

public class DoubleLinkedList {
    private HeroNode head = new HeroNode(0, "", "");

    public HeroNode getHead() {
        return head;
    }

    //按照编号添加元素
    public void addByNo(HeroNode heroNode) {
        HeroNode temp = head;
        while (temp.next != null) {
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                System.out.println("编号" + heroNode.no + "已经存在，添加失败");
                return;
            }

            temp = temp.next;
        }

        heroNode.next = temp.next;
        if (temp.next != null)
            temp.next.pre = heroNode;
        heroNode.pre = temp;
        temp.next = heroNode;
    }

    //删除元素
    public void delete(HeroNode heroNode) {
        HeroNode temp = head.next;
        if (temp == null) {
            System.out.println("双链表为空，删除失败");
            return;
        }

        while (temp != null) {
            if (temp.no == heroNode.no)
                break;
            else
                temp = temp.next;
        }

        if (temp == null) {
            System.out.println("没找到编号为：" + heroNode.no + "的元素，删除失败");
            return;
        } else {
            temp.pre.next = temp.next;
            if (temp.next != null)
                temp.next.pre = temp.pre;
        }
    }

    //修改元素
    public void update(HeroNode heroNode) {
        HeroNode temp = head.next;
        if (temp == null) {
            System.out.println("双链表为空，修改失败");
            return;
        }

        while (temp != null) {
            if (temp.no == heroNode.no)
                break;
            else
                temp = temp.next;
        }
        if (temp == null) {
            System.out.println("没有找到编号为：" + heroNode.no + "的元素");
            return;
        } else {
            temp.name = heroNode.name;
            temp.nickName = heroNode.nickName;
        }
    }

    //在链表末尾添加元素
    public void add(HeroNode heroNode) {
        HeroNode temp = head;

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

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

    //遍历
    public void show() {
        if (head.next == null) {
            System.out.println("双链表为空");
        }

        HeroNode temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        //创立单链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero5 = new HeroNode(5, "林冲", "豹子头");

        //添加节点
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero5);
        doubleLinkedList.show();

        //修改节点
//        System.out.println();
//        HeroNode newhero = new HeroNode(2, "小卢", "玉麒麟。。");
//        doubleLinkedList.update(newhero);
//        doubleLinkedList.show();

        //删除节点
//        System.out.println();
//        HeroNode newhero = new HeroNode(2, "卢俊义", "玉麒麟");
//        doubleLinkedList.delete(newhero);
//        doubleLinkedList.show();

        //按照编号添加元素
        System.out.println();
        HeroNode hero4 = new HeroNode(4, "沙悟净", "小沙");
        HeroNode hero6 = new HeroNode(6, "哪吒", "小喳");
        doubleLinkedList.addByNo(hero4);
        doubleLinkedList.addByNo(hero6);
        doubleLinkedList.show();


    }
}

约瑟夫问题（循环单链表）

  • 设编号为1， 2， …n的n个人围坐一圈，num个人从编号startNum开始报数，数到countNum的那个人出列，他的下一位又从1开始报数，数到countNum的那个人又出列，一次类推，知道所有人出列为止，由此产生一个出队编号的序列

小孩类

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

循环单链表

public class CircleSingleLinkedList {
    private Boy first = null;

    /**
     *
     * @param startNo 开始的小孩的编号
     * @param countNum 每次跳过的次数
     * @param num 最初的小孩数目
     */
    //出圈
    public void countBoy(int startNo, int countNum, int num){
        if (first == null || startNo < 1 || startNo > num){
            System.out.println("数据不合理，请重新输入");
            return;
        }

        Boy temp = first;
        while (temp.getNext() != first)
            temp = temp.getNext();

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

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

            System.out.println("小孩：" + first.getNo() + "出圈");
            first = first.getNext();
            temp.setNext(first);
        }

        System.out.println("小孩：" + first.getNo() + "获得胜利");
    }

    //添加节点
    public void addBoy(int num){
        if (num < 1){
            System.out.println("num数据不合理");
            return;
        }

        Boy temp = new Boy(0);
        for (int i = 1; i <= num; i++) {
            Boy boy = new Boy(i);
            if (i == 1){
                first = boy;
                first.setNext(first);
                temp = first;
            }else{
                temp.setNext(boy);
                boy.setNext(first);
                temp = boy;
            }
        }
    }

    //遍历链表
    public void show(){
        if (first == null)
            System.out.println("链表为空");

        Boy temp = first;
        while (true){
            System.out.println("小孩编号为：" + temp.getNo());
            if (temp.getNext() == first)
                break;
            temp = temp.getNext();
        }
    }
}

测试类

public class test {
    public static void main(String[] args) {
        CircleSingleLinkedList c = new CircleSingleLinkedList();
        c.addBoy(5);
        c.show();

        c.countBoy(1, 2, 5);
    }
}
数二150种子选手
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表和双链表
SHUIHAN_007的博客
04-06 2915
单链表 链表是有序的列表，但是它在内存中的存储如下： 链表是以节点的方式来存储, 是链式存储 每个节点包含 data 域（存储数据），next 域（指向下一个节点） 链表的各个节点不一定是连续存储 链表分为带头节点的链表和 没有头节点的链表，根据实际的需求来确定 单链表的应用实例 使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作， 注: 删除和修改,查找 可以考虑学员独立完成，也可带学员完成 1) 第一种方法在添加英雄时，直接添加到链表的尾部 第二种方式在添加英
数据结构：单链表和双向链表
Jocab_jl的博客
03-12 2663
1、链表 链表是有序的列表，但是它在内存中是存储如下 小结： 链表是以节点的方，来存储是链式存储 每个节点包含data域，next域：指向下一个节点 如图：发现链表的各个节点不一定是连续存储 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点)逻辑结构示意图如下 2、单链表的应用 使用带head头的单向链表实现-水浒英雄排行榜管理完成对英雄人物的増删改査操作， 第一种方法在添加英雄时，直接添加到链表的尾部 第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果
【数据结构与算法】 01 链表 （单链表、双向链表、循环链表、块状链表、头结点、链表反转与排序、约瑟夫环问题）
热门推荐
风高秋月白，雨霁晚霞红
06-07 1万+
单链表、双向链表、循环链表、块状链表、头结点、链表反转与排序、约瑟夫环问题
数据结构与算法(四)——双向链表，环形链表(约瑟夫环问题)
菜鸟的博客
04-11 783
双向链表 构成 双向链表的每一个节点都由三部分构成： 前置节点指针pre 数据data 后置节点指针next 单向链表和双向链表对比 单向链表查找的方向只能是一个方向，而双向链表可以向前和向后查找 单向链表不能进行自我删除，需要依靠辅助节点。而双向链表，可以进行自我删除（正是因为单链表不能自我删除，所以删除节点时要找到待删除节点的前一个节点） 双向链表逻辑结构示意 代码实现 /*** * 双向链表 * * @author laowa * */ class DoubleLinkedLis
03 单链表、双向链表、循环链表(约瑟夫环问题)及代码实现
朱古力的博客
05-10 394
链表 1. 链表介绍 内存中的存储方式： 链表是以节点的方式来存储,是链式存储 。 每个节点包含 data 域， next 域：指向下一个节点。 如图：发现链表的各个节点不一定是连续存储。 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。 单链表(带头结点) 逻辑结构示意图如下： 2. 单链表的实现 节点定义： /** * 英雄节点类 */ class HeroNode { public int no; public String name; p
链表（单链表、双链表、单向环形链表）
weixin_52347460的博客
06-17 904
Josephu问题为：设编号为1,2，...n的n个人围坐一圈，约定编号为k（1
数据结构——链表&用单项链表解决约瑟夫问题
祖国栋梁一的博客
08-29 813
数据结构——链表&用单项链表解决约瑟夫问题
单向链表，双向链表及环形列表解决约瑟夫问题
学习笔记
01-17 254
下面的代码包括了单向链表的逆序打印 和将链表逆序,即将链表中的节点逆序连接 节点的插入(order by) 节点的删除 单链表的反转 逆序打印 利用栈的数据结构特点,遍历链表,将每个节点压入链表中,然后逐个弹出打印 package com.whb.linkedlisk; import java.util.Stack; public class SingleLinkedListDemo { public static void main(String[] args) {
数据结构与算法——Java实现单链表、双向链表、环型链表、约瑟夫
weixin_51351637的博客
12-13 766
我们看下面的图示如下图链表是以节点的方法来存储，是链式存储每个节点包含data域（存放数据），next域（指向下一个节点）链表各个节点不一定是连续存储的链表分带头节点的链表（头结点不存放数据）和不带头结点的链表，根据实际需求来确定下图是带头节点的链表，其中每一个白色的矩形就是一个节点。
约瑟夫问题-基于java+双链表实现的约瑟夫问题题解.zip
02-11
在提供的代码实现中，`约瑟夫问题_基于java+双链表实现的约瑟夫问题题解`这个文件很可能是包含了解决约瑟夫问题的Java源代码。这个文件可能包括一个主类，用于设置初始参数（如人数和报数间隔），以及一个辅助类来...
深入解析C++的循环链表与双向链表设计的API实现
09-02
循环链表是单链表的一种变体，它的最后一个节点指向链表的第一个节点，形成了一个逻辑上的环。双向链表则在每个节点中包含两个指针，分别指向其前一个和后一个节点，使得双向操作更为便捷。 循环链表的API设计通常...
链表，单链表，双向（单向）循环链表
AiTTTTTT的博客
01-16 1586
动态链表 单链表： // 头结点是指链表中的第一个结点，有真实头结点和虚拟头结点之分； （1）真实头结点：其第一个结点用于存储数据（一般使用真实头结点）。 （2）虚拟头结点：其第一个结点不许存储数据。 （3）头指针：仅仅是一个引用变量，存储头结点地址的指针而已，无前驱结点，有后继。 （4）尾指针：同头指针，不过是链表中最后一个结点的指针而已,尾部指向null，有前驱无后继。 向单链表添加元素： 元素2中存有元素3的地址，将元素二中存放的地址给新元素，让新元素指向元素3，再把新元素的地址传存放在元素2中，
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）
yzc的博客
09-05 915
详解了推有关的两个面试题：堆排序，TopK问题
栈的内容..
最新发布
2301_79724394的博客
09-09 96
持续更新，小手动一动，点个关注，谢谢！
数据结构之红黑树的 “奥秘“
robin_suli的博客
09-09 584
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
[数据结构] 开散列法 && 闭散列法 模拟实现哈希结构（一）
水墨不写bug
09-09 821
[数据结构] 开散列法 && 闭散列法 模拟实现哈希结构
【数据结构】基本概念和术语
Sakura_ding的博客
09-09 706
是指一个数学模型以及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关，即不论其内部结构如何变化，只要它的数学特性不变，都不影响其外部的使用。抽象数据类型和数据类型实质上是一个概念。“抽象”的意义在于数据类型的数学抽象特性。抽象数据类型的定义由一个值域和定义在该值域上的一组操作组成。若按其值的不同特性，可细分为下列三种类型：原子类型 (atomic data type)属原子类型的变量的值是不可分解的。
数据结构 栈 队列
qq_69971969的博客
09-06 599
数据的插入--->入栈 数据的删除----->出栈。函数的调用关系（保护现场，恢复现场操作，遵循先进后出，后进先出）缓存数据：主要使用队列，类似于缓冲区，防止数据丢失。允许从一端插入数据，另一端删除数据的线性存储结构。只允许从一端进行数据的插入和删除的线性存储结构。增栈 减栈：用栈顶的增长方向区分（移动方向）顺序队列：假溢出------>循环队列。满栈 空栈：栈顶所在位置是否存有元素。增栈：从内存低地址向高地址移动。减栈：从内存高地址向低地址移动。链式队列：用链表方式构造队列。
Java实现单链表与双向链表详解及代码示例
本篇文章主要介绍了如何使用Java编程语言实现单链表和双向链表的数据结构。单链表是一种线性数据结构，每个节点包含一个数据元素和一个指向下一个节点的引用，而双向链表则在单链表的基础上增加了指向前一个节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值