【转载】数组、单链表和双链表介绍以及双向链表的C/C++/Java实现-白红宇

【转载】数组、单链表和双链表介绍以及双向链表的C/C++/Java实现

阅读量：5119 次

发布时间：2019-06-13

本文共 19251 字，大约阅读时间需要 64 分钟。

本博客转自大神，链接地址http://www.cnblogs.com/skywang12345/p/3561803.html

概要

线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本章先介绍线性表的几个基本组成部分：数组、单向链表、双向链表；随后给出双向链表的C、C++和Java三种语言的实现。内容包括：

转载请注明出处：

更多内容

数组

数组有上界和下界，数组的元素在上下界内是连续的。

存储10,20,30,40,50的数组的示意图如下：

数组的特点是：数据是连续的；随机访问速度快。

数组中稍微复杂一点的是多维数组和动态数组。对于C语言而言，多维数组本质上也是通过一维数组实现的。至于动态数组，是指数组的容量能动态增长的数组；对于C语言而言，若要提供动态数组，需要手动实现；而对于C++而言，STL提供了Vector；对于Java而言，Collection集合中提供了ArrayList和Vector。

单向链表

单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针。

单链表的示意图如下：

表头为空，表头的后继节点是"节点10"(数据为10的节点)，"节点10"的后继节点是"节点20"(数据为10的节点)，...

单链表删除节点

删除"节点30"

删除之前："节点20" 的后继节点为"节点30"，而"节点30" 的后继节点为"节点40"。

删除之后："节点20" 的后继节点为"节点40"。

单链表添加节点

在"节点10"与"节点20"之间添加"节点15"

添加之前："节点10" 的后继节点为"节点20"。

添加之后："节点10" 的后继节点为"节点15"，而"节点15" 的后继节点为"节点20"。

单链表的特点是：节点的链接方向是单向的；相对于数组来说，单链表的的随机访问速度较慢，但是单链表删除/添加数据的效率很高。

双向链表

双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

双链表的示意图如下：

表头为空，表头的后继节点为"节点10"(数据为10的节点)；"节点10"的后继节点是"节点20"(数据为10的节点)，"节点20"的前继节点是"节点10"；"节点20"的后继节点是"节点30"，"节点30"的前继节点是"节点20"；...；末尾节点的后继节点是表头。

双链表删除节点

删除"节点30"

删除之前："节点20"的后继节点为"节点30"，"节点30" 的前继节点为"节点20"。"节点30"的后继节点为"节点40"，"节点40" 的前继节点为"节点30"。

删除之后："节点20"的后继节点为"节点40"，"节点40" 的前继节点为"节点20"。

双链表添加节点

在"节点10"与"节点20"之间添加"节点15"

添加之前："节点10"的后继节点为"节点20"，"节点20" 的前继节点为"节点10"。

添加之后："节点10"的后继节点为"节点15"，"节点15" 的前继节点为"节点10"。"节点15"的后继节点为"节点20"，"节点20" 的前继节点为"节点15"。

下面介绍双链表的实现，分别介绍C/C++/Java三种实现。

1. C实现双链表

实现代码

双向链表头文件(double_link.h)

1 #ifndef _DOUBLE_LINK_H 2 #define _DOUBLE_LINK_H 3  4 // 新建“双向链表”。成功，返回表头；否则，返回NULL 5 extern int create_dlink(); 6 // 撤销“双向链表”。成功，返回0；否则，返回-1 7 extern int destroy_dlink(); 8  9 // “双向链表是否为空”。为空的话返回1；否则，返回0。10 extern int dlink_is_empty();11 // 返回“双向链表的大小”12 extern int dlink_size();13 14 // 获取“双向链表中第index位置的元素”。成功，返回节点指针；否则，返回NULL。15 extern void* dlink_get(int index);16 // 获取“双向链表中第1个元素”。成功，返回节点指针；否则，返回NULL。17 extern void* dlink_get_first();18 // 获取“双向链表中最后1个元素”。成功，返回节点指针；否则，返回NULL。19 extern void* dlink_get_last();20 21 // 将“value”插入到index位置。成功，返回0；否则，返回-1。22 extern int dlink_insert(int index, void *pval);23 // 将“value”插入到表头位置。成功，返回0；否则，返回-1。24 extern int dlink_insert_first(void *pval);25 // 将“value”插入到末尾位置。成功，返回0；否则，返回-1。26 extern int dlink_append_last(void *pval);27 28 // 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-129 extern int dlink_delete(int index);30 // 删除第一个节点。成功，返回0；否则，返回-131 extern int dlink_delete_first();32 // 删除组后一个节点。成功，返回0；否则，返回-133 extern int dlink_delete_last();34 35 #endif

View Code

双向链表实现文件(double_link.c)

1 #include 
        
           2 #include 
         
            3   4 /**  5  * C 语言实现的双向链表，能存储任意数据。  6  *  7  * @author skywang  8  * @date 2013/11/07  9  */ 10 // 双向链表节点 11 typedef struct tag_node  12 { 13     struct tag_node *prev; 14     struct tag_node *next; 15     void* p; 16 }node; 17  18 // 表头。注意，表头不存放元素值！！！ 19 static node *phead=NULL; 20 // 节点个数。 21 static int  count=0; 22  23 // 新建“节点”。成功，返回节点指针；否则，返回NULL。 24 static node* create_node(void *pval) 25 { 26     node *pnode=NULL; 27     pnode = (node *)malloc(sizeof(node)); 28     if (!pnode) 29     { 30         printf("create node error!\n"); 31         return NULL; 32     } 33     // 默认的，pnode的前一节点和后一节点都指向它自身 34     pnode->prev = pnode->next = pnode; 35     // 节点的值为pval 36     pnode->p = pval; 37  38     return pnode; 39 } 40  41 // 新建“双向链表”。成功，返回0；否则，返回-1。 42 int create_dlink() 43 { 44     // 创建表头 45     phead = create_node(NULL); 46     if (!phead) 47         return -1; 48  49     // 设置“节点个数”为0 50     count = 0; 51  52     return 0; 53 } 54  55 // “双向链表是否为空” 56 int dlink_is_empty() 57 { 58     return count == 0; 59 } 60  61 // 返回“双向链表的大小” 62 int dlink_size() { 63     return count; 64 } 65  66 // 获取“双向链表中第index位置的节点” 67 static node* get_node(int index)  68 { 69     if (index<0 || index>=count) 70     { 71         printf("%s failed! index out of bound!\n", __func__); 72         return NULL; 73     } 74  75     // 正向查找 76     if (index <= (count/2)) 77     { 78         int i=0; 79         node *pnode=phead->next; 80         while ((i++) < index)  81             pnode = pnode->next; 82  83         return pnode; 84     } 85  86     // 反向查找 87     int j=0; 88     int rindex = count - index - 1; 89     node *rnode=phead->prev; 90     while ((j++) < rindex)  91         rnode = rnode->prev; 92  93     return rnode; 94 } 95  96 // 获取“第一个节点” 97 static node* get_first_node()  98 { 99     return get_node(0);100 }101 102 // 获取“最后一个节点”103 static node* get_last_node() 104 {105     return get_node(count-1);106 }107 108 // 获取“双向链表中第index位置的元素”。成功，返回节点值；否则，返回-1。109 void* dlink_get(int index)110 {111     node *pindex=get_node(index);112     if (!pindex) 113     {114         printf("%s failed!\n", __func__);115         return NULL;116     }117 118     return pindex->p;119 120 }121 122 // 获取“双向链表中第1个元素的值”123 void* dlink_get_first()124 {125     return dlink_get(0);126 }127 128 // 获取“双向链表中最后1个元素的值”129 void* dlink_get_last()130 {131     return dlink_get(count-1);132 }133 134 // 将“pval”插入到index位置。成功，返回0；否则，返回-1。135 int dlink_insert(int index, void* pval) 136 {137     // 插入表头138     if (index==0)139         return dlink_insert_first(pval);140 141     // 获取要插入的位置对应的节点142     node *pindex=get_node(index);143     if (!pindex) 144         return -1;145 146     // 创建“节点”147     node *pnode=create_node(pval);148     if (!pnode)149         return -1;150 151     pnode->prev = pindex->prev;152     pnode->next = pindex;153     pindex->prev->next = pnode;154     pindex->prev = pnode;155     // 节点个数+1156     count++;157 158     return 0;159 }160 161 // 将“pval”插入到表头位置162 int dlink_insert_first(void *pval) 163 {164     node *pnode=create_node(pval);165     if (!pnode)166         return -1;167 168     pnode->prev = phead;169     pnode->next = phead->next;170     phead->next->prev = pnode;171     phead->next = pnode;172     count++;173     return 0;174 }175 176 // 将“pval”插入到末尾位置177 int dlink_append_last(void *pval) 178 {179     node *pnode=create_node(pval);180     if (!pnode)181         return -1;182     183     pnode->next = phead;184     pnode->prev = phead->prev;185     phead->prev->next = pnode;186     phead->prev = pnode;187     count++;188     return 0;189 }190 191 // 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1。192 int dlink_delete(int index)193 {194     node *pindex=get_node(index);195     if (!pindex) 196     {197         printf("%s failed! the index in out of bound!\n", __func__);198         return -1;199     }200 201     pindex->next->prev = pindex->prev;202     pindex->prev->next = pindex->next;203     free(pindex);204     count--;205 206     return 0;207 }    208 209 // 删除第一个节点210 int dlink_delete_first() 211 {212     return dlink_delete(0);213 }214 215 // 删除组后一个节点216 int dlink_delete_last() 217 {218     return dlink_delete(count-1);219 }220 221 // 撤销“双向链表”。成功，返回0；否则，返回-1。222 int destroy_dlink()223 {224     if (!phead)225     {226         printf("%s failed! dlink is null!\n", __func__);227         return -1;228     }229 230     node *pnode=phead->next;231     node *ptmp=NULL;232     while(pnode != phead)233     {234         ptmp = pnode;235         pnode = pnode->next;236         free(ptmp);237     }238 239     free(phead);240     phead = NULL;241     count = 0;242 243     return 0;244 }

View Code

双向链表测试程序(dlink_test.c)

1 #include 
        
           2 #include "double_link.h"  3   4 /**  5  * C 语言实现的双向链表的测试程序。  6  *  7  * (01) int_test()  8  *      演示向双向链表操作“int数据”。  9  * (02) string_test() 10  *      演示向双向链表操作“字符串数据”。 11  * (03) object_test() 12  *      演示向双向链表操作“对象”。 13  * 14  * @author skywang 15  * @date 2013/11/07 16  */ 17  18 // 双向链表操作int数据 19 void int_test() 20 { 21     int iarr[4] = {
      10, 20, 30, 40}; 22  23     printf("\n----%s----\n", __func__); 24     create_dlink();        // 创建双向链表 25  26     dlink_insert(0, &iarr[0]);    // 向双向链表的表头插入数据 27     dlink_insert(0, &iarr[1]);    // 向双向链表的表头插入数据 28     dlink_insert(0, &iarr[2]);    // 向双向链表的表头插入数据 29  30     printf("dlink_is_empty()=%d\n", dlink_is_empty());    // 双向链表是否为空 31     printf("dlink_size()=%d\n", dlink_size());            // 双向链表的大小 32  33     // 打印双向链表中的全部数据 34     int i; 35     int *p; 36     int sz = dlink_size(); 37     for (i=0; i
         
          id, p->name);108     }109 110     destroy_dlink();111 }112 113 int main()114 {115     int_test();        // 演示向双向链表操作“int数据”。116     string_test();    // 演示向双向链表操作“字符串数据”。117     object_test();    // 演示向双向链表操作“对象”。118 119     return 0;120 }

View Code

运行结果

----int_test----dlink_is_empty()=0dlink_size()=3dlink_get(0)=30dlink_get(1)=20dlink_get(2)=10----string_test----dlink_is_empty()=0dlink_size()=3dlink_get(0)=thirtydlink_get(1)=twentydlink_get(2)=ten----object_test----dlink_is_empty()=0dlink_size()=3dlink_get(0)=[30, vic]dlink_get(1)=[20, jody]dlink_get(2)=[10, sky]

2. C++实现双链表

实现代码

双向链表文件(DoubleLink.h)

1 #ifndef DOUBLE_LINK_HXX  2 #define DOUBLE_LINK_HXX  3   4 #include 
        
           5 using namespace std;  6   7 template
         
             8 struct DNode   9 { 10     public: 11         T value; 12         DNode *prev; 13         DNode *next; 14     public: 15         DNode() { } 16         DNode(T t, DNode *prev, DNode *next) { 17             this->value = t; 18             this->prev  = prev; 19             this->next  = next; 20            } 21 }; 22  23 template
          
             24 class DoubleLink  25 { 26     public: 27         DoubleLink(); 28         ~DoubleLink(); 29  30         int size(); 31         int is_empty(); 32  33         T get(int index); 34         T get_first(); 35         T get_last(); 36  37         int insert(int index, T t); 38         int insert_first(T t); 39         int append_last(T t); 40  41         int del(int index); 42         int delete_first(); 43         int delete_last(); 44  45     private: 46         int count; 47         DNode
           
             *phead; 48     private: 49         DNode
            
              *get_node(int index); 50 }; 51  52 template
             
               53 DoubleLink
              
               ::DoubleLink() : count(0) 54 { 55 // 创建“表头”。注意：表头没有存储数据！ 56 phead = new DNode
               
                (); 57 phead->prev = phead->next = phead; 58 // 设置链表计数为0 59 //count = 0; 60 } 61 62 // 析构函数 63 template
                
                  64 DoubleLink
                 
                  ::~DoubleLink() 65 { 66 // 删除所有的节点 67 DNode
                  
                   * ptmp; 68 DNode
                   
                    * pnode = phead->next; 69 while (pnode != phead) 70 { 71 ptmp = pnode; 72 pnode=pnode->next; 73 delete ptmp; 74 } 75 76 // 删除"表头" 77 delete phead; 78 phead = NULL; 79 } 80 81 // 返回节点数目 82 template
                    
                      83 int DoubleLink
                     
                      ::size() 84 { 85 return count; 86 } 87 88 // 返回链表是否为空 89 template
                      
                        90 int DoubleLink
                       
                        ::is_empty() 91 { 92 return count==0; 93 } 94 95 // 获取第index位置的节点 96 template
                        
                          97 DNode
                         
                          * DoubleLink
                          
                           ::get_node(int index) 98 { 99 // 判断参数有效性100 if (index<0 || index>=count)101 {102 cout << "get node failed! the index in out of bound!" << endl;103 return NULL;104 }105 106 // 正向查找107 if (index <= count/2)108 {109 int i=0;110 DNode
                           
                            * pindex = phead->next;111 while (i++ < index) {112 pindex = pindex->next;113 }114 115 return pindex;116 }117 118 // 反向查找119 int j=0;120 int rindex = count - index -1;121 DNode
                            
                             * prindex = phead->prev;122 while (j++ < rindex) {123 prindex = prindex->prev;124 }125 126 return prindex;127 }128 129 // 获取第index位置的节点的值130 template
                             
                              131 T DoubleLink
                              
                               ::get(int index) 132 {133 return get_node(index)->value;134 }135 136 // 获取第1个节点的值137 template
                               
                                138 T DoubleLink
                                
                                 ::get_first() 139 {140 return get_node(0)->value;141 }142 143 // 获取最后一个节点的值144 template
                                 
                                  145 T DoubleLink
                                  
                                   ::get_last() 146 {147 return get_node(count-1)->value;148 }149 150 // 将节点插入到第index位置之前151 template
                                   
                                    152 int DoubleLink
                                    
                                     ::insert(int index, T t) 153 {154 if (index == 0)155 return insert_first(t);156 157 DNode
                                     
                                      * pindex = get_node(index);158 DNode
                                      
                                       * pnode = new DNode
                                       
                                        (t, pindex->prev, pindex);159 pindex->prev->next = pnode;160 pindex->prev = pnode;161 count++;162 163 return 0;164 }165 166 // 将节点插入第一个节点处。167 template
                                        
                                         168 int DoubleLink
                                         
                                          ::insert_first(T t) 169 {170 DNode
                                          
                                           * pnode = new DNode
                                           
                                            (t, phead, phead->next);171 phead->next->prev = pnode;172 phead->next = pnode;173 count++;174 175 return 0;176 }177 178 // 将节点追加到链表的末尾179 template
                                            
                                             180 int DoubleLink
                                             
                                              ::append_last(T t) 181 {182 DNode
                                              
                                               * pnode = new DNode
                                               
                                                (t, phead->prev, phead);183 phead->prev->next = pnode;184 phead->prev = pnode;185 count++;186 187 return 0;188 }189 190 // 删除index位置的节点191 template
                                                
                                                 192 int DoubleLink
                                                 
                                                  ::del(int index) 193 {194 DNode
                                                  
                                                   * pindex = get_node(index);195 pindex->next->prev = pindex->prev;196 pindex->prev->next = pindex->next;197 delete pindex;198 count--;199 200 return 0;201 }202 203 // 删除第一个节点204 template
                                                   
                                                    205 int DoubleLink
                                                    
                                                     ::delete_first() 206 {207 return del(0);208 }209 210 // 删除最后一个节点211 template
                                                     
                                                      212 int DoubleLink
                                                      
                                                       ::delete_last() 213 {214 return del(count-1);215 }216 217 #endif

View Code

双向链表测试文件(DlinkTest.cpp)

1 #include 
        
           2 #include "DoubleLink.h"  3 using namespace std;  4   5 // 双向链表操作int数据  6 void int_test()  7 {  8     int iarr[4] = {
      10, 20, 30, 40};  9  10     cout << "\n----int_test----" << endl; 11     // 创建双向链表 12     DoubleLink
         
          * pdlink = new DoubleLink
          
           (); 13  14     pdlink->insert(0, 20);        // 将 20 插入到第一个位置 15     pdlink->append_last(10);    // 将 10 追加到链表末尾 16     pdlink->insert_first(30);    // 将 30 插入到第一个位置 17  18     // 双向链表是否为空 19     cout << "is_empty()=" << pdlink->is_empty() <
           
            * pdlink = new DoubleLink
            
             (); 36  37     pdlink->insert(0, sarr[1]);        // 将 sarr中第2个元素 插入到第一个位置 38     pdlink->append_last(sarr[0]);    // 将 sarr中第1个元素  追加到链表末尾 39     pdlink->insert_first(sarr[2]);    // 将 sarr中第3个元素  插入到第一个位置 40  41     // 双向链表是否为空 42     cout << "is_empty()=" << pdlink->is_empty() <
             
              * pdlink = new DoubleLink
              
               (); 72 73 pdlink->insert(0, arr_stu[1]); // 将 arr_stu中第2个元素 插入到第一个位置 74 pdlink->append_last(arr_stu[0]); // 将 arr_stu中第1个元素 追加到链表末尾 75 pdlink->insert_first(arr_stu[2]); // 将 arr_stu中第3个元素 插入到第一个位置 76 77 // 双向链表是否为空 78 cout << "is_empty()=" << pdlink->is_empty() <
               
                << p.id << ", " << p.name <<"]" <

View Code

示例说明

在上面的示例中，我将双向链表的"声明"和"实现"都放在头文件中。而编程规范告诫我们：将类的声明和实现分离，在头文件(.h文件或.hpp)中尽量只包含声明，而在实现文件(.cpp文件)中负责实现！

那么为什么要这么做呢？这是因为，在双向链表的实现中，采用了模板；而C++编译器不支持对模板的分离式编译！简单点说，如果在DoubleLink.h中声明，而在DoubleLink.cpp中进行实现的话；当我们在其他类中创建DoubleLink的对象时，会编译出错。具体原因，可以参考""。

运行结果

----int_test----is_empty()=0size()=3pdlink(0)=30pdlink(1)=20pdlink(2)=10----string_test----is_empty()=0size()=3pdlink(0)=thirtypdlink(1)=twentypdlink(2)=ten----object_test----is_empty()=0size()=3pdlink(0)=[30, vic]pdlink(1)=[20, jody]pdlink(2)=[10, sky]

3. Java实现双链表

实现代码

双链表类(DoubleLink.java)

1 /**  2  * Java 实现的双向链表。   3  * 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList  4  *  5  * @author skywang  6  * @date 2013/11/07  7  */  8 public class DoubleLink
        
          {  9  10     // 表头 11     private DNode
         
           mHead; 12     // 节点个数 13     private int mCount; 14  15     // 双向链表“节点”对应的结构体 16     private class DNode
          
            { 17         public DNode prev; 18         public DNode next; 19         public T value; 20  21         public DNode(T value, DNode prev, DNode next) { 22             this.value = value; 23             this.prev = prev; 24             this.next = next; 25         } 26     } 27  28     // 构造函数 29     public DoubleLink() { 30         // 创建“表头”。注意：表头没有存储数据！ 31         mHead = new DNode
           
            (null, null, null); 32         mHead.prev = mHead.next = mHead; 33         // 初始化“节点个数”为0 34         mCount = 0; 35     } 36  37     // 返回节点数目 38     public int size() { 39         return mCount; 40     } 41  42     // 返回链表是否为空 43     public boolean isEmpty() { 44         return mCount==0; 45     } 46  47     // 获取第index位置的节点 48     private DNode
            
              getNode(int index) { 49         if (index<0 || index>=mCount) 50             throw new IndexOutOfBoundsException(); 51  52         // 正向查找 53         if (index <= mCount/2) { 54             DNode
             
               node = mHead.next; 55 for (int i=0; i
              
                rnode = mHead.prev; 63 int rindex = mCount - index -1; 64 for (int j=0; j
               
                 node = new DNode
                
                 (t, mHead, mHead.next); 89 mHead.next.prev = node; 90 mHead.next = node; 91 mCount++; 92 return ; 93 } 94 95 DNode
                 
                   inode = getNode(index); 96 DNode
                  
                    tnode = new DNode
                   
                    (t, inode.prev, inode); 97 inode.prev.next = tnode; 98 inode.next = tnode; 99 mCount++;100 return ;101 }102 103 // 将节点插入第一个节点处。104 public void insertFirst(T t) {105 insert(0, t);106 }107 108 // 将节点追加到链表的末尾109 public void appendLast(T t) {110 DNode
                    
                      node = new DNode
                     
                      (t, mHead.prev, mHead);111 mHead.prev.next = node;112 mHead.prev = node;113 mCount++;114 }115 116 // 删除index位置的节点117 public void del(int index) {118 DNode
                      
                        inode = getNode(index);119 inode.prev.next = inode.next;120 inode.next.prev = inode.prev;121 inode = null;122 mCount--;123 }124 125 // 删除第一个节点126 public void deleteFirst() {127 del(0);128 }129 130 // 删除最后一个节点131 public void deleteLast() {132 del(mCount-1);133 }134 }

View Code

测试程序(DlinkTest.java)

1 /**  2  * Java 实现的双向链表。   3  * 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList  4  *  5  * @author skywang  6  * @date 2013/11/07  7  */  8   9 public class DlinkTest { 10  11     // 双向链表操作int数据 12     private static void int_test() { 13         int[] iarr = {10, 20, 30, 40}; 14  15         System.out.println("\n----int_test----"); 16         // 创建双向链表 17         DoubleLink
        
          dlink = new DoubleLink
         
          (); 18  19         dlink.insert(0, 20);    // 将 20 插入到第一个位置 20         dlink.appendLast(10);    // 将 10 追加到链表末尾 21         dlink.insertFirst(30);    // 将 30 插入到第一个位置 22  23         // 双向链表是否为空 24         System.out.printf("isEmpty()=%b\n", dlink.isEmpty()); 25         // 双向链表的大小 26         System.out.printf("size()=%d\n", dlink.size()); 27  28         // 打印出全部的节点 29         for (int i=0; i
          
            dlink = new DoubleLink
           
            (); 40  41         dlink.insert(0, sarr[1]);    // 将 sarr中第2个元素 插入到第一个位置 42         dlink.appendLast(sarr[0]);    // 将 sarr中第1个元素 追加到链表末尾 43         dlink.insertFirst(sarr[2]);    // 将 sarr中第3个元素 插入到第一个位置 44  45         // 双向链表是否为空 46         System.out.printf("isEmpty()=%b\n", dlink.isEmpty()); 47         // 双向链表的大小 48         System.out.printf("size()=%d\n", dlink.size()); 49  50         // 打印出全部的节点 51         for (int i=0; i
            
              dlink = new DoubleLink
             
              (); 83 84 dlink.insert(0, students[1]); // 将 students中第2个元素 插入到第一个位置 85 dlink.appendLast(students[0]); // 将 students中第1个元素 追加到链表末尾 86 dlink.insertFirst(students[2]); // 将 students中第3个元素 插入到第一个位置 87 88 // 双向链表是否为空 89 System.out.printf("isEmpty()=%b\n", dlink.isEmpty()); 90 // 双向链表的大小 91 System.out.printf("size()=%d\n", dlink.size()); 92 93 // 打印出全部的节点 94 for (int i=0; i

View Code

运行结果

----int_test----isEmpty()=falsesize()=3dlink(0)=30dlink(1)=20dlink(2)=10----string_test----isEmpty()=falsesize()=3dlink(0)=thirtydlink(1)=twentydlink(2)=ten----object_test----isEmpty()=falsesize()=3dlink(0)=[30, vic]dlink(1)=[20, jody]dlink(2)=[10, sky]

转载于:https://www.cnblogs.com/Vancuicide/p/9591185.html

你可能感兴趣的文章

centos 7 redis-4.0.11 主从

springboot No Identifier specified for entity的解决办法

查看>>

慵懒中长大的人，只会挨生活留下的耳光

查看>>