单链表的代码实现(上)

        提起单链表，单链表虽然是线性表的一种数据结构，只不过是一种链表，它的链接方向是单向的，并且用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，为了表示每个数据元素Ai与其直接后继数据元素Ai+1之间的逻辑关系，对数据元素Ai来讲，除了存储其本身的信息外，还需存储一个指示其直接后继的信息（直接后继元素的存储位置）。这两部分信息组成数据元素Ai的存储映像，称为节点（node）。它包括两个域：其中存储数据元素信息的域称为数据域；存储直接后继元素存储位置的域称为指针域。指针域中存储的信息称为指针或链。n个节点[Ai（1<=i<=n）的存储映像]链接成一个链表，即为线性表：

（A1,A2,A3,...An）

的链式存储结构。又由于此链表的每个节点中只包含一个指针域，故又称为线性链表或单链表。

        值得一提的是以下几点：

        1、首元节点是指链表中存储第一个数据元素A1的节点。

        2、头节点是在首元节点之前附设的一个节点，其指针域指向首元节点。头节点的数据域可以不存储任何信息，也可存储与数据元素类型相同的其他附加信息（例如单链表的长度等等）。

        3、头指针是指向链表中第一个节点的指针。若链表设有头节点，则头指针所指节点为线性表的头指针；若链表不设头节点，则头指针所指节点为该线性表的首元节点。

        带头节点的单链表的不同语言实现如下：

        C语言（SingleLinkedList）：

#ifndef SINGLELINKEDLIST_H_INCLUDED
#define SINGLELINKEDLIST_H_INCLUDED
typedef int ElemType; //It is changeble to change this data type.
typedef struct Node
{
    ElemType elem;
    struct Node *next;
}*LinkedList,LNode;
void InitList(LinkedList *L)
{
    (*L)=(LNode*)malloc(sizeof(LNode));
    (*L)->next=NULL;
}
void DestroyList(LinkedList *L)
{
    LNode *p=(*L);
    while((*L)->next!=NULL)
    {
        p=(*L)->next;
        (*L)->next=p->next;
        free(p);
        p=NULL;
    }
    (*L)=NULL;
}
void ClearList(LinkedList *L)
{
    LNode *p=(*L);
    while((*L)->next!=NULL)
    {
        p=(*L)->next;
        (*L)->next=p->next;
        free(p);
    }
}
int ListEmpty(LinkedList *L)
{
    LNode *p=(*L);
    if(p->next!=NULL)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
int ListLength(LinkedList *L)
{
    LNode *p=(*L);
    int i=0;
    while(p->next!=NULL)
    {
        p=p->next;
        i++;
    }
    return i;
}
ElemType GetElem(LinkedList *L,int index)
{
    if(index<0||index>=ListLength(L))
    {
        return -1;
    }
    LNode *p=(*L)->next;
    int i=0;
    while(i<index)
    {
        i++;
        p=p->next;
    }
    return p->elem;
}
int LocateElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    int i=0;
    while(i<ListLength(L)&&p!=NULL)
    {
        if(p->elem==elem)
        {
            return i;
        }
        p=p->next;
        i++;
    }
    return -1;
}
ElemType PriorElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    while(p->next!=NULL)
    {
        if(p->next->elem==elem)
        {
            return p->elem;
        }
        p=p->next;
    }
    return -1;
}
ElemType NextElem(LinkedList *L,ElemType elem)
{
    LNode *p=(*L)->next;
    while(p->next!=NULL)
    {
        if(p->elem==elem)
        {
            return p->next->elem;
        }
        p=p->next;
    }
    return -1;
}
void addFirst(LinkedList *L,ElemType elem)
{
    LNode *s;
    s=(LNode*)malloc(sizeof(LNode));
    s->elem=elem;
    s->next=(*L)->next;
    (*L)->next=s;
}
void addAfter(LinkedList *L,ElemType elem)
{
    LNode *s,*p=(*L);
    s=(LNode*)malloc(sizeof(LNode));
    s->elem=elem;
    while(p->next!=NULL)
    {
        p=p->next;
    }
    s->next=p->next;
    p->next=s;
}
int ListInsert(LinkedList *L,int index,ElemType elem)
{
    if(index<0||index>ListLength(L))
    {
        return -1;
    }
    LNode *p=(*L),*s;
    s=(LNode*)malloc(sizeof(LNode));
    s->elem=elem;
    int i=0;
    while(i<index)
    {
        p=p->next;
        i++;
    }
    s->next=p->next;
    p->next=s;
    return 1;
}
int ListDelete(LinkedList *L,int index)
{
    if(index<0||index>=ListLength(L))
    {
        return -1;
    }
    LNode *p=(*L),*del;
    int i=0;
    while(i<index)
    {
        p=p->next;
        i++;
    }
    del=p->next;
    p->next=del->next;
    free(del);
    return 1;
}
void TraverseList(LinkedList *L)
{
    LNode *p=(*L)->next;
    while(p!=NULL)
    {
        printf("%d\t",p->elem);
        p=p->next;
    }
    printf("\n");
}
#endif // SINGLELINKEDLIST_H_INCLUDED

        Java语言：

//文件对应的包路径名:DataStructure.LinearList.LinkedList.java
package DataStructure.LinearList;
public class LinkedList
{
    protected Object elem;
    protected LinkedList next;
    public LinkedList(Object elem)
    {
        this.elem=elem;
    }
    public LinkedList(){}
}

//文件对应的包路径名:DataStructure.LinearList.SingleLinkedList.java
package DataStructure.LinearList;
public class SingleLinkedList {
    private LinkedList list=new LinkedList();
    private LinkedList head=list;
    public void InitList()
    {
        list=new LinkedList();
        this.head=list;
        list.next=null;
        list.elem=null;
    }
    public Boolean DestoryList()
    {
        try
        {
            head=null;
            ClearList();
            return true;
        }catch (NullPointerException e)
        {
            System.out.println("This SingleLinkedList has been destoried");
            return true;
        }
    }
    public Boolean ClearList()
    {
        LinkedList temp=head;
        temp.next=null;
        return true;
    }
    public Boolean ListEmpty()
    {
        if(head.next!=null)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    public int ListLength()
    {
        LinkedList temp=head;
        int i=0;
        while (temp.next!=null)
        {
            i++;
            temp=temp.next;
        }
        return i;
    }
    public Object GetElem(int index)
    {
        if(index<0||index>=this.ListLength())
        {
            return -1;
        }
        else
        {
            LinkedList temp=head;
            int i=0;
            while(i<index)
            {
                temp=temp.next;
                i++;
            }
            return temp.elem;
        }
    }
    public int LocateElem(Object elem)
    {
        LinkedList temp=head;
        for(int i=0;i<this.ListLength();i++)
        {
            if(temp.elem.equals(elem))
            {
                return i;
            }
            else
            {
                temp=temp.next;
                continue;
            }
        }
        return -1;
    }
    public Object PriorElem(Object elem)
    {
        LinkedList temp=head;
        for(int i=1;i<this.ListLength();i++)
        {
            if(temp.next.elem.equals(elem))
            {
                return temp.elem;
            }
            else
            {
                temp=temp.next;
            }
        }
        return -1;
    }
    public Object NextElem(Object elem)
    {
        LinkedList temp=head;
        for(int i=0;i<this.ListLength()-1;i++)
        {
            if(temp.elem.equals(elem))
            {
                return temp.next.elem;
            }
            else
            {
                temp=temp.next;
                continue;
            }
        }
        return -1;
    }
    public Boolean ListInsert(Object elem,int index)
    {
        if(index<0||index>this.ListLength())
        {
            return false;
        }
        LinkedList temp=head;
        if (index==0)
        {
            addFirst(elem);
            return true;
        }
        if(index>0)
        {
            for(int i=1;i<index;i++)
            {
                temp=temp.next;
            }
            LinkedList node=new LinkedList(elem);
            node.next=temp.next;
            temp.next=node;
        }
        return true;
    }
    public void addFirst(Object elem)
    {
        LinkedList node=new LinkedList(elem);
        //node.elem=elem;
        node.next = head;
        head = node;
    }
    public void addAfter(Object elem)
    {
        LinkedList temp=head;
        int i=0;
        if(this.ListLength()==0)
        {
            LinkedList node=new LinkedList(elem);
            //node.elem=elem;
            node.next = head;
            head = node;
        }
        else
        {
            while (i<this.ListLength()-1)
            {
                temp=temp.next;
                i++;
            }
            LinkedList node=new LinkedList(elem);
            //node.elem=elem;
            node.next=temp.next;
            temp.next=node;
        }
    }
    public Boolean DeleteElem(int index)
    {
        if(index<0||index>this.ListLength()-1)
        {
            return false;
        }
        LinkedList temp=head;
        if(index==0)
        {
            LinkedList save=temp.next;
            head=save;
            return true;
        }
        else
        {
            for (int i = 0; i < index-1; i++) {
                temp=temp.next;
            }
            LinkedList delete=temp.next;
            temp.next=delete.next;
            delete.next=null;
            return true;
        }
    }
    public void TraverseList()
    {
        LinkedList temp=head;
        while(temp.next!=null)
        {
            System.out.print(temp.elem+"\t");
            temp=temp.next;
        }
        System.out.println("");
    }
}