简单介绍线性表以及如何实现双链表

线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。

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

存储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)

#ifndef _double_link_h
#define _double_link_h
// 新建“双向链表”。成功，返回表头；否则，返回null
extern int create_dlink();
// 撤销“双向链表”。成功，返回0；否则，返回-1
extern int destroy_dlink();
// “双向链表是否为空”。为空的话返回1；否则，返回0。
extern int dlink_is_empty();
// 返回“双向链表的大小”
extern int dlink_size();
// 获取“双向链表中第index位置的元素”。成功，返回节点指针；否则，返回null。
extern void* dlink_get(int index);
// 获取“双向链表中第1个元素”。成功，返回节点指针；否则，返回null。
extern void* dlink_get_first();
// 获取“双向链表中最后1个元素”。成功，返回节点指针；否则，返回null。
extern void* dlink_get_last();
// 将“value”插入到index位置。成功，返回0；否则，返回-1。
extern int dlink_insert(int index, void *pval);
// 将“value”插入到表头位置。成功，返回0；否则，返回-1。
extern int dlink_insert_first(void *pval);
// 将“value”插入到末尾位置。成功，返回0；否则，返回-1。
extern int dlink_append_last(void *pval);
// 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1
extern int dlink_delete(int index);
// 删除第一个节点。成功，返回0；否则，返回-1
extern int dlink_delete_first();
// 删除组后一个节点。成功，返回0；否则，返回-1
extern int dlink_delete_last();
#endif

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

#include <stdio.h>
#include <malloc.h>
/**
* c 语言实现的双向链表，能存储任意数据。
*
* @author skywang
* @date 2013/11/07
*/
// 双向链表节点
typedef struct tag_node
{
struct tag_node *prev;
struct tag_node *next;
void* p;
}node;
// 表头。注意，表头不存放元素值！！！
static node *phead=null;
// 节点个数。
static int count=0;
// 新建“节点”。成功，返回节点指针；否则，返回null。
static node* create_node(void *pval)
{
node *pnode=null;
pnode = (node *)malloc(sizeof(node));
if (!pnode)
{
printf("create node error!\n");
return null;
}
// 默认的，pnode的前一节点和后一节点都指向它自身
pnode->prev = pnode->next = pnode;
// 节点的值为pval
pnode->p = pval;
return pnode;
}
// 新建“双向链表”。成功，返回0；否则，返回-1。
int create_dlink()
{
// 创建表头
phead = create_node(null);
if (!phead)
return -1;
// 设置“节点个数”为0
count = 0;
return 0;
}
// “双向链表是否为空”
int dlink_is_empty()
{
return count == 0;
}
// 返回“双向链表的大小”
int dlink_size() {
return count;
}
// 获取“双向链表中第index位置的节点”
static node* get_node(int index)
{
if (index<0 || index>=count)
{
printf("%s failed! index out of bound!\n", __func__);
return null;
}
// 正向查找
if (index <= (count/2))
{
int i=0;
node *pnode=phead->next;
while ((i++) < index)
pnode = pnode->next;
return pnode;
}
// 反向查找
int j=0;
int rindex = count - index - 1;
node *rnode=phead->prev;
while ((j++) < rindex)
rnode = rnode->prev;
return rnode;
}
// 获取“第一个节点”
static node* get_first_node()
{
return get_node(0);
}
// 获取“最后一个节点”
static node* get_last_node()
{
return get_node(count-1);
}
// 获取“双向链表中第index位置的元素”。成功，返回节点值；否则，返回-1。
void* dlink_get(int index)
{
node *pindex=get_node(index);
if (!pindex)
{
printf("%s failed!\n", __func__);
return null;
}
return pindex->p;
}
// 获取“双向链表中第1个元素的值”
void* dlink_get_first()
{
return dlink_get(0);
}
// 获取“双向链表中最后1个元素的值”
void* dlink_get_last()
{
return dlink_get(count-1);
}
// 将“pval”插入到index位置。成功，返回0；否则，返回-1。
int dlink_insert(int index, void* pval)
{
// 插入表头
if (index==0)
return dlink_insert_first(pval);
// 获取要插入的位置对应的节点
node *pindex=get_node(index);
if (!pindex)
return -1;
// 创建“节点”
node *pnode=create_node(pval);
if (!pnode)
return -1;
pnode->prev = pindex->prev;
pnode->next = pindex;
pindex->prev->next = pnode;
pindex->prev = pnode;
// 节点个数+1
count++;
return 0;
}
// 将“pval”插入到表头位置
int dlink_insert_first(void *pval)
{
node *pnode=create_node(pval);
if (!pnode)
return -1;
pnode->prev = phead;
pnode->next = phead->next;
phead->next->prev = pnode;
phead->next = pnode;
count++;
return 0;
}
// 将“pval”插入到末尾位置
int dlink_append_last(void *pval)
{
node *pnode=create_node(pval);
if (!pnode)
return -1;

pnode->next = phead;
pnode->prev = phead->prev;
phead->prev->next = pnode;
phead->prev = pnode;
count++;
return 0;
}
// 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1。
int dlink_delete(int index)
{
node *pindex=get_node(index);
if (!pindex)
{
printf("%s failed! the index in out of bound!\n", __func__);
return -1;
}
pindex->next->prev = pindex->prev;
pindex->prev->next = pindex->next;
free(pindex);
count--;
return 0;
}
// 删除第一个节点
int dlink_delete_first()
{
return dlink_delete(0);
}
// 删除组后一个节点
int dlink_delete_last()
{
return dlink_delete(count-1);
}
// 撤销“双向链表”。成功，返回0；否则，返回-1。
int destroy_dlink()
{
if (!phead)
{
printf("%s failed! dlink is null!\n", __func__);
return -1;
}
node *pnode=phead->next;
node *ptmp=null;
while(pnode != phead)
{
ptmp = pnode;
pnode = pnode->next;
free(ptmp);
}
free(phead);
phead = null;
count = 0;
return 0;
}

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

#include <stdio.h>
#include "double_link.h"
/**
* c 语言实现的双向链表的测试程序。
*
* (01) int_test()
* 演示向双向链表操作“int数据”。
* (02) string_test()
* 演示向双向链表操作“字符串数据”。
* (03) object_test()
* 演示向双向链表操作“对象”。
*
* @author skywang
* @date 2013/11/07
*/
// 双向链表操作int数据
void int_test()
{
int iarr[4] = {10, 20, 30, 40};
printf("\n----%s----\n", __func__);
create_dlink(); // 创建双向链表
dlink_insert(0, &iarr[0]); // 向双向链表的表头插入数据
dlink_insert(0, &iarr[1]); // 向双向链表的表头插入数据
dlink_insert(0, &iarr[2]); // 向双向链表的表头插入数据
printf("dlink_is_empty()=%d\n", dlink_is_empty()); // 双向链表是否为空
printf("dlink_size()=%d\n", dlink_size()); // 双向链表的大小
// 打印双向链表中的全部数据
int i;
int *p;
int sz = dlink_size();
for (i=0; i<sz; i++)
{
p = (int *)dlink_get(i);
printf("dlink_get(%d)=%d\n", i, *p);
}
destroy_dlink();
}
void string_test()
{
char* sarr[4] = {"ten", "twenty", "thirty", "forty"};
printf("\n----%s----\n", __func__);
create_dlink(); // 创建双向链表
dlink_insert(0, sarr[0]); // 向双向链表的表头插入数据
dlink_insert(0, sarr[1]); // 向双向链表的表头插入数据
dlink_insert(0, sarr[2]); // 向双向链表的表头插入数据
printf("dlink_is_empty()=%d\n", dlink_is_empty()); // 双向链表是否为空
printf("dlink_size()=%d\n", dlink_size()); // 双向链表的大小
// 打印双向链表中的全部数据
int i;
char *p;
int sz = dlink_size();
for (i=0; i<sz; i++)
{
p = (char *)dlink_get(i);
printf("dlink_get(%d)=%s\n", i, p);
}
destroy_dlink();
}
typedef struct tag_stu
{
int id;
char name[20];
}stu;
static stu arr_stu[] =
{
{10, "sky"},
{20, "jody"},
{30, "vic"},
{40, "dan"},
};
#define arr_stu_size ( (sizeof(arr_stu)) / (sizeof(arr_stu[0])) )
void object_test()
{
printf("\n----%s----\n", __func__);
create_dlink(); // 创建双向链表
dlink_insert(0, &arr_stu[0]); // 向双向链表的表头插入数据
dlink_insert(0, &arr_stu[1]); // 向双向链表的表头插入数据
dlink_insert(0, &arr_stu[2]); // 向双向链表的表头插入数据
printf("dlink_is_empty()=%d\n", dlink_is_empty()); // 双向链表是否为空
printf("dlink_size()=%d\n", dlink_size()); // 双向链表的大小
// 打印双向链表中的全部数据
int i;
int sz = dlink_size();
stu *p;
for (i=0; i<sz; i++)
{
p = (stu *)dlink_get(i);
printf("dlink_get(%d)=[%d, %s]\n", i, p->id, p->name);
}
destroy_dlink();
}
int main()
{
int_test(); // 演示向双向链表操作“int数据”。
string_test(); // 演示向双向链表操作“字符串数据”。
object_test(); // 演示向双向链表操作“对象”。
return 0;
}

运行结果

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

2. c++实现双链表

实现代码
双向链表文件(doublelink.h)

#ifndef double_link_hxx
#define double_link_hxx
#include <iostream>
using namespace std;
template<class t>
struct dnode
{
public:
t value;
dnode *prev;
dnode *next;
public:
dnode() { }
dnode(t t, dnode *prev, dnode *next) {
this->value = t;
this->prev = prev;
this->next = next;
}
};
template<class t>
class doublelink
{
public:
doublelink();
~doublelink();
int size();
int is_empty();
t get(int index);
t get_first();
t get_last();
int insert(int index, t t);
int insert_first(t t);
int append_last(t t);
int del(int index);
int delete_first();
int delete_last();
private:
int count;
dnode<t> *phead;
private:
dnode<t> *get_node(int index);
};
template<class t>
doublelink<t>::doublelink() : count(0)
{
// 创建“表头”。注意：表头没有存储数据！
phead = new dnode<t>();
phead->prev = phead->next = phead;
// 设置链表计数为0
//count = 0;
}
// 析构函数
template<class t>
doublelink<t>::~doublelink()
{
// 删除所有的节点
dnode<t>* ptmp;
dnode<t>* pnode = phead->next;
while (pnode != phead)
{
ptmp = pnode;
pnode=pnode->next;
delete ptmp;
}
// 删除"表头"
delete phead;
phead = null;
}
// 返回节点数目
template<class t>
int doublelink<t>::size()
{
return count;
}
// 返回链表是否为空
template<class t>
int doublelink<t>::is_empty()
{
return count==0;
}
// 获取第index位置的节点
template<class t>
dnode<t>* doublelink<t>::get_node(int index)
{
// 判断参数有效性
if (index<0 || index>=count)
{
cout << "get node failed! the index in out of bound!" << endl;
return null;
}
// 正向查找
if (index <= count/2)
{
int i=0;
dnode<t>* pindex = phead->next;
while (i++ < index) {
pindex = pindex->next;
}
return pindex;
}
// 反向查找
int j=0;
int rindex = count - index -1;
dnode<t>* prindex = phead->prev;
while (j++ < rindex) {
prindex = prindex->prev;
}
return prindex;
}
// 获取第index位置的节点的值
template<class t>
t doublelink<t>::get(int index)
{
return get_node(index)->value;
}
// 获取第1个节点的值
template<class t>
t doublelink<t>::get_first()
{
return get_node(0)->value;
}
// 获取最后一个节点的值
template<class t>
t doublelink<t>::get_last()
{
return get_node(count-1)->value;
}
// 将节点插入到第index位置之前
template<class t>
int doublelink<t>::insert(int index, t t)
{
if (index == 0)
return insert_first(t);
dnode<t>* pindex = get_node(index);
dnode<t>* pnode = new dnode<t>(t, pindex->prev, pindex);
pindex->prev->next = pnode;
pindex->prev = pnode;
count++;
return 0;
}
// 将节点插入第一个节点处。
template<class t>
int doublelink<t>::insert_first(t t)
{
dnode<t>* pnode = new dnode<t>(t, phead, phead->next);
phead->next->prev = pnode;
phead->next = pnode;
count++;
return 0;
}
// 将节点追加到链表的末尾
template<class t>
int doublelink<t>::append_last(t t)
{
dnode<t>* pnode = new dnode<t>(t, phead->prev, phead);
phead->prev->next = pnode;
phead->prev = pnode;
count++;
return 0;
}
// 删除index位置的节点
template<class t>
int doublelink<t>::del(int index)
{
dnode<t>* pindex = get_node(index);
pindex->next->prev = pindex->prev;
pindex->prev->next = pindex->next;
delete pindex;
count--;
return 0;
}
// 删除第一个节点
template<class t>
int doublelink<t>::delete_first()
{
return del(0);
}
// 删除最后一个节点
template<class t>
int doublelink<t>::delete_last()
{
return del(count-1);
}
#endif

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

#include <iostream>
#include "doublelink.h"
using namespace std;
// 双向链表操作int数据
void int_test()
{
int iarr[4] = {10, 20, 30, 40};
cout << "\n----int_test----" << endl;
// 创建双向链表
doublelink<int>* pdlink = new doublelink<int>();
pdlink->insert(0, 20); // 将 20 插入到第一个位置
pdlink->append_last(10); // 将 10 追加到链表末尾
pdlink->insert_first(30); // 将 30 插入到第一个位置
// 双向链表是否为空
cout << "is_empty()=" << pdlink->is_empty() <<endl;
// 双向链表的大小
cout << "size()=" << pdlink->size() <<endl;
// 打印双向链表中的全部数据
int sz = pdlink->size();
for (int i=0; i<sz; i++)
cout << "pdlink("<<i<<")=" << pdlink->get(i) <<endl;
}
void string_test()
{
string sarr[4] = {"ten", "twenty", "thirty", "forty"};
cout << "\n----string_test----" << endl;
// 创建双向链表
doublelink<string>* pdlink = new doublelink<string>();
pdlink->insert(0, sarr[1]); // 将 sarr中第2个元素 插入到第一个位置
pdlink->append_last(sarr[0]); // 将 sarr中第1个元素 追加到链表末尾
pdlink->insert_first(sarr[2]); // 将 sarr中第3个元素 插入到第一个位置
// 双向链表是否为空
cout << "is_empty()=" << pdlink->is_empty() <<endl;
// 双向链表的大小
cout << "size()=" << pdlink->size() <<endl;
// 打印双向链表中的全部数据
int sz = pdlink->size();
for (int i=0; i<sz; i++)
cout << "pdlink("<<i<<")=" << pdlink->get(i) <<endl;
}
struct stu
{
int id;
char name[20];
};
static stu arr_stu[] =
{
{10, "sky"},
{20, "jody"},
{30, "vic"},
{40, "dan"},
};
#define arr_stu_size ( (sizeof(arr_stu)) / (sizeof(arr_stu[0])) )
void object_test()
{
cout << "\n----object_test----" << endl;
// 创建双向链表
doublelink<stu>* pdlink = new doublelink<stu>();
pdlink->insert(0, arr_stu[1]); // 将 arr_stu中第2个元素 插入到第一个位置
pdlink->append_last(arr_stu[0]); // 将 arr_stu中第1个元素 追加到链表末尾
pdlink->insert_first(arr_stu[2]); // 将 arr_stu中第3个元素 插入到第一个位置
// 双向链表是否为空
cout << "is_empty()=" << pdlink->is_empty() <<endl;
// 双向链表的大小
cout << "size()=" << pdlink->size() <<endl;
// 打印双向链表中的全部数据
int sz = pdlink->size();
struct stu p;
for (int i=0; i<sz; i++)
{
p = pdlink->get(i);
cout << "pdlink("<<i<<")=[" << p.id << ", " << p.name <<"]" <<endl;
}
}
int main()
{
int_test(); // 演示向双向链表操作“int数据”。
string_test(); // 演示向双向链表操作“字符串数据”。
object_test(); // 演示向双向链表操作“对象”。
return 0;
}

示例说明

在上面的示例中，我将双向链表的"声明"和"实现"都放在头文件中。而编程规范告诫我们：将类的声明和实现分离，在头文件(.h文件或.hpp)中尽量只包含声明，而在实现文件(.cpp文件)中负责实现！
那么为什么要这么做呢？这是因为，在双向链表的实现中，采用了模板；而c++编译器不支持对模板的分离式编译！简单点说，如果在doublelink.h中声明，而在doublelink.cpp中进行实现的话；当我们在其他类中创建doublelink的对象时，会编译出错。具体原因，可以参考"为什么c++编译器不能支持对模板的分离式编译"。

运行结果

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

3. java实现双链表

实现代码
双链表类(doublelink.java)

/**
* java 实现的双向链表。
* 注：java自带的集合包中有实现双向链表，路径是:java.util.linkedlist
*
* @author skywang
* @date 2013/11/07
*/
public class doublelink<t> {
// 表头
private dnode<t> mhead;
// 节点个数
private int mcount;
// 双向链表“节点”对应的结构体
private class dnode<t> {
public dnode prev;
public dnode next;
public t value;
public dnode(t value, dnode prev, dnode next) {
this.value = value;
this.prev = prev;
this.next = next;
}
}
// 构造函数
public doublelink() {
// 创建“表头”。注意：表头没有存储数据！
mhead = new dnode<t>(null, null, null);
mhead.prev = mhead.next = mhead;
// 初始化“节点个数”为0
mcount = 0;
}
// 返回节点数目
public int size() {
return mcount;
}
// 返回链表是否为空
public boolean isempty() {
return mcount==0;
}
// 获取第index位置的节点
private dnode<t> getnode(int index) {
if (index<0 || index>=mcount)
throw new indexoutofboundsexception();
// 正向查找
if (index <= mcount/2) {
dnode<t> node = mhead.next;
for (int i=0; i<index; i++)
node = node.next;
return node;
}
// 反向查找
dnode<t> rnode = mhead.prev;
int rindex = mcount - index -1;
for (int j=0; j<rindex; j++)
rnode = rnode.prev;
return rnode;
}
// 获取第index位置的节点的值
public t get(int index) {
return getnode(index).value;
}
// 获取第1个节点的值
public t getfirst() {
return getnode(0).value;
}
// 获取最后一个节点的值
public t getlast() {
return getnode(mcount-1).value;
}
// 将节点插入到第index位置之前
public void insert(int index, t t) {
if (index==0) {
dnode<t> node = new dnode<t>(t, mhead, mhead.next);
mhead.next.prev = node;
mhead.next = node;
mcount++;
return ;
}
dnode<t> inode = getnode(index);
dnode<t> tnode = new dnode<t>(t, inode.prev, inode);
inode.prev.next = tnode;
inode.next = tnode;
mcount++;
return ;
}
// 将节点插入第一个节点处。
public void insertfirst(t t) {
insert(0, t);
}
// 将节点追加到链表的末尾
public void appendlast(t t) {
dnode<t> node = new dnode<t>(t, mhead.prev, mhead);
mhead.prev.next = node;
mhead.prev = node;
mcount++;
}
// 删除index位置的节点
public void del(int index) {
dnode<t> inode = getnode(index);
inode.prev.next = inode.next;
inode.next.prev = inode.prev;
inode = null;
mcount--;
}
// 删除第一个节点
public void deletefirst() {
del(0);
}
// 删除最后一个节点
public void deletelast() {
del(mcount-1);
}
}

测试程序(dlinktest.java)

/**
* java 实现的双向链表。
* 注：java自带的集合包中有实现双向链表，路径是:java.util.linkedlist
*
* @author skywang
* @date 2013/11/07
*/
public class dlinktest {
// 双向链表操作int数据
private static void int_test() {
int[] iarr = {10, 20, 30, 40};
system.out.println("\n----int_test----");
// 创建双向链表
doublelink<integer> dlink = new doublelink<integer>();
dlink.insert(0, 20); // 将 20 插入到第一个位置
dlink.appendlast(10); // 将 10 追加到链表末尾
dlink.insertfirst(30); // 将 30 插入到第一个位置
// 双向链表是否为空
system.out.printf("isempty()=%b\n", dlink.isempty());
// 双向链表的大小
system.out.printf("size()=%d\n", dlink.size());
// 打印出全部的节点
for (int i=0; i<dlink.size(); i++)
system.out.println("dlink("+i+")="+ dlink.get(i));
}
private static void string_test() {
string[] sarr = {"ten", "twenty", "thirty", "forty"};
system.out.println("\n----string_test----");
// 创建双向链表
doublelink<string> dlink = new doublelink<string>();
dlink.insert(0, sarr[1]); // 将 sarr中第2个元素 插入到第一个位置
dlink.appendlast(sarr[0]); // 将 sarr中第1个元素 追加到链表末尾
dlink.insertfirst(sarr[2]); // 将 sarr中第3个元素 插入到第一个位置
// 双向链表是否为空
system.out.printf("isempty()=%b\n", dlink.isempty());
// 双向链表的大小
system.out.printf("size()=%d\n", dlink.size());
// 打印出全部的节点
for (int i=0; i<dlink.size(); i++)
system.out.println("dlink("+i+")="+ dlink.get(i));
}
// 内部类
private static class student {
private int id;
private string name;
public student(int id, string name) {
this.id = id;
this.name = name;
}
@override
public string tostring() {
return "["+id+", "+name+"]";
}
}
private static student[] students = new student[]{
new student(10, "sky"),
new student(20, "jody"),
new student(30, "vic"),
new student(40, "dan"),
};
private static void object_test() {
system.out.println("\n----object_test----");
// 创建双向链表
doublelink<student> dlink = new doublelink<student>();
dlink.insert(0, students[1]); // 将 students中第2个元素 插入到第一个位置
dlink.appendlast(students[0]); // 将 students中第1个元素 追加到链表末尾
dlink.insertfirst(students[2]); // 将 students中第3个元素 插入到第一个位置
// 双向链表是否为空
system.out.printf("isempty()=%b\n", dlink.isempty());
// 双向链表的大小
system.out.printf("size()=%d\n", dlink.size());
// 打印出全部的节点
for (int i=0; i<dlink.size(); i++) {
system.out.println("dlink("+i+")="+ dlink.get(i));
}
}

public static void main(string[] args) {
int_test(); // 演示向双向链表操作“int数据”。
string_test(); // 演示向双向链表操作“字符串数据”。
object_test(); // 演示向双向链表操作“对象”。
}
}

运行结果

----int_test----
isempty()=false
size()=3
dlink(0)=30
dlink(1)=20
dlink(2)=10
----string_test----
isempty()=false
size()=3
dlink(0)=thirty
dlink(1)=twenty
dlink(2)=ten
----object_test----
isempty()=false
size()=3
dlink(0)=[30, vic]
dlink(1)=[20, jody]
dlink(2)=[10, sky]

以上就是本文的全部内容，希望大家能够理解，对大家有所帮助。