链表-备忘录

已于 2022-04-26 16:39:14 修改
阅读量144 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 链表
于 2022-04-12 10:24:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haowu8888/article/details/123648898
版权

跳转到总目录

文章目录

链表

链表是有序的列表，但是它在内存中是存储如下:
在这里插入图片描述
由上图小结:

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

单向链表

在这里插入图片描述
举例示范: 使用带head头的单向链表实现 –水浒英雄排行榜管理.
完成对英雄人物的增删改查操作.

示例图如下:
第一种方法在添加英雄时，直接添加到链表的尾部
在这里插入图片描述
第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)
在这里插入图片描述
链表删除
在这里插入图片描述
代码示例如下:

//写一个单链表类
class SingleLinkedList {
    //先初始化一个头结点 不存放数据
    private HeroNode head = new HeroNode(0, "", "");

    public HeroNode getHead() {
        return head;
    }


    //添加节点到单向链表 不考虑编号顺序
    public void add(HeroNode heroNode) {
        //因为头结点不能动 需要辅助节点temp遍历
        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = heroNode;
    }

    //通过编号顺序添加节点到单向链表
    public void addByOrder(HeroNode heroNode) {
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no) {
                break;
            }
            if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("编号%d重复\n", heroNode.no);
        } else {
            //重点 链表中间加入节点的写法
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点信息,根据no来修改,即no编号不能改
    public void update(HeroNode heroNode) {
        if (head.next == null) {
            System.out.println("空的");
            return;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = heroNode.name;
            temp.nickName = heroNode.nickName;
        } else {
            System.out.println("没有该编号的节点 无法修改");
        }
    }

    //删除节点
    public void delete(int no) {
        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 == no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.println("没有找到该编号 无法删除");
        }
    }

    //遍历显示
    public void show() {
        if (head.next == null) {
            System.out.println("空的");
            return;
        }
        HeroNode temp = head.next;
        while (true) {
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

//每一个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 + '\'' +
                '}';
    }
}

双向链表

管理单向链表的缺点分析:

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

示意图帮助理解删除
在这里插入图片描述
分析 双向链表的遍历，添加，修改，删除的操作思路===》代码实现

  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) {
        //双向链表测试
        HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
        HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
//        doubleLinkedList.add(hero1);
//        doubleLinkedList.add(hero2);
//        doubleLinkedList.add(hero3);
//        doubleLinkedList.add(hero4);

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


        doubleLinkedList.show();
        System.out.println("====================");

        //修改测试
//        HeroNode2 heroNode2 = new HeroNode2(4, "1", "11");
//        doubleLinkedList.update(heroNode2);
//        doubleLinkedList.show();
//        System.out.println("====================");

        //删除测试
//        doubleLinkedList.delete(4);
//        doubleLinkedList.show();
    }


}

class DoubleLinkedList {
    //先初始化一个头结点 不存放数据
    private HeroNode2 head = new HeroNode2(0, "", "");

    public HeroNode2 getHead() {
        return head;
    }

    //添加节点到双向链表 不考虑编号顺序
    public void add(HeroNode2 heroNode) {
        //因为头结点不能动 需要辅助节点temp遍历
        HeroNode2 temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    //通过编号顺序添加节点到双向链表
    public void addByOrder(HeroNode2 heroNode) {
        HeroNode2 temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no) {
                break;
            }
            if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("编号%d重复\n", heroNode.no);
        } else {
            if (temp.next == null) {
                temp.next = heroNode;
                heroNode.pre = temp;
            } else {
                heroNode.next = temp.next;
                temp.next.pre = heroNode;
                temp.next = heroNode;
                heroNode.pre = temp;
            }
        }
    }

    //修改双向链表节点信息,根据no来修改,即no编号不能改 与单项链表基本一样
    public void update(HeroNode2 heroNode) {
        if (head.next == null) {
            System.out.println("空的");
            return;
        }
        HeroNode2 temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = heroNode.name;
            temp.nickName = heroNode.nickName;
        } else {
            System.out.println("没有该编号的节点 无法修改");
        }
    }

    //双向链表删除节点
    public void delete(int no) {
        if (head.next == null) {
            System.out.println("空的");
            return;
        }
        HeroNode2 temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) { // 已经到链表最后
                break;
            }
            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 show() {
        if (head.next == null) {
            System.out.println("空的");
            return;
        }
        HeroNode2 temp = head.next;
        while (true) {
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

//每一个HeroNode2对象就是一个节点
class HeroNode2 {
    public int       no;
    public String    name;
    public String    nickName;
    public HeroNode2 next; //下一个节点
    public HeroNode2 pre; //上一个节点

    public HeroNode2(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 问题：先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。

思路图解:
在这里插入图片描述
在这里插入图片描述
代码示例:

//约瑟夫问题
public class Josephu {
    public static void main(String[] args) {
        //测试环形链表
        CirCleSingleLinkedList cirCleSingleLinkedList = new CirCleSingleLinkedList();
        cirCleSingleLinkedList.addBoy(5);
        cirCleSingleLinkedList.showBoy();

        //测试小孩出圈
        cirCleSingleLinkedList.conutBoy(1,2,5);
    }
}

class CirCleSingleLinkedList {
    //创建头节点,当前没有编号
    private Boy first= null;
    //添加子节点,构建环形链表
    public void addBoy(int nums){
        //nums 数据校验
        if (nums<1){
            System.out.println("编号的值不正确");
            return;
        }
        Boy curBoy =null;
        for (int i = 1; i <= nums; i++) {
            Boy boy = new Boy(i);
            if (i==1){
                first=boy;
                first.setNext(boy);
                curBoy=boy;
            }else {
                curBoy.setNext(boy);
                boy.setNext(first);
                curBoy=boy;
            }
        }
    }
    //遍历
    public void showBoy(){
        if (first==null){
            System.out.println("空的");
            return;
        }
        Boy temp=first;
        while (true){
            System.out.println("编号"+temp.getNo());
            if (temp.getNext()==first){
                break;
            }
            temp=temp.getNext();
        }
    }


    /**
     * 根据用户输入,计算出小孩出圈顺序
     * @param startNo 表示从第几个小孩开始数
     * @param countNum 表示数几下
     * @param nums 表示最初有多少小孩在圈中
     */
    public void conutBoy(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){
                break;
            }
            helper=helper.getNext();
        }
        //小孩报数前,先让first和helper移动startNo-1次
        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();
            }
            System.out.println("出圈的小孩编号:"+first.getNo());
            first=first.getNext();
            helper.setNext(first);
        }
        System.out.println("最后留在圈中的小孩编号"+first.getNo());
    }
}

//表示一个节点
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;
    }
}
虚火徉攻
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
工作备忘录的生成（链表）
遇见生活
03-13 5516
题目： 每天都要处理很多事务，为了更好地安排工作，希望在每天开始工作前，根据工作记录，生成工作备忘录。首先输入工作记录数（大于0的一个整数），再逐条输入各条工作记录，每条工作记录包括：工作名，开始时间，结束时间。假设每项工作的开始时间均小于它的结束时间，并且各项工作的开始时间互不相同。 我们的工作是需要把这些工作记录按开始时间排序并输出，在输出时，如果某项工作与若干项工作冲突（在做该项工作时，需要...
leetcode备忘录系统-LeetCode:力码
06-30
这些编号通常对应于LeetCode网站上的题目ID，按照编号顺序，我们可以推断出这个备忘录系统至少包括了近2000个编程挑战，覆盖了初级到高级的各种编程题目类型，如数组、字符串、链表、树、图、排序、搜索等。...
哈希表-备忘录
haowu8888的博客
05-30 107
跳转到总目录 文章目录哈希表基本介绍图解说明代码示例 哈希表 场景:要求不使用数据库,尽量节省内存,速度越快越好=>哈希表(散列) 基本介绍 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 图解说明 代码示例 /** * @author haowu * @create 2022-05-09-22:13 *
集合-备忘录
haowu8888的博客
02-07 579
跳转到总目录 文章目录集合-备忘录Collection集合List集合Set集合TreeSet类Map集合TreeMap类Properties类Collections类 集合-备忘录 Java 集合可分为Collection和Map两种体系. Collection接口：单列集合，用来储存一个一个的对象. List：存储有序的、可重复的集合. ArrayList,LinkedList,Vector Set：存储无序的、不可重复的集合. HashSet,LinkedHashSet,TreeSet
【设计模式】Java设计模式 - 备忘录模式
qq_43843951的博客
09-07 544
备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。
PTA 6-6 工作备忘录的生成（链表）
aillear的博客
05-01 1762
每天都要处理很多事务，为了更好地安排工作，希望在每天开始工作前，根据工作记录，生成工作备忘录。首先输入工作记录数（大于0的一个整数），再逐条输入各条工作记录，每条工作记录包括：工作名，开始时间，结束时间。假设每项工作的开始时间均小于它的结束时间，并且各项工作的开始时间互不相同。 我们的工作是需要把这些工作记录按开始时间排序并输出，在输出时，如果某项工作与若干项工作冲突（在做该项工作时，需要同时做其它工作），则在该工作名前加'*'。 函数接口定义： Node* add(Node *, Node *);
leetcode备忘录系统-Algorithms-DataStructures:算法-数据结构
06-30
leetcode备忘录系统算法-数据结构 两个不错的排序算法及其 Big-O（完成） 归并排序 快速排序 冒泡排序 基本数据结构实现及其 Big-O 复杂性 哈希图 堆 队列 双端队列双端队列 链表 反转链表 合并两个排序列表 回文...
个人备忘录
12-18
《个人备忘录系统设计与实现》 个人备忘录是一种高效管理日常生活和工作事务的工具，它通过图形用户界面（GUI）为用户提供便捷的操作体验，使得记事、管理、检索信息变得简单易行。本备忘录系统设计旨在帮助用户...
modelAndLink 责任链模式 备忘录模式 单（双）链表 链表 显示“请稍后……"原理
07-05
责任链模式 备忘录模式 单（双）链表 显示 "正在加载，请稍后……" 原理 1、责任链模式： * 责任连模式的结构 责任连模式的类图非常简单，它由一个抽象地处理类和它的一组实现类组成： * 抽象处理类：抽象处理类中...
数据结构之单向、双线链表
2301_78503818的博客
08-28 744
首先我们先定义链表节点的类型，以及里面包含的数据和存储下一个节点地址的指针，然后通过定义变量，使用malloc函数来申请一个头结点的空间，而后进行赋值操作即可完成对头结点的创建。链表大体可以分成有头链表（有头节点）和无头链表，今天主要记录一下单向链表和双线链表的一些基本操作。3.单向链表的遍历，寻找，删除，更改。6.链表的复杂操作（读者可酌情观看）链表空间的释放（链表的销毁）2.头插法插入链表节点。
【数据结构】—— 树和二叉树
mist的博客
08-26 1110
树和二叉树、堆（顺序结构）、二叉树链式结构
数据结构：用栈实现队列（232）LeetCode
2303_81073778的博客
08-26 538
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1376
数据结构-时间、空间复杂度-详解
浅谈【数据结构】树与二叉树之哈夫曼树
weixin_67526434的博客
08-26 768
浅谈【数据结构】树与二叉树之哈夫曼树
【Java & 数据结构】HashMap和HashSet介绍
qq_42150700的博客
08-29 612
Map 和 Set 是 Java 集合框架中的两个接口, 其分别对应着两种不同的搜索模型. 其中 一个是纯 key 模型, 另一个则是 key-value 模型.纯 key 模型就类似于一个集合, 里面装载着一些元素, 这些元素只包含其本身. 例如我有一个冰箱, 里面装着各式各样的饮料, 那么此时这个冰箱就可以看作是一个饮料的集合, 里面装载着饮料. 此时如果我要在里面找饮料, 找的就是饮料本身.
【数据结构】-----哈希
最新发布
m0_73470633的博客
08-29 531
一文看懂哈希结构！
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1087
KMP算法：理解next[]表
集合及数据结构第十二节（下）————哈希表、字符串常量池和练习题
2301_79418684的博客
08-26 797
哈希表、字符串常量池和练习题 1. 哈希表的概念 2. 冲突-概念 3. 冲突-避免 4. 冲突-解决 5. 冲突严重时的解决办法 6. 冲突严重时的解决办法的实现 7. 性能分析 8. 和 java 类集的关系 9. Hashmap的使用案例 10. 模拟实现HashMap（k-v模型） 11. 创建对象的思考 12. 字符串常量池(StringTable) 13. 再谈String对象创建 14. 练习
C++程序设计：函数编程题 - 工作备忘录生成与冲突处理
在C++程序设计的第一章中，涉及了一个关于工作备忘录生成的编程题目，主要目标是根据工作记录数据结构实现一个功能。题目要求你创建一个程序，处理用户输入的工作任务列表，其中每个任务包括工作名称、开始时间和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值