单链表结构

链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种：单链表、循环链表、双向链表，下面将逐一介绍。

单链表：单链表有一个头节点head，指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型（数据的结构类型，有一个数据域和指针域共同组成了这种新的数据），节点有两个成员：整型成员（实际需要保存的数据，可以是泛型）和指向下一个结构体类型节点的指针即下一个节点的地址。链表按此结构对各节点的访问需从链表的头找起，后续节点的地址由当前节点给出。无论在表中访问那一个节点，都需要从链表的头开始，顺序向后查找。链表的尾节点由于无后续节点，其指针域为空，写作为NULL。

单链表的创建过程：

1、定义一个单链表的数据结构，可以说是一种新的数据类型

2、创建一个空的链表

3、分配一个指针域为NULL,数据域不设置的头结点

4、可以进行链表的使用，加入元素，将新节点的指针域成员赋为NULL，通过循环判断指针域的值是否为NULL，来找到最后一个节点或者是第一个节点

单链表的使用过程：

1、把单链表的头结点传入

2、通过检测节点中的指针域是否非NULL，来循环数据节点中的数据域

3、找到下一个节点的地址，返回第二步

C语言单链表的形式

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode LNode;//新数据类型
typedef struct LNode* pLNode;//指针数据类型
//1、定义结构
struct LNode{
int data; //数据域
struct LNode *next; //指针域
};
pLNode addLNode(pLNode p,int i);
pLNode init(pLNode p);
void show(pLNode p);

int main()
{
pLNode p=NULL; //2、创建空表
//p=(pLNode)malloc(sizeof(LNode));
p =init(p);
int i=0;
for(i;i<100;i++)
{
p = addLNode(p, i);
}
show(p);
}
pLNode init(pLNode p)
{
p=(pLNode)malloc(sizeof(LNode));
p->next=NULL;
return p;
}
pLNode addLNode(pLNode p,int i)
{
pLNode head = p;
pLNode p1=(pLNode)malloc(sizeof(LNode)); //3、使用malloc函数进行动态内存分配
p1->next=NULL;                      //4、把新节点的指针域赋值为null
while(p->next!=NULL){   //并找到最后一个节点或者是第一个节点
p=p->next;
}
p->next=p1;    //5、给最后一个指针域赋值为新创建的节点
p1->data=i;
//给最后一个节点赋值
return head;
}

void show(pLNode p)
{
while(p->next!=NULL)
{
p=p->next;
printf(" %d  ",p);
printf("  %d\n",p->data);

}
}

网上找的一幅图

Java语言编写的数据结构

1、第一种实现方式，只有一个头结点和一个节点个数属性，节点内容一样，就是链表的定义方式实现

public class MySigleLinkListe<E> {
public static class Node<E>{
Node<E> pNext;
E item;
public Node(Node<E> pNext, E item) {
super();
this.pNext = pNext;
this.item = item;
}
@Override
public String toString() {
return "Node [item=" + item + "]";
}

}

public MySigleLinkListe() {
super();
head=new Node<E>(null, null);  //穿件头指针，java中存储方式不一样，
}

transient Node<E> head; //头结点
transient int size; //节点数量

public void add(E e){
addLast(e);
}

private void addLast(E e){
final Node<E> n=new Node<E>(null,e);  //新 创建了 一个节点
Node<E> m=head;   //先把节点引用赋给一个中间变量引用
if(m.pNext==null) //若果这个节点中的pNext为null，说明是头结点
m.pNext=n;   //则把新节点引用赋给投头结点中的pNext属性
else{
while(m.pNext!=null){ //如果已存在节点，则开始遍历，利用pNext属性为null这一特性来查找最后一个节点，
m=m.pNext;     //成立，则把当前引用改为 下一个引用，继续遍历
}
m.pNext=n; //直到最后一个节点，这时把新节点引用赋给最后一个节点的pNext属性
}
size++;//size++
}

public void show(){
if(head.pNext==null){
return ;
}
Node<E> m=head;
while(m.pNext!=null){
m=m.pNext;
System.out.println(m.item.toString());
}
}
//存储 个数
public int count(){
return size;
}
}

使用部分代码

MySigleLinkListe<String> my=new MySigleLinkListe<String>();
for (int i = 0; i < 10; i++) {
my.add(i+"");
}
my.show();
System.out.println(my.count());

2、第二种实现方式，使用两个引用，一个头引用，一个尾引用，这样就利于添加

public class MyDoubleLinkList<E> {
private static class Node<E>{
E e;
//Node<E> pFirst;  //头引用
Node<E> pNext;   //下一个节点的引用
public Node(E e, Node<E> pNext) {
super();
this.e = e;
this.pNext = pNext;
}

}
transient Node<E> head; //头结点
transient Node<E> end;  //尾节点
transient int size;    //节点数
public MyDoubleLinkList() {
super();
head=new Node<E>(null, null);
end=head;
}
public void add(E e){
addLinkLast(e);
}
private void addLinkLast(E e){
Node<E> n=new Node<E>(e, null);
Node<E> m=head;
if(end==head){    //头节点等于尾节点时则说明还没有子节点
m.pNext=n;   //把头结点的pNext指向下一个节点
end=n;      //尾节点指向新节点
}else{
end.pNext=n;  //把前一次的尾节点保存为新节点
end=n;     //把新节点保存为尾节点 ，这样可以不用每次插入都找尾节点，效率提升了很多，
}
size++;
}
public void show(){
Node<E> m=head;
while(m.pNext!=null){
m=m.pNext;
System.out.println(m.e);
}
}
public E get(int index){
Node<E> m=head;
for (int i = 0; i < index+1; i++) {
m=m.pNext;
}
return m.e;
}
public int count(){
return size;
}
}

使用部分代码

MyDoubleLinkList<String> d=new MyDoubleLinkList<String>();
for(int j=20;j<30;j++){
d.add(j+"");
}
for(int i=0;i<d.count();i++){
System.out.print(d.get(i)+"  ");
}

感悟：源码中的linkList实现是基于双端链表的，也就是一个节点既有上一个节点引用也有下一个节点引用，这个思想都是一样的，源码中写的有些很复杂，源码中使用了一个 size属性，就是用来作为一个查找索引使用的，这样有利于查询

这是get（int index）方法的源码一部分
Node<E> node(int index) {
// assert isElementIndex(index);

if (index < (size >> 1)){  //这里直接就进行了 一半处理，这样查找的时间大多会缩短一半，
Node<E> x = first;     //如果在前一半就从头引用开始查找
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {                  //后一半就从尾引用忘前找，这个实现的前提就是使用双端链表
Node<E> x = last;    //，才能找到上一个引用
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}