【链表】单链表、双向循环链表

骑猪看日落 2024-03-24 18:19 101阅读 0赞

#### 文章目录 ####

*  前言
 *  一：链表(LinkedList)
 *   *  1.1 链表分类
     *  1.2 介绍
     *  1.3 链表的概念及结构
 *  二：单链表
 *   *  2.1 单链表结构示意图
     *  2.2 单链表的应用实例
     *  2.3 单链表的添加
     *   *  2.3.1 直接添加到链表的尾部（不考虑顺序）
         *   *  2.3.1.1 整体思路
             *  2.3.1.2 代码实现
         *  2.3.2 按顺序插入到指定位置(如果有这个排名，则添加失败，并给出提示)
         *   *  2.3.2.1 思路分析
             *  2.3.2.2 代码实现
             *  2.3.2.3 测试
     *  2.4 单链表的修改
     *  2.5 单链表的删除
     *   *  2.5.1 思路分析
         *  2.5.2 代码实现
         *  2.5.3 测试
 *  三：常见的单链表面试题
 *   *  3.1 求单链表中有效节点的个数
     *  3.2 查找单链表中的倒数第k个结点
     *   *  3.2.1 思路
         *  3.2.2 代码实现
     *  3.3 单链表的反转
     *   *  3.3.1 思路分析
         *  3.3.2 代码实现
 *  四：双向环形链表
 *   *  4.1 单链表的不足
     *  4.2 介绍
     *  4.3 定义双向循环链表节点类
     *  4.4 将元素追加到链表的末尾
     *  4.5 将元素插入到指定下标处
     *  4.6 返回指定下标处的元素
     *  4.7 移除指定位置处的元素
     *  4.8 返回指定位置的节点
     *  4.9 重写toString方法
     *  4.10 测试

## 前言 ##

问：为什么使用链表？  
答：当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此又引入了LinkedList，即链表结构。

## 一：链表(LinkedList) ##

### 1.1 链表分类 ###

链表可分为三类：单链表、双向链表、循环列表  
单向或者双向：  
![在这里插入图片描述][4662214a01bf4586894664f02e6592da.png]  
带头或者不带头：  
![在这里插入图片描述][5dc306d4572d49cc9a8279271baffcc0.png]  
循环或者非循环：  
![在这里插入图片描述][6bf5e1dcb39d42359c5649a633c4365f.png]

### 1.2 介绍 ###

链表是有序的列表，但是它在内存中是存储如下  
![在这里插入图片描述][035637f1f9504011a04c1b4375091f6f.png]  
![在这里插入图片描述][4e957df65d22482f82705d76b1f97276.png]

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

### 1.3 链表的概念及结构 ###

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序来实现的。类似于一节又一节火车。  
![在这里插入图片描述][bf17011ebc614d7992a420b688923a76.png]

## 二：单链表 ##

### 2.1 单链表结构示意图 ###

![在这里插入图片描述][b001b19875124a68ad1d3e382ebd0bc2.png]

### 2.2 单链表的应用实例 ###

实例：使用带head头的单向链表实现 –人物排行榜管理  
功能：完成对人物的增删改查操作

### 2.3 单链表的添加 ###

#### 2.3.1 直接添加到链表的尾部（不考虑顺序） ####

![在这里插入图片描述][4ba200a777c84e2aae59040c3f200e94.png]

##### 2.3.1.1 整体思路 #####

1.  先创建一个head头节点，作用就是表示单链表的头
2.  后面我们没添加一个节点，就直接加入到链表的最后
3.  通过一个辅助变量遍历，帮助遍历整个链表

##### 2.3.1.2 代码实现 #####

public class SingleLinkedListDemo {
        
        public static void main(String[] args) {
        
            //创建节点
            HeroNode hero1 = new HeroNode(1, "蔡徐坤", "ikun");
            HeroNode hero2 = new HeroNode(2, "刀郎", "罗刹海市");
            HeroNode hero3 = new HeroNode(3, "那英", "哪有鸟");
            HeroNode hero4 = new HeroNode(4, "汪峰", "春天里");
            HeroNode hero5 = new HeroNode(5, "杨坤", "马户");
            //创建链表
            SingleLinkedList singleLinkedList = new SingleLinkedList();
            singleLinkedList.add(hero1);
            singleLinkedList.add(hero2);
            singleLinkedList.add(hero3);
            singleLinkedList.add(hero4);
            singleLinkedList.add(hero5);
            //显示
            singleLinkedList.list();
        }
    }
    
    /**
     * 定义singleLinkedList来管理我们的人员
     */
    class SingleLinkedList {
        
        //先初始化头节点,头节点不要动,不存放具体数据
        private final HeroNode head = new HeroNode(0, "", "");
    
        /**
         * 添加节点到单链表
         * 思路：当不考虑编号顺序时，
         * 1.找到当前列表的最后一个节点
         * 2.将最后这个节点的next指向新的节点
         *
         * @param heroNode
         */
        public void add(HeroNode heroNode) {
        
            //因为head节点不能动，因此我们需要设置一个辅助变量temp，并且遍历temp
            HeroNode temp = head;
            //遍历链表，找到最后一个节点
            while (temp.next != null) {
        
                //找到链表的最后一个节点
                //如果没有找到，就将temp临时变量后移
                temp = temp.next;
            }
            //当退出while循环时，temp就指向了链表的最后
            temp.next = heroNode;
        }
    
        /**
         * 显示链表
         */
        public void list() {
        
            //判断链表是否为空
            if (head.next == null) {
        
                System.out.println("链表为空");
                return;
            }
            //因为头节点不能动，因此我们需要使用一个辅助变量来遍历
            HeroNode temp = head.next;
            while (temp != null) {
        
                //判断是否到链表的最后
                //输出节点信息
                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;
        }
    
        /**
         * 重写toString方法
         *
         * @return String
         */
        @Override
        public String toString() {
        
            return "HeroNode{" + "no=" + no + ", name='" + name + ", nickname='" + nickname + '}';
        }
    
    
    }

![在这里插入图片描述][fae71dd6e4b1474cb23e786dedc20809.png]

#### 2.3.2 按顺序插入到指定位置(如果有这个排名，则添加失败，并给出提示) ####

![在这里插入图片描述][3f483e241252404595be928392cc8d13.png]

##### 2.3.2.1 思路分析 #####

需按照编号的书序添加：

1.  首先找到新添加的节点的位置，是通过辅助变量（指针），通过遍历来搞定
2.  新的节点.next = temp.next;
3.  将temp.next指向新的节点

##### 2.3.2.2 代码实现 #####

/**
         * 按照顺序插入到指定位置，如果有这个排名，则添加失败，并给出提示
         *
         * @param heroNode
         */
        public void addByOrder(HeroNode heroNode) {
        
            //因为head节点不能动，因此我们需要设置一个辅助变量temp，并且遍历temp
            //因为是单链表，所以我们找的temp是位于添加位置的前一个节点，否则无法插入
            HeroNode temp = head;
            //添加的编号是否存在，默认为false
            boolean flag = false;
            //说明temp已经在链表的最后
            while (true) {
        
                if (temp.next == null) {
        
                    break;
                }
                //位置找到，就在temp的后面插入
                if (temp.next.no > heroNode.no) {
        
                    break;
                } else if (temp.next.no == heroNode.no) {
        
                    //此时说明heroNode编号已经存在,将flag变为true
                    flag = true;
                }
                //如果以上条件都不满足，则将temp后移
                temp = temp.next;
            }
    
            //判断flag的值，如果flag为true则不能添加
            if (flag) {
        
                System.out.printf("编号%d,已经存在,无法添加", heroNode.no);
            } else {
        
                //插入到链表中，temp的后面
                heroNode.next = temp.next;
                temp.next = heroNode;
            }
        }

##### 2.3.2.3 测试 #####

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

![在这里插入图片描述][8ecab60ebb9d49d8af87493038d65b2a.png]  
此时顺序添加功能就实现了！

### 2.4 单链表的修改 ###

/**
         * 通过no编号进行修改，no编号不可以修改
         *
         * @param newHeroNode
         */
        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 = temp.next;
    
            }
            //根据flag判断是否找到该节点
            if(flag){
        
                //找到了，则将temp重新赋值
                temp.name = newHeroNode.name;
                temp.nickname = newHeroNode.nickname;
            } else {
        
                //没找到该节点
                System.out.printf("没有找到编号为%d的节点，无法修改\n", newHeroNode.no);
    
            }
    
        }

![在这里插入图片描述][10882ae4752d44b6899656e72fc53b92.png]

### 2.5 单链表的删除 ###

#### 2.5.1 思路分析 ####

![在这里插入图片描述][d0b3a8744b4d4ee685d085700a45b91c.png]  
从单链表中删除一个节点的思路：

1.  我们需要先找到删除节点的前一个节点temp
2.  temp.next = temp.next.next
3.  被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收

#### 2.5.2 代码实现 ####

/**
         * 思路
         * 1.因为头节点不能动，所以我们需要一个temp临时变量来找到删除节点的前一个节点
         * 2.在比较时，我们需要将temp.next.no和需要删除节点的no进行比较
         *
         * @param no 需要删除节点的编号
         */
        public void delete(int no) {
        
            //因为head节点不能动，因此我们需要设置一个辅助变量temp，并且遍历temp
            //因为是单链表，所以我们找的temp是位于添加位置的前一个节点
            HeroNode temp = head;
            //表示是否找到该节点
            boolean flag = false;
            while (true) {
        
                //说明temp已经在链表的最后
                if (temp.next == null) {
        
                    break;
                }
                //找到待删除节点的前一个节点
                if (temp.next.no == no) {
        
                    flag = true;
                    break;
                }
                //如果以上条件都不满足，则将temp后移
                temp = temp.next;
            }
    
            //判断flag的值，如果flag为true则找到
            if (flag) {
        
                //可以删除
                temp.next = temp.next.next;
            } else {
        
                System.out.printf("编号%d,不存在,无法删除", no);
            }
        }

#### 2.5.3 测试 ####

删除节点信息为3的信息

//删除一个节点信息
    singleLinkedList.delete(3);

![在这里插入图片描述][57e18441898248aaae568ec4e3822603.png]

## 三：常见的单链表面试题 ##

### 3.1 求单链表中有效节点的个数 ###

/**
         * 获取单链表的节点个数
         * 注:如果是带头结点的，需求不统计头节点
         *
         * @param head
         * @return
         */
        public static 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;
        }

### 3.2 查找单链表中的倒数第k个结点 ###

#### 3.2.1 思路 ####

1.编写一个方法，接收head节点，同时接收一个index（index表示倒数的第index个节点）
     2.先把链表从头到尾遍历，得到链表的总长度size
     3.得到size后，我们从链表的第一个开始遍历（size - index）个，就可以得到
     4.如果找到了则返回该节点，否则返回null

#### 3.2.2 代码实现 ####

/**
         * 查找单链表中的倒数第k个结点
         * 思路：
         * 1.编写一个方法，接收head节点，同时接收一个index（index表示倒数的第index个节点）
         * 2.先把链表从头到尾遍历，得到链表的总长度size
         * 3.得到size后，我们从链表的第一个开始遍历（size - index）个，就可以得到
         * 4.如果找到了则返回该节点，否则返回null
         *
         * @param head
         * @param index
         * @return
         */
        public static HeroNode findLastIndexNode(HeroNode head, int index) {
        
            //如果链表为空，则返回null
            if (head.next == null) {
        
                return null;
            }
            //获取链表节点得个数
            int size = getLength(head);
            //遍历size - index，就是我们需要的倒数第k个节点
            //先做index校验
            if (index <= 0 || index > size) {
        
                return null;
            }
            //定义辅助变量，for循环定位到倒数的index
            //假设数组长度为8，我们需要找到倒数第3个数据，则就是正数第8 - 3 = 5个数据
            HeroNode temp = head.next;
            for (int i = 0; i < size - index; i++) {
        
                temp = temp.next;
            }
            return temp;
        }

### 3.3 单链表的反转 ###

#### 3.3.1 思路分析 ####

![在这里插入图片描述][eb9f65dadc45484b948abb624172d01b.png]  
![在这里插入图片描述][a4f6e01d4a7d486fa447c932097fb737.png]

思路：

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

#### 3.3.2 代码实现 ####

/**
         * 单链表的反转
         * 思路
         * 1.先定义一个节点，reverseHead = new HeroHead();
         * 2.从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并且放在新的链表reverseHead的最前端
         * 3.原来的链表的head.next = reverseHead.next;
         *
         * @param head
         */
        public static void reverseList(HeroNode head) {
        
            //如果只有一个节点或者链表是空的，则不需要反转
            if (head.next == null || head.next.next == null) {
        
                return;
            }
            //定义一个辅助变量，来帮助我们循环遍历链表,cur表示当前节点
            HeroNode cur = head.next;
            //指向当前节点cur的下一个节点
            HeroNode next = null;
            //定义一个空的链表
            HeroNode reverseNode = new HeroNode(0, "", "");
            //遍历原来的链表，每遍历一个节点，就将其取出，放到新链表reverseNode的最前端
            //当cur为null时，说明已经遍历结束
            while (cur != null) {
        
                //先暂时保存当前节点的下一个节点
                next = cur.next;
                //将当前节点的下一个节点赋值给反转链表的最前端
                cur.next = reverseNode.next;
                //将cur连接到新的链表上
                reverseNode.next = cur;
                //将cur后移，继续向下遍历
                cur = next;
            }
            //将head.next指向reverseNode.next,实现单链表的反转
            head.next = reverseNode.next;
        }

## 四：双向环形链表 ##

### 4.1 单链表的不足 ###

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

### 4.2 介绍 ###

有两个指针域，一个指向后一个结点，一个指向前一个结点。它存储了前一个结点的地址与后一个结点的地址，所以可以很方便的进行向前遍历或者向后遍历。同时它还是一个循环链表，可以通过第一个结点直接找到最后一个结点。  
![在这里插入图片描述][e1627f55d388468595c8e6d14b947a41.png]

next：指向下一个节点  
pre：指向上一个节点

### 4.3 定义双向循环链表节点类 ###

public class LinkedList<E> {
        
        /**
         * head用于存放头节点信息
         */
        private Node head;
        /**
         * 链表的长度
         */
        private Integer size = 0;
    
        /**
         *  Node用于描述表中的一个节点
         *  其中，data用于存放于元素
         *  next是存放前继节点
         *  prev用于存放指向其后继节点
         */
        class Node {
        
            //存放数据
            E data;
            //前继节点
            Node next;
            //后继节点
            Node prev;
            //构造器
            public Node(E e){
        
                data = e;
            }
        }
    
    /**
         * 获得链表的长度
         *
         * @return
         */
        public int size() {
        
            return size;
        }
    }

### 4.4 将元素追加到链表的末尾 ###

![在这里插入图片描述][8c8358f801d34c6b9b8687343ed9b7b2.png]

/**
         * 将元素追加到链表的末尾
         * @param e 被添加的元素
         * @return 添加成功，返回true
         */
        public boolean add(E e){
        
            //将元素封装成一个节点
            Node node = new Node(e);
            //如果链表为空，则新节点就是头节点
            if(head == null){
        
                head = node;
                head.next = node;
                head.prev = node;
                //链表的长度加1
                size ++;
                return true;
            }
            //找到末尾节点地址
            Node last = head.prev;
            //将新节点添加到未节点后面
            last.next = node;
            node.next = head;
            head.prev = node;
            node.prev = last;
            //链表的长度加1
            size ++;
            return true;
        }

### 4.5 将元素插入到指定下标处 ###

![在这里插入图片描述][1ece3d953c4641199c486272ccbd1d2a.png]

/**
         * 将元素插入到指定下标处
         * @param index
         * @param e
         */
        public void add(int index,E e){
        
            if( index < 0 || index > size ){
        
                throw new IndexOutOfBoundsException("数组下标越界异常");
            }
            if(index == size){
        
               add(e);
            }
            //将元素封装成一个节点
            Node node = new Node(e);
            Node next = getNode(index);
            Node prev = next.prev;
            next.prev = node;
            node.prev = prev;
            prev.next = node;
            node.next = next;
            if(index == 0){
        
                head = node;
            }
            size ++;
        }

### 4.6 返回指定下标处的元素 ###

![在这里插入图片描述][e6f66774bb094e83a15cf8a114dc6597.png]

/**
         * 返回指定下标处的元素
         * @param index 下标，从0开始
         * @return 对应位置处的元素
         */
        public E get(Integer index){
        
            if(index < 0 || index >= size){
        
                throw new IndexOutOfBoundsException("数组下标越界异常");
            }
            Node node = getNode(index);
            //返回该节点存放的数据
            return node.data;
        }

### 4.7 移除指定位置处的元素 ###

![在这里插入图片描述][957757c6d5a1469bbbaf57502173a86d.png]

/**
         * 移除指定位置处的元素
         *
         * @return
         */
        public E remove(Integer index) {
        
            if (index < 0 || index >= size) {
        
                throw new IndexOutOfBoundsException("数组下标越界异常");
            }
            //如果链表只有一个元素,则删除该节点以后，需要将head设置为null,并返回删除的元素
            if (size == 1) {
        
                E data = head.data;
                head = null;
                size--;
                return data;
            }
            //找到要删除的节点
            Node node = this.getNode(index);
            //找到该节点的前驱节点和后继节点
            Node next = node.next;
            Node prev = node.prev;
            //将该节点删除(其实就是在prev和next之间建立引用关系)
            prev.next = next;
            next.prev = prev;
            //如果被删除的元素为头节点,则其下一个节点为头节点
            if (index == 0) {
        
                head = next;
            }
            //链表长度减1
            size--;
            return node.data;
        }

### 4.8 返回指定位置的节点 ###

/**
         * 返回指定位置的节点
         *
         * @param index
         * @return
         */
        private Node getNode(Integer index) {
        
            //从头结点开始遍历
            Node node = this.head;
            //此时可以用移位运算
            //为了提升性能，可以通过比较index与链表的长度的一半来决定是向前遍历还是向后遍历
            if (index < size >> 1) {
        
                for (int i = 0; i < index; i++) {
        
                    node = node.next;
                }
            } else {
        
                for (int i = size; i > index; i--) {
        
                    node = node.prev;
                }
            }
            return node;
        }

### 4.9 重写toString方法 ###

@Override
        public String toString() {
        
            if (head == null) {
        
                return "[]";
            }
            StringBuilder stringBuilder = new StringBuilder("[");
            stringBuilder.append(head.data);
            Node node = head.next;
            while (node.next != head) {
        
                stringBuilder.append(",").append(node.data);
                //继续查找下个节点
                node = node.next;
            }
            return stringBuilder.append("]").toString();
        }

### 4.10 测试 ###

public class LinkedListTest {
        
        public static void main(String[] args) {
        
            LinkedList<String> list = new LinkedList<>();
            List<Integer> arrayList = new ArrayList<>();
            list.add("Curry");
            list.add("Green");
            list.add("Thompson");
            list.add("Durant");
            list.add("James");
            System.out.println("size():" + list.size());
            System.out.println("get(2):" + list.get(2));
            System.out.println("list:" + list.toString());
        }
    }

![在这里插入图片描述][6e5968908fa14bf5a6157f21c978326a.png]

[4662214a01bf4586894664f02e6592da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/e095ecbefc53481d97ffb9ac81ff0830.png
[5dc306d4572d49cc9a8279271baffcc0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/2344b28a38244dc4816b73dac0486d87.png
[6bf5e1dcb39d42359c5649a633c4365f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/94c5c815f4f84a4c899f9e2344d98921.png
[035637f1f9504011a04c1b4375091f6f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/79d589f782574f3c8b6bdb9ff83a6cd4.png
[4e957df65d22482f82705d76b1f97276.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/29a73b7d458c4841a63e45daa5632f31.png
[bf17011ebc614d7992a420b688923a76.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/6d5816e6622f49a29b30d313984b93ba.png
[b001b19875124a68ad1d3e382ebd0bc2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/c305e20fcfab4b7ea95cadcc522b0441.png
[4ba200a777c84e2aae59040c3f200e94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/ca2c586a24e144868a20501204bbc97a.png
[fae71dd6e4b1474cb23e786dedc20809.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/aec2b408424c46b3b99c966f7bab4389.png
[3f483e241252404595be928392cc8d13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/7de9ef50faa448e0b11cec1bfc6881ec.png
[8ecab60ebb9d49d8af87493038d65b2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/9fd87a1900a64b099ec758adbeb169a1.png
[10882ae4752d44b6899656e72fc53b92.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/0bbe17d9d203410caf6bdc8dfff85394.png
[d0b3a8744b4d4ee685d085700a45b91c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/4ef0488da5424f44b291d498e88325e2.png
[57e18441898248aaae568ec4e3822603.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/a760af1c17104f388104057048907a3c.png
[eb9f65dadc45484b948abb624172d01b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/b7d80c2554b6423ebc4489f635bff8b9.png
[a4f6e01d4a7d486fa447c932097fb737.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/8b61867db19a4b169ce2873e8d0a6f25.png
[e1627f55d388468595c8e6d14b947a41.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/a8219ec2599546c4929da5b9b52fedb8.png
[8c8358f801d34c6b9b8687343ed9b7b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/eec23d0afb3944608b1c1ec85b506ffc.png
[1ece3d953c4641199c486272ccbd1d2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/77a0e4ff7eab4b40b7ecc23c6ff11b2a.png
[e6f66774bb094e83a15cf8a114dc6597.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/f5440c083e9946ad94fbc897fbcb0af3.png
[957757c6d5a1469bbbaf57502173a86d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/992bcefce8cf4605a126a558e9fe50df.png
[6e5968908fa14bf5a6157f21c978326a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/923157b52fae42ceaf66253fc48dead5.png