Linux C 数据结构---单向链表

线性表存储结构分为顺序存储、链式存储。

       顺序存储的优点：

       顺序存储的缺点：

       链表就是典型的链式存储，将线性表L = （a0,a1,a2,........an-1）中个元素分布在存储器的不同存储块，成为结点（Node），通过地址或指针建立他们之间的练习，所得到的存储结构为链表结构。表中元素ai的结点形式如下：

其中，结点的data域存放数据元素ai,而next域是一个指针，指向ai的直接后继a(i+1)所在的结点。于是，线性表L=（a0,a1,......an-1）的结构如图：

 

一、节点类型描述：

[cpp] view plaincopy
  1. typedef struct node_t  
  2. {  
  3.     data_t data; //节点的数据域  
  4.     struct node_t *next;//节点的后继指针域  
  5. }linknode_t,*linklist_t;  

也可这样表示：

[cpp] view plaincopy
  1. struct node_t  
  2. {  
  3.     data_t data;   
  4.     struct node_t *next;  
  5. }  
  6. typedef struct node_t linknode_t;  
  7. typedef struct node_t *linklist_t;  

若说明

linknode_t  A;

linklist_t p  = &A;

则结构变量A为所描述的节点，而指针变量P为指向此类型节点的指针（p的值为节点的地址）；

这样看来 linknode_t  linklist_t 的作用是一样的，那为什么我们要定义两个数据类型（同一种）呢？主要为了代码的可读性，我们要求标识符要望文识义，便于理解；

1、linknode_t  *pnode  指向一个节点；

2、linklist_t list  指向一个整体


二、头结点 head

        我们在前篇提到的顺序存储线性表，如何表达一个空表{ }，是通过list->last = -1来表现的，所谓的空表就是数据域为NULL，而我们的链表有数据域和指针域，我们如何表现空链表呢？这时，就引入了头结点的概念，头结点和其他节点数据类型一样，只是数据域为NULL，head->next = NULL，下面我们看一个创建空链表的函数，如何利用头结点来创建一个空链表：

[cpp] view plaincopy
  1. linklist_t CreateEmptyLinklist()  
  2. {  
  3.     linklist_t list;  
  4.   
  5.     list = (linklist_t)malloc(sizeof(linknode_t));  
  6.     if (NULL != list) {  
  7.         list->next = NULL;  
  8.     }  
  9.     return list;  
  10. }  

只要头结点，链表就还在！

 

三、链表基本运算的相关算法

         链表的运算除了上面的创建空链表，还有数据的插入，删除，查找等函数，链表的运算有各种实现方法，如何写出一个高效的，封装性较好的函数是我们要考虑的，比如数据插入函数，我们就要尽可能考虑所有能出现的结果，比如：1）如果需插入数据的链表是个空表；2）所插入的位置超过了链表的长度；如果我们的函数能包含所有能出现的情况，不仅能大大提高我们的开发效率，也会减少代码的错误率。下面，我们来看看下面的这个链表的插入函数的实现：

[cpp] view plaincopy
  1. int InsertLinklist(linklist_t list, int at, data_t x)  
  2. {  
  3.     linknode_t *node_prev, *node_at, *node_new;  
  4.     int pos_at;  
  5.     int found = 0;  
  6.   
  7.     if (NULL == list) return -1;  
  8.   
  9.     /* at must >= 0  */  
  10.     if (at < 0) return -1;  
  11.       
  12.     /*第一步、分配空间*/  
  13.     node_new = malloc(sizeof(linknode_t));  
  14.     if (NULL == node_new)   
  15.     {  
  16.         return -1;  
  17.     }  
  18.     node_new->data = x; /* assigned value */  
  19.     node_new->next = NULL; /*节点如果插入超过链表长度的位置，会接到尾节点后面，这样，node_new成了尾节点，node_new->next = NULL */  
  20.   
  21.     /*第二步、定位*/  
  22.     node_prev = list;//跟随指针，帮助我们更好的定位  
  23.     node_at = list->next; //遍历指针  
  24.     pos_at = 0;  
  25.     while (NULL != node_at)   
  26.     {  
  27.         if (pos_at == at)  
  28.         {  
  29.             found = 1; //找到正确的位置，跳出循环  
  30.             break;            
  31.         }  
  32.   
  33.         /* move to the next pos_at */  
  34.         node_prev = node_at; //跟随指针先跳到遍历指针的位置  
  35.         node_at = node_at->next;//遍历指针跳到下一个节点的位置  
  36.         pos_at++;  
  37.     }  
  38.   
  39.     /*第三步、插入*/    
  40.     if (found)   
  41.     {  
  42.         /* found = 1,找到正确的位置，插入  */  
  43.         node_new->next = node_at;//插入的节点next指向node_at  
  44.         node_prev->next = node_new;//插入节点的前一个节点  
  45.     }   
  46.     else   
  47.     {  
  48.         /*若是没找到正确的位置，即所插入位置超越了链表的长度，则接到尾节点的后面，同样，这样适用于{ }即空链表，这样我们可以建立一个空链表，利用这个函数，实现链表的初始化*/  
  49.         node_prev->next = node_new;  
  50.     }  
  51.       

这个插入函数可利用性就非常高。

 

下面讲一个完整链表代码贴出：

listlink.h

[cpp] view plaincopy
  1. #ifndef _LNK_LIST_H_  
  2. #define _LNK_LIST_H_  
  3.   
  4. typedef int data_t;  
  5.   
  6. typedef struct node_t {  
  7.     data_t data;  
  8.     struct node_t *next;  
  9. } linknode_t, *linklist_t;  
  10.   
  11. linklist_t CreateEmptyLinklist();  
  12.   
  13. void DestroyLinklist(linklist_t list);  
  14.   
  15. void ClearLinklist(linklist_t list);  
  16.   
  17. int EmptyLinklist(linklist_t list);  
  18.   
  19. int LengthLinklist(linklist_t list);  
  20.   
  21. int GetLinklist(linklist_t list, int at, data_t *x);  
  22.   
  23. int SetLinklist(linklist_t list, int at, data_t x);  
  24.   
  25. int InsertLinklist(linklist_t list, int at, data_t x);  
  26.   
  27. int DeleteLinklist(linklist_t list, int at);  
  28.   
  29. linklist_t ReverseLinklist(linklist_t list);  
  30.   
  31. #endif /* _LNK_LIST_H_ */  

linklist.c

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "linklist.h"  
  4.   
  5. linklist_t CreateEmptyLinklist()  
  6. {  
  7.     linklist_t list;  
  8.     list = (linklist_t)malloc(sizeof(linknode_t));  
  9.   
  10.     if (NULL != list) {  
  11.         list->next = NULL;  
  12.     }  
  13.   
  14.     return list;  
  15. }  
  16.   
  17. void DestroyLinklist(linklist_t list)  
  18. {  
  19.     if (NULL != list) {  
  20.         ClearLinklist(list);  
  21.         free(list);  
  22.     }  
  23. }  
  24.   
  25. void ClearLinklist(linklist_t list)  
  26. {  
  27.     linknode_t *node; /* pointer to the node to be removed */  
  28.     if (NULL == list) return;  
  29.   
  30.     while (NULL != list->next) {  
  31.         node = list->next;  
  32.         list->next = node->next;  
  33.         free(node);  
  34.     }  
  35.     return;  
  36. }  
  37.   
  38. int LengthLinklist(linklist_t list)  
  39. {  
  40.     int len = 0;  
  41.     linknode_t *node; //iterate pointer  
  42.   
  43.     if (NULL == list) return -1;  
  44.   
  45.     node = list->next; // node points to the first data node  
  46.     while (NULL != node) {  
  47.         len++;  
  48.         node = node->next;  
  49.     }  
  50.     return len;  
  51. }  
  52.   
  53. int EmptyLinklist(linklist_t list)  
  54. {  
  55.     if (NULL != list) {  
  56.         if (NULL == list->next) {  
  57.             return 1;  
  58.         } else {  
  59.             return 0;  
  60.         }  
  61.     } else {  
  62.         return -1;  
  63.     }  
  64. }  
  65.   
  66. int GetLinklist(linklist_t list, int at, data_t *x)  
  67. {  
  68.     linknode_t *node;   /* used for iteration */  
  69.     int pos;        /* used for iteration and compare with */  
  70.   
  71.     if (NULL == list) return -1;  
  72.     /* at must >= 0 */  
  73.     if (at < 0) return -1;  
  74.     /* start from the first element */  
  75.     node = list->next;  
  76.     pos = 0;  
  77.     while (NULL != node) {  
  78.         if (at == pos) {  
  79.             if (NULL != x) {  
  80.                 *x = node->data;  
  81.             }  
  82.             return 0;             
  83.         }  
  84.         /* move to the next */  
  85.         node = node->next;  
  86.         pos++;  
  87.     }  
  88.     return -1;  
  89. }  
  90.   
  91.   
  92.   
  93. int SetLinklist(linklist_t list, int at, data_t x)  
  94. {  
  95.     linknode_t *node; /* used for iteration */  
  96.     int pos;  
  97.     int found = 0;  
  98.   
  99.     if (!list) return -1;  
  100.     /* at must >= 0 */  
  101.     if (at < 0) return -1;  
  102.     /* start from the first element */  
  103.     node = list->next;  
  104.     pos = 0;  
  105.     while (NULL != node) {  
  106.         if (at == pos) {   
  107.             found = 1; /* found the position */  
  108.             node->data = x;  
  109.             break;            
  110.         }  
  111.         /* move to the next */  
  112.         node = node->next;  
  113.         pos++;  
  114.     }  
  115.     if (1 == found) {  
  116.         return 0;  
  117.     } else {  
  118.         return -1;  
  119.     }  
  120. }  
  121.   
  122. int InsertLinklist(linklist_t list, int at, data_t x)  
  123. {  
  124.     /*  
  125.      * node_at and pos_at are used to locate the position of node_at. 
  126.      * node_prev follows the node_at and always points to previous node  
  127.      *  of node_at. 
  128.      * node_new is used to point to the new node to be inserted. 
  129.      */  
  130.     linknode_t  *node_prev, *node_at, *node_new;  
  131.     int     pos_at;  
  132.     int         found = 0;  
  133.   
  134.     if (NULL == list) return -1;  
  135.   
  136.     /* at must >= 0 */  
  137.     if (at < 0) return -1;  
  138.   
  139.     node_new = malloc(sizeof(linknode_t));  
  140.     if (NULL == node_new) {  
  141.         return -1;  
  142.     }  
  143.     node_new->data = x; /* assigned value */  
  144.     node_new->next = NULL;  
  145.   
  146.     node_prev = list;  
  147.     node_at = list->next;  
  148.     pos_at = 0;  
  149.     while (NULL != node_at) {  
  150.         if (pos_at == at) {  
  151.             /*  
  152.              * found the node 'at' 
  153.              */   
  154.             found = 1;  
  155.             break;            
  156.         }  
  157.         /* move to the next pos_at */  
  158.         node_prev = node_at;  
  159.         node_at = node_at->next;  
  160.         pos_at++;  
  161.     }  
  162.       
  163.     if (found) {  
  164.         /* insert */  
  165.         node_new->next = node_at;  
  166.         node_prev->next = node_new;  
  167.     } else {  
  168.         /*  
  169.          * If not found, means the provided "at" 
  170.          * exceeds the upper limit of the list, just  
  171.          * append the new node to the end of the list. 
  172.          */  
  173.         node_prev->next = node_new;  
  174.     }  
  175.     return 0;  
  176. }  
  177.   
  178. int DeleteLinklist(linklist_t list, int at)  
  179. {  
  180.     /*  
  181.      * node_at and pos_at are used to locate the position of node_at. 
  182.      * node_prev follows the node_at and always points to previous node  
  183.      *  of node_at. 
  184.      */  
  185.   
  186.     linknode_t  *node_prev, *node_at;  
  187.     int     pos_at;  
  188.     int         found = 0;  
  189.   
  190.     if (!list) return -1;  
  191.     /* at must >= 0 */  
  192.     if (at < 0) return -1;  
  193.   
  194.     node_prev = list;  
  195.     node_at = list->next;  
  196.     pos_at = 0;   
  197.   
  198.     while (NULL != node_at) {  
  199.         if (pos_at == at) {  
  200.             /*  
  201.              * found the node 'at' 
  202.              */   
  203.             found = 1;  
  204.             break;            
  205.         }  
  206.         /* move to the next pos_at */  
  207.         node_prev = node_at;  
  208.         node_at = node_at->next;  
  209.         pos_at++;  
  210.     }  
  211.     if (found) {  
  212.         /* remove */  
  213.         node_prev->next = node_at->next;  
  214.         free(node_at);  
  215.         return  0;  
  216.     } else {  
  217.         return -1;  
  218.     }  
  219. }  
  220.   
  221. linklist_t ReverseLinklist(linklist_t list)  
  222. {  
  223.     linknode_t *node;   /* iterator */  
  224.     linknode_t *node_prev;  /* previous node of iterator */  
  225.     linknode_t *node_next;  /* next node of iterator,  
  226.                  * used to backup next of iterator  
  227.                  */  
  228.     if (NULL == list) return NULL;  
  229.     node_prev = NULL;  
  230.     node = list->next;  
  231.     while (NULL != node) {  
  232.         /* 
  233.          * step1: backup node->next 
  234.          * due to the next of iterator will be 
  235.          * modified in step2 
  236.          */  
  237.         node_next = node->next;  
  238.         /*  
  239.          * when iterator reaches the last node  
  240.          * of original list, make the list head 
  241.          * point to the last node, so the original 
  242.          * last one becomes the first one. 
  243.          */  
  244.   
  245.         if (NULL == node_next) {  
  246.             list->next = node;  
  247.         }  
  248.   
  249.         /*  
  250.          * step2: reverse the linkage between nodes 
  251.          * make the node pointer to the previous node, 
  252.          * not the next node 
  253.          */       
  254.         node->next = node_prev;        
  255.         /*  
  256.          * step3: move forward  
  257.          */  
  258.   
  259.         node_prev = node;  
  260.         node = node_next;  
  261.     }  
  262.     return list;  
  263. }  

main.c

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "linklist.h"  
  4.   
  5. int main()  
  6. {  
  7.     int i;  
  8.     data_t x;  
  9.     linklist_t p;  
  10.     p = CreateEmptyLinklist();  
  11.     data_t a[10] = {1,3,5,7,9,11,13,15,17,19};  
  12.   
  13.     for(i = 0;i < 10;i++)  
  14.     {  
  15.         InsertLinklist(p,i,a[i]);  
  16.     }  
  17.   
  18.     ReverseLinklist(p);  
  19.     printf("The length of the list is:%d\n",LengthLinklist(p));  
  20.       
  21.     GetLinklist(p,4,&x);  
  22.     printf("The NO.4 of this list is:%d\n",x);  
  23.   
  24.     SetLinklist(p,4,100);  
  25.     GetLinklist(p,4,&x);  
  26.     printf("After updating!The No.4 0f this list is:%d\n",x);  
  27.   
  28.     DeleteLinklist(p,4);  
  29.     printf("After updating!The length of the list is:%d\n",LengthLinklist(p));  
  30.     GetLinklist(p,4,&x);  
  31.     printf("After updating!The No.4 0f this list is:%d\n",x);  
  32.   
  33.     ReverseLinklist(p);  
  34.       
  35.     ClearLinklist(p);  
  36.     if(EmptyLinklist(p))  
  37.         printf("This list is empty!\n");  
  38.     DestroyLinklist(p);  
  39.     printf("This list is destroyed!\n");  
  40.   
  41.     return 0;  
  42.       
  43. }  

执行结果如下：

[cpp] view plaincopy
  1. fs@ubuntu:~/qiang/list/list2$ ./Test  
  2. The length of the list is:10  
  3. The NO.4 of this list is:11  
  4. After updating!The No.4 0f this list is:100  
  5. After updating!The length of the list is:9  
  6. After updating!The No.4 0f this list is:9  
  7. This list is empty!  
  8. This list is destroyed! 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/402415.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

分页插件--根据Bootstrap Paginator改写的js插件

分页插件--根据Bootstrap Paginator改写的js插件

刚刚出来实习&#xff0c;之前实习的公司有一个分页插件&#xff0c;和后端的数据字典约定好了的&#xff0c;基本上是看不到内部是怎么实现的&#xff0c;新公司是做WPF的&#xff0c;好像对于ASP.NET的东西不多&#xff0c;导师扔了一个小系统给我和另一个同事&#xff0c;指…
阅读更多...
Linux C 算法分析初步

Linux C 算法分析初步

提到算法&#xff0c;必须提到数据结构&#xff0c;我们要知道一个著名公式&#xff1a; 数据结构 算法 程序 我们先看看下面这张图&#xff1a; 算法是什么&#xff1f;算法是一个有穷规则&#xff08;或语句、指令&#xff09;的有续集和。他确定了解决某一问题的一个运算序…
阅读更多...
hive实例，GPRS流量统计

hive实例，GPRS流量统计

2019独角兽企业重金招聘Python工程师标准>>> 最近面试&#xff0c;发现很多公司在使用hive对数据进行处理。 hive是hadoop家族成员&#xff0c;是一种解析like sql语句的框架。它封装了常用MapReduce任务&#xff0c;让你像执行sql一样操作存储在HDFS的表。 hive的表…
阅读更多...
Linux C 数据结构—-循环链表

Linux C 数据结构—-循环链表

前面我们学习了单向链表&#xff0c;现在介绍单向循环链表&#xff0c;单向循环链表是单链表的一种改进&#xff0c;若将单链表的首尾节点相连&#xff0c;便构成单向循环链表结构&#xff0c;如下图&#xff1a; 对于一个循环链表来说,其首节点和末节点被连接在一起。这种方式…
阅读更多...
预备作业03 20162320刘先润

预备作业03 20162320刘先润

第一次编代码 这几周自学了Linux基础入门&#xff0c;有好多想吐槽的地方&#xff0c;所以这篇随笔是带有半吐槽性质的&#xff0c;这是我学完后最真实的感受 我在电脑上按照教程安装了虚拟机&#xff0c;对于Linux这个完全陌生的概念也稍微算是有些理解&#xff0c;但是还有很…
阅读更多...
JTable 失去焦点时取消编辑状态

JTable 失去焦点时取消编辑状态

为什么80%的码农都做不了架构师&#xff1f;>>> reference&#xff1a; http://tips4java.wordpress.com/2008/12/12/table-stop-editing/ 当JTable的单元格处于编辑状态时&#xff0c;如果用户触发以下事件&#xff0c;表格就会退出编辑状态&#xff0c;进而调用T…
阅读更多...
Linux C 数据结构——栈

Linux C 数据结构——栈

还是先把这张图贴出来&#xff0c;以便对比和理解 栈是限制在一段进行插入操作和删除操作的线性表&#xff08;俗称堆栈&#xff09;&#xff0c;允许进行操作的一端称为“栈顶”&#xff0c;另一固定端称为“栈底”&#xff0c;当栈中没有元素称为“空栈”。特点&#xff1a;先…
阅读更多...
常用的HTTP状态码

常用的HTTP状态码

2019独角兽企业重金招聘Python工程师标准>>> 第一、成功的状态码&#xff1a; 1&#xff09;200 OK – 服务器成功返回网页 2&#xff09;304 Not Modified – 未修改 第二、失败的状态码&#xff1a; 3&#xff09;404 Not F…
阅读更多...
Linux C 数据结构——队列

Linux C 数据结构——队列

还是先放这张图&#xff0c;以便对比和理解&#xff1a; 队列是限制在两端进行插入操作和删除操作的线性表&#xff0c;允许进行存入操作的一端称为“队尾”&#xff0c;允许进行删除操作的一端称为“队头”。当线性表中没有元素时&#xff0c;称为“空队”。特点&#xff1a;先…
阅读更多...
如何使用FF的Firebug组件中的net工具查看页面元素加载消耗时间

如何使用FF的Firebug组件中的net工具查看页面元素加载消耗时间

1.安装FF的Firebug组件&#xff1a;点击FF的Tools的Add-ons菜单&#xff0c;输入Firebug关键字&#xff0c;并选择合适的版本Install。 2.安装完毕后地址栏右边会出现一个小虫图标&#xff0c;右边还有一个下拉箭头。如下图&#xff1a; 3.点击下拉箭头&#xff0c;选择“on fo…
阅读更多...
Linux C 数据结构——二叉树

Linux C 数据结构——二叉树

先放这张图&#xff1a; 可以看出&#xff0c;树是非线性结构&#xff1b; 一、树的概念 树&#xff08;tree&#xff09;是n(n>0)个节点的有限集合T&#xff0c;它满足两个条件&#xff1a; 1&#xff09;有且仅有一个特定的称为根&#xff08;root&#xff09;的节点&…
阅读更多...
Linux C 算法——查找

Linux C 算法——查找

所谓“查找”记为在一个含有众多的数据元素&#xff08;或记录&#xff09;的查找表中找出某个“特定的”数据&#xff0c;即在给定信息集上寻找特定信息元素的过程。 为了便于讨论&#xff0c;必须给出这个“特定的”词的确切含义。首先&#xff0c;引入一个“关键字”的概念&…
阅读更多...
SharePoint项目中新建类库的错误处理及项目建设中遇到的问题总结

SharePoint项目中新建类库的错误处理及项目建设中遇到的问题总结

第一次SP项目总监遇到各种问题&#xff0c;以下是总结&#xff1a;问题1.创建SP项目的时候“场解决方案”跟“沙盒解决方案”是有区别的&#xff0c;具体可以看MSDN官方文档&#xff0c;这里简单摘抄如下&#xff1a;1&#xff09;场解决方案&#xff1a;承载与W3WP.exe中&…
阅读更多...
ECharts学习（1）--简单图表的绘制

ECharts学习（1）--简单图表的绘制

1.获取ECharts 官网 下载&#xff1a;http://echarts.baidu.com/download.html 2.在html页面中引入ECharts文件 <!DOCTYPE html> <html><head><meta charset"UTF-8"><title>ECharts练习</title><script type"text/javas…
阅读更多...
Linux C 算法——排序

Linux C 算法——排序

排序(Sort)是将无序的记录序列&#xff08;或称文件&#xff09;调整成有序的序列。 为了方便讨论&#xff0c;在此首先要对排序下一个确切的定义&#xff1a; 假设含有n个记录的序列为 { R1、R2、&#xff0c;。。。Rn } 其相应的关键字序列为 {K1、K2&#xff0c;。。。。Kn}…
阅读更多...
【Phpstorm】Property accessed via magic method

【Phpstorm】Property accessed via magic method

阅读更多...
JSON.parse 解析json字符串时，遇换行符报错

JSON.parse 解析json字符串时，遇换行符报错

Json字符串转换成Json对象时候&#xff0c;有两种方式&#xff1a; 假设d是json字符串&#xff1a; 1&#xff0c;eval(( d ))。 2&#xff0c;JSON.parse(d)&#xff1b; 但是以上方式有隐患&#xff0c;如果Json字符串有换行的话&#xff0c;这样转换就会报错。 假如有…
阅读更多...
文件I/O和标准I/O的区别

文件I/O和标准I/O的区别

一、先来了解下什么是文件I/O和标准I/O&#xff1a; 文件I/O&#xff1a;文件I/O称之为不带缓存的IO&#xff08;unbuffered I/O)。不带缓存指的是每个read&#xff0c;write都调用内核中的一个系统调用。也就是一般所说的低级I/O——操作系统提供的基本IO服务&#xff0c;与os…
阅读更多...
程序集、应用程序配置及App.config和YourSoft.exe.config .

程序集、应用程序配置及App.config和YourSoft.exe.config .

转自&#xff1a;http://www.cnblogs.com/luminji/archive/2010/10/21/1857339.html 什么是程序集 程序集标识属性 强名称的程序集 强名称工作原理配置文件使用 DEVPATH 查找程序集指定要使用的运行库版本Appconfig和YourSoftexeconfig本章概要&#xff1a; 1&#xff1a;什么是…
阅读更多...
[Android]在Dagger 2中使用RxJava来进行异步注入（翻译）

[Android]在Dagger 2中使用RxJava来进行异步注入（翻译）

以下内容为原创&#xff0c;欢迎转载&#xff0c;转载请注明 来自天天博客&#xff1a;http://www.cnblogs.com/tiantianbyconan/p/6236646.html 在Dagger 2中使用RxJava来进行异步注入 原文&#xff1a;http://frogermcs.github.io/async-injection-in-dagger-2-with-rxjava 几…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023