提起单链表,单链表虽然是线性表的一种数据结构,只不过是一种链表,它的链接方向是单向的,并且用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的)。因此,为了表示每个数据元素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("");
}
}