【数据结构Java版】LinkedList与链表

「爱情、让人受尽委屈。」 2024-04-03 13:44 175阅读 0赞

**目录**

一、什么是LinkedList

二、LinkedList的模拟实现

（1）合法LinkedList的要求

（2）LinkedList实现的内容

1.结点个数

2.链表尾插元素

3.链表头插元素

4.指定下标插入元素

5.删除指定下标结点

6.删除指定元素

7.获取指定下标元素

8.设置指定下标元素

9.从前往后获取指定元素下标

10.从后往前获取指定元素下标

11.判断是否包含指定元素

12.清空链表

13.判断链表是否为空

三、LinkedList的使用

（1）LinkedList的构造

（2）LinkedList的其他常用方法介绍

（3）LinkedList的遍历

四、ArrayList与LinkedList的比较

--------------------

## 一、什么是LinkedList ##

LinkedList 的官方文档： [LinkedList (Java Platform SE 8 )][LinkedList _Java Platform SE 8]  
单链表从前往后遍历支持较好，从后往前遍历支持较差。 因此LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的结点中，然后通过引用将结点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。

不太清楚单链表知识的小朋友建议先看这：[http://t.csdn.cn/c8WZ2][http_t.csdn.cn_c8WZ2]

LinkedList示意图：

![baea8a68898a4249b80413ec9fc7351e.png][]

**模拟实现LinkedList的属性 ：**

public class MyLinkedList implements MyList {
        // 维护着 3 个属性
        // 1. 链表的头结点
        private MyNode head;
        // 2. 链表的尾结点
        private MyNode last;
        // 3. 维护着链表中的元素个数
        private int size;   // 不维护也可以通过遍历数出来，但维护好这个属性，可以让 size 的时间复杂度 O(n) -> O(1)
    
        // 构造方法
        // 构造一个空的链表
        public MyLinkedList() {
            this.head = this.last = null;
            this.size = 0;
        }

在集合框架中，LinkedList也实现了List接口，具体如下：

![5540b5aa3fce4549adda7edb1bc7580f.png][]

1. LinkedList实现了List接口  
2. LinkedList的底层使用了双向链表  
3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问  
比特就业课  
4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)  
5. LinkedList比较适合任意位置插入的场景

--------------------

## 二、LinkedList的模拟实现 ##

### （1）合法LinkedList的要求 ###

一个正确的 MyLinkedList 应该做到什么 ？要始终在模拟实现的过程关注以下几点内容，判断模拟的链表是否是合法的。

为了在实现LinkedList模拟过程时刻判断链表是否合法，我们可以设置一套检查装置，这套检查代码不用掌握。我们自己编写代码是要注意时刻检查调试代码是否正确，不要一股脑儿的写代码，最后bug满天飞，无法入手。

1. 得是一个合法的线性表

2. 当 head != null 则 last != null 反之亦然 当 head == null 则 last == null

3. 当 head != null 的时候，则 size > 0 同理，当 head == null 的时候，则 size == 0

4. size 的值应该 == 通过遍历数出来的结点个数 (从 head 到 last 或者 从 last 到 head）

5. 除了 head 和 last 之外，所有的其他结点(node), node.prev != null && node.next != null

6. head != null 时，则 head.prev == null，但 head.next 不确定（可以不为 null | size > 1）；也可 以为 null | size == 1) last != null 时，则 last.next == null，但 last.prev 不确定（可以不为 null | size > 1）；也可以为 null | size == 1)

7. 除了 head 和 last 之外的所有结点(node)，node.prev.next == node && node.next.prev == node8. 当 head.next != null 时，head.next.prev == head 当 last.prev != null 时，last.prev.next == last 9. 当 size == 1 时，head == last && head != null

private static void 断言为真(boolean condition, String message) {
            if (!condition) {
                throw new RuntimeException(message);
            }
        }
    
        private static void 检查2(MyLinkedList list) {
            if (list.head == null) {
                断言为真(list.last == null, "head 为 null 时，last 必须是 null");
            } else {
                断言为真(list.last != null, "head 不为 null 时，last 必须不为 null");
            }
        }
    
        private static void 检查3(MyLinkedList list) {
            断言为真(list.size >= 0, "size 必须 >= 0");
    
            if (list.head == null) {
                断言为真(list.size == 0, "head 为 null 时，size 必须是 0");
            } else {
                断言为真(list.size > 0, "head 不为 null 时，size 必须大于 0");
            }
        }
    
        private static int 从前往后遍历确定结点个数(MyLinkedList list) {
            int size = 0;
            for (MyNode cur = list.head; cur != null; cur = cur.next) {
                size++;
            }
    
            return size;
        }
    
        private static void 检查4(MyLinkedList list) {
            断言为真(list.size == 从前往后遍历确定结点个数(list), "记录的 size 应该和遍历出的 size 相等");
        }
    
        private static void 检查5(MyLinkedList list) {
            if (list.size > 1) {
                MyNode cur = list.head.next;
                while (cur != list.last) {
                    断言为真(cur.prev != null, "非头尾结点的 prev 不能是 null");
                    断言为真(cur.next != null, "非头尾结点的 next 不能是 null");
    
                    cur = cur.next;
                }
            }
        }
    
        private static void 检查6(MyLinkedList list) {
            // head != null 等价于 size > 0
            if (list.head != null) {
                断言为真(list.head.prev == null, "头结点的 prev 一定是 null");
                断言为真(list.last.next == null, "尾结点的 next 一定是 null");
                if (list.size == 1) {
                    断言为真(list.head.next == null, "size 为 1 时，头节点的 next 一定是 null");
                    断言为真(list.last.prev == null, "size 为 1 时，为节点的 prev 一定是 null");
                } else {
                    断言为真(list.head.next != null, "size > 1 时，头节点的 next 一定不是 null");
                    断言为真(list.last.prev != null, "size > 1 时，尾节点的 prev 一定不是 null");
                }
    
            }
        }
    
        private static void 检查7(MyLinkedList list) {
            if (list.size > 1) {
                MyNode cur = list.head.next;    // 跳过头节点
                while (cur != list.last) {      // 跳过尾结点
                    断言为真(cur.prev.next == cur, "非头尾结点的 前驱的 后继是自己");
                    断言为真(cur.next.prev == cur, "非头尾结点的 后继的 前驱是自己");
    
                    cur = cur.next;
                }
            }
        }
    
        private static void 检查8(MyLinkedList list) {
            // head.next != null 等价于 last.prev != null 等价于 size > 1
            if (list.size > 1) {
                断言为真(list.head.next.prev == list.head, "当 head.next != null 时，head.next.prev == head");
                断言为真(list.last.prev.next == list.last, "当 last.prev != null 时，last.prev.next == last");
            }
        }
    
        private static void 断言是一个合法的链表(MyLinkedList list) {
            检查2(list);
            检查3(list);
            检查4(list);
            检查5(list);
            检查6(list);
            检查7(list);
            检查8(list);
        }

--------------------

### （2）LinkedList实现的内容 ###

> //结点个数  
> public int size() \{  
> return 0;  
> \}
> 
> //链表尾插元素  
> public boolean add(Long e) \{  
> return false;  
> \}
> 
> //链表头插元素
> 
>  public boolean addFirst(Long e) \{ 
> 
>  return false;
> 
>  \}
> 
> //指定下标插入元素  
> public void add(int index, Long e) \{ 
> 
>  \}
> 
> //删除指定下标结点  
> public Long remove(int index) \{  
> return null;  
> \}
> 
> //删除指定元素  
> public boolean remove(Long e) \{  
> return false;  
> \}
> 
> //获取指定下标元素  
> public Long get(int index) \{  
> return null;  
> \}
> 
> //设置指定下标元素  
> public Long set(int index, Long e) \{  
> return null;  
> \}
> 
> //从前往后获取指定元素下标  
> public int indexOf(Long e) \{  
> return 0;  
> \}
> 
> //从后往前获取指定元素下标  
> public int lastIndexOf(Long e) \{  
> return 0;  
> \}
> 
> //判断是否包含指定元素  
> public boolean contains(Long e) \{  
> return false;  
> \}
> 
> //清空链表  
> public void clear() \{ 
> 
>  \}
> 
> //判断链表是否为空  
> public boolean isEmpty() \{  
> return false;  
> \}

--------------------

#### 1.结点个数 ####

在检查机制中已经写过一遍，就是从前往后遍历所有元素。这里主要要返回size即可

public int size() {
        return size
    }

--------------------

#### 2.链表尾插元素 ####

时间复杂度是O(1)

考虑两种情况：size==0的情况和链表size>0的情况。

注意要点 ：

a.需要分情况讨论。两种情况无法合并

b.既要关注head，也要关注last

c.需要正确处理结点的next和prev。涉及新加入的结点和之前的尾结点（如果存在的话）

d.size不能忘记

![0f8903c1e4044a3ea21c7992b9aa3062.png][]![671b216ddb6e4f2ca3b45df9ff59de20.png][]

public boolean add(Long e){
        //1.将元素装入新结点
        MyNode node=new MyNode(e);
        node.next=null;//这一步可以省略
        //2.找尾结点，分情况讨论
        //2.1链表中有尾结点：last != null 等价于 head != null 等价于 size > 0
        if(size>0){
            this.last.next=node;
            node.prev=this.last;
            this.last=node;
        }else{
        //2.2链表中没有有尾结点
            node.prev=null;
            this.head=this.last=node;
        }
        //3.size个数增加
        this.size++;
        return true;
    }

--------------------

#### 3.链表头插元素 ####

时间复杂度是O(1)

与尾插思路基本一致。

![af8283d49f2049809f3ff5102c9a1c87.png][]

![00d802962fc5451a88502021c4fe2819.png][]

public boolean addFisrst(Long e){
        MyNode node=new MyNode(e);
        node.prev=null;
        if(size>0){
            this.head.prev=node;
            node.next=this.head;
            this.head=node;
        }else{
            node.next=null;
            this.head=this.last=node;
        }
        this.size++;
        return true;
    }

--------------------

#### 4.指定下标插入元素 ####

时间复杂度是O(n)

根据下标的特征可以分为以下几种情况。根据以下表格写代码，才可以保证所有情况都考虑到不出错。

![e40fe15ac8fe460d84caa23701b7fef7.png][]

![7a58eac0a30b48de851797f1a83b5a4a.png][]

public void add(int index,int e){
 if(index<0||index>size){
 throw new ArrayIndexOfBoundsException("下标不合法");
 }
 //情况1 size==0
 if(size==0){
 add(e);//尾插，或者addFirst(e)用头插也可以
 return;
 }
 //情况2 size==1
 if(size==1){
 //2.1 index==0
 if(index==0){
 addFirst(e);
 //2.2 index==1
 }else{
 add(e);
 }
 return;
 }
 //情况3 size>1
 //3.1 index==0
 if(index==0){
 addFirst(e);
 return;
 //3.2 index=size
 }else if(index==size){
 add(e);
 return;
 }
 
 //3.3 0<index<size
 // 链表要插入，是要找到前驱结点
 // 由于我们是双向链表，前驱结点很容易找
 // 先找到前驱结点，记为 prevNode
 
 MyNode prevNode = this.head;
 //找到指定下标的前一个位置
 for(int i=0;i<index-1;i++){
 prevNode=prevNode.next;
 }
 //找到指定下标的位置
 MyNode curNode=prevNode.next;
 //将元素e装入结点
 MyNode node=new Mynode(e);
 //将该结点插入指定下标位置处
 prevNode.next=node;
 curNode.prev=node;
 node.prev=prevNode;
 node.next=curNode;
 //size的值增加
 size++;
 }

**关于异常操作，指路☞** [http://t.csdn.cn/QaTL8][http_t.csdn.cn_QaTL8]

--------------------

#### 5.删除指定下标结点 ####

时间复杂度是O(n)

注意size==0的情况是下标不合法。

![be7f697d731c4aa792842c35f18e5b84.png][]

--------------------

![04cfa568b1824c8098e75dc1cf4f9409.png][]

public Long remove(int index){
 //下标不合法
 if(index<0||index>=size){
 throw new ArrayIndexOutOfBoundsException("下标不合法");
 }
 //下标合法
 //情况1:size==1
 if(size==1){
 //现将要删除的结点元素保存下来
 Long e=this.head.val;
 this.head=this.last=null;
 //size减少
 this.size==0;
 return e;
 }
 
 //情况2:size>1
 //2.1 index==0 头删
 if(index==0){
 Long e=this.head.val;
 //改变头结点的位置，现头结点为原来头结点的后一个
 this.head=this.head.next;
 //现头结点的前驱指向为null
 this.head.prev=null;
 //size减少
 this.size--;
 return e;
 }
 //2.2 index==size-1 尾删
 if(index==size-1){
 Long e=this.last.val;
 //改变尾结点的位置，现尾结点为原来尾结点的前一个
 this.last=this.last.prev;
 //现尾结点的前驱指向为null
 this.last.next=null;
 //size减少
 this.size--;
 return e; 
 }
 //size>1 && 0<index<size-1
 //找到指定下标结点
 MyNode curNode=this.head;
 for(int i=0;i<index;i++){
 curNode=curNode.next;
 }
 Long e=curNode.val;
 //指定下标结点的前一个结点
 MyNode prevNode=curNode.prev;
 //指定下标结点的后一个结点
 MyNode nextNode=curNode.next;
 
 //删除操作
 preNode.next=nextNode;
 nextNode.prev=prevNode;
 this.size--;
 return e;
 }

**关于异常操作，指路☞** [http://t.csdn.cn/QaTL8][http_t.csdn.cn_QaTL8]

#### 6.删除指定元素 ####

时间复杂度是O(n)

删除指定元素，如果找到该元素，返回true；如果没有找到该元素，返回false。

public boolean remove(Long e){
 MyNode cur=this.head;
 for(int i=0;i<size;i++){
 if(cur.val.equals(e)){
 //头删
 if(i==0){
 //size可能性>=1，分情况讨论
 this.head=this.head.next;
 // size > 1 则 此时 this.head != null
 if(this.head!=null){
 this.head.prev==null;
 //size == 1 则 此时 this.head == null
 }else{
 this.head=this.last=null;
 }
 this.size--;
 return true;
 }
 if(i==size-1){
 //size>1
 this.last=this.last.prev;
 this.last.next=null;
 this.size--;
 return true;
 }
 //既不是头删，也不是尾删
 MyNode prevNode =curNode.prev;
 MyNode nextNode =curNode.next;
 
 prevNode.next=nextNode;
 nextNode.next=prevNode;
 this.size--;
 return true;
 }
 cur=cur.next;//循环，写到最后别忘了
 }
 return false; 
 }

--------------------

#### 7.获取指定下标元素 ####

时间复杂度是0(n)

首先要判断下标是非合法，然后遍历获取。

public Long get(int index){ 
 if(index<0||index>=size){
 throw new ArrayIndexOutOfBoundsException("下标不合法");
 }
 MyNode curNode=this.head;
 for(int i=0;i<index;i++){//遍历
 curNode=curNode.next;
 }
 return curNode.val;
 }

--------------------

#### 8.设置指定下标元素 ####

时间复杂度是0(n)

首先要判断下标是非合法，然后遍历获取。存储旧的结点信息。

public Long set(int index,Long e){
 if(index<0||index>=size){
 throw new ArrayIndexOutOfBoundsException("下标不合法");
 }
 MyNode curNode = this.head;
 for(int i=0;i<index;i++){//遍历
 curNode=curNode.next;
 }
 Long oldValue=curNode.val;//存储旧值
 curNode.val=e;
 return oldValue;
 }

--------------------

#### 9.从前往后获取指定元素下标 ####

时间复杂度是O(n)

public int indexOf(Long e){
        int i=0;
        MyNode curNode =this.head;
        while(curNode!=null){
            if(curNode.val.equals(e)){
                return i;
            }
            i++;
            curNode=curNode.next;
        }
        return -1;
    }

--------------------

#### 10.从后往前获取指定元素下标 ####

时间复杂度是O(n)

public int lastIndexOf(Long e){
        int i=size-1;
        MyNode curNode =this.last;
        while(curNode!=null){
            if(curNode.val.equals(e)){
                return i;
            }
            i--;
            curNode=curNode.prev;
        }
        return -1;
    }

--------------------

#### 11.判断是否包含指定元素 ####

时间复杂度是O(n)

public boolean contains(Long e){
        return indexOf(e)!=-1;
    }

--------------------

#### 12.清空链表 ####

时间复杂度是O(1)

public void clear() {
        this.head = this.last = null;
        this.size = 0;
    }

--------------------

#### 13.判断链表是否为空 ####

时间复杂度是O(1)

public boolean isEmpty() {
        return size == 0;
    }

--------------------

## 三、LinkedList的使用 ##

### （1）LinkedList的构造 ###

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td style="width:300px;">方法</td> 
 <td style="width:198px;">解释</td> 
 </tr> 
 <tr> 
 <td style="width:300px;">LinkedList()</td> 
 <td style="width:198px;">无参构造</td> 
 </tr> 
 <tr> 
 <td style="width:300px;">public LinkedList(Collection&lt;? extends E&gt; c)</td> 
 <td style="width:198px;">使用其他集合容器中元素构造List</td> 
 </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
 // 构造一个空的LinkedList
 List<Integer> list1 = new LinkedList<>();
 List<String> list2 = new java.util.ArrayList<>();
 list2.add("A");
 list2.add("B");
 list2.add("C");
 // 使用ArrayList构造LinkedList
 List<String> list3 = new LinkedList<>(list2);
 }

### （2）LinkedList的其他常用方法介绍 ###

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td>方法 </td> 
 <td>解释</td> 
 </tr> 
 <tr> 
 <td>boolean add(E e)</td> 
 <td>尾插 e</td> 
 </tr> 
 <tr> 
 <td>void add(int index, E element) </td> 
 <td>将 e 插入到 index 位置</td> 
 </tr> 
 <tr> 
 <td>boolean addAll(Collection&lt;? extends E&gt; c)</td> 
 <td>尾插 c 中的元素</td> 
 </tr> 
 <tr> 
 <td>E remove(int index)</td> 
 <td>删除 index 位置元素</td> 
 </tr> 
 <tr> 
 <td>boolean remove(Object o) </td> 
 <td>删除遇到的第一个 o</td> 
 </tr> 
 <tr> 
 <td>E get(int index)</td> 
 <td>获取下标 index 位置元素</td> 
 </tr> 
 <tr> 
 <td>E set(int index, E element)</td> 
 <td>将下标 index 位置元素设置为 element</td> 
 </tr> 
 <tr> 
 <td>void clear()</td> 
 <td>清空</td> 
 </tr> 
 <tr> 
 <td>boolean contains(Object o)</td> 
 <td>判断 o 是否在线性表中</td> 
 </tr> 
 <tr> 
 <td>int indexOf(Object o) </td> 
 <td>返回第一个 o 所在下标</td> 
 </tr> 
 <tr> 
 <td>int lastIndexOf(Object o) </td> 
 <td>返回最后一个 o 的下标</td> 
 </tr> 
 <tr> 
 <td>List&lt;E&gt; subList(int fromIndex, int toIndex)</td> 
 <td>截取部分 list</td> 
 </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
 LinkedList<Integer> list = new LinkedList<>();
 list.add(1); // add(elem): 表示尾插
 list.add(2);
 list.add(3);
 list.add(4);
 list.add(5);
 list.add(6);
 list.add(7);
 System.out.println(list.size());
 System.out.println(list);
 // 在起始位置插入0
 list.add(0, 0); // add(index, elem): 在index位置插入元素elem
 System.out.println(list);
 list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
 list.removeFirst(); // removeFirst(): 删除第一个元素
 list.removeLast(); // removeLast(): 删除最后元素
 list.remove(1); // remove(index): 删除index位置的元素
 System.out.println(list);
 // contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
 if(!list.contains(1)){
 list.add(0, 1);
 }
 list.add(1);
 System.out.println(list);
 System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
 System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
 int elem = list.get(0); // get(index): 获取指定位置元素
 list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
 System.out.println(list);
 // subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
 List<Integer> copy = list.subList(0, 3);
 System.out.println(list);
 System.out.println(copy);
 list.clear(); // 将list中元素清空
 System.out.println(list.size());
 }

### （3）LinkedList的遍历 ###

a.foreach遍历

b.迭代器正向遍历

c.迭代器负向遍历

public static void main(String[] args) {
 LinkedList<Integer> list = new LinkedList<>();
 list.add(1); // add(elem): 表示尾插
 list.add(2);
 list.add(3);
 list.add(4);
 list.add(5);
 list.add(6);
 list.add(7);
 System.out.println(list.size());
 // foreach遍历
 for (int e:list) {
 System.out.print(e + " ");
 } 
 System.out.println();
 // 使用迭代器遍历---正向遍历
 ListIterator<Integer> it = list.listIterator();
 while(it.hasNext()){
 System.out.print(it.next()+ " ");
 } 
 System.out.println();
 // 使用反向迭代器---反向遍历
 ListIterator<Integer> rit = list.listIterator(list.size());
 while (rit.hasPrevious()){
 System.out.print(rit.previous() +" ");
 } 
 System.out.println();
 }

--------------------

## 四、ArrayList与LinkedList的比较 ##

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td>不同点</td> 
 <td>ArrayList </td> 
 <td>LinkedList</td> 
 </tr> 
 <tr> 
 <td>存储空间上</td> 
 <td>物理上一定连续</td> 
 <td>逻辑上连续，但物理上不一定连续</td> 
 </tr> 
 <tr> 
 <td>随机访问</td> 
 <td>支持O(1)</td> 
 <td>不支持：O(N)</td> 
 </tr> 
 <tr> 
 <td>头插</td> 
 <td>需要搬移元素，效率低O(N)</td> 
 <td>只需修改引用的指向，时间复杂度为O(1)</td> 
 </tr> 
 <tr> 
 <td>插入</td> 
 <td>空间不够时需要扩容</td> 
 <td>没有容量的概念</td> 
 </tr> 
 <tr> 
 <td>应用场景</td> 
 <td>元素高效存储+频繁访问</td> 
 <td>任意位置插入和删除频繁</td> 
 </tr> 
 </tbody> 
</table>

--------------------

![54d0b4d3b4454a038020dabd78d8a208.png][]

[LinkedList _Java Platform SE 8]: https://docs.oracle.com/javase/8/docs/api/java/util/LinkedList.html
[http_t.csdn.cn_c8WZ2]: http://t.csdn.cn/c8WZ2
[baea8a68898a4249b80413ec9fc7351e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/de59f78290bc4f419c3df07d35614e02.png
[5540b5aa3fce4549adda7edb1bc7580f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/49df38eba02f4d1e9edd6640e0d8c37d.png
[0f8903c1e4044a3ea21c7992b9aa3062.png]: https://img-blog.csdnimg.cn/0f8903c1e4044a3ea21c7992b9aa3062.png
[671b216ddb6e4f2ca3b45df9ff59de20.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/eb51dfe5700f4894b5d96cad93e09dd4.png
[af8283d49f2049809f3ff5102c9a1c87.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/07aa2d9efc1a44079dfa08ec5a378986.png
[00d802962fc5451a88502021c4fe2819.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/71f5778b43b040d79170cd362c4cd489.png
[e40fe15ac8fe460d84caa23701b7fef7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/4f7483be34b0437697f4273c4d74b104.png
[7a58eac0a30b48de851797f1a83b5a4a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/5c11b6c9fd984cffa9f4168b0f78956a.png
[http_t.csdn.cn_QaTL8]: http://t.csdn.cn/QaTL8
[be7f697d731c4aa792842c35f18e5b84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/eb521b1a575f4574a7b19d45815cbafc.png
[04cfa568b1824c8098e75dc1cf4f9409.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/9ce7bd9ccc1e4d8cad9a79ea6b2cd7b1.png
[54d0b4d3b4454a038020dabd78d8a208.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/4f21543e603a4a8f96f6f81880c9d125.png