Java数据结构和算法之链表

　　三、链表

　　链结点

　　在链表中，每个数据项都被包含在‘点“中，一个点是某个类的对象，这个类可认叫做LINK。因为一个链表中有许多类似的链结点，所以有必要用一个不同于链表的类来表达链结点。每个LINK对象中都包含一个对下一个点引用的字段（通常叫做next）但是本身的对象中有一个字段指向对第一个链结点的引用。

　　单链表

　　用一组地址任意的存储单元存放线性表中的数据元素。

　　以元素(数据元素的映象)  + 指针(指示后继元素存储位置)  = 结点(表示数据元素 或 数据元素的映象)

　　以“结点的序列”表示线性表,称作线性链表（单链表）

　　单链表是一种顺序存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。

　　因此，查找第 i 个数据元素的基本操作为：移动指针，比较 j 和 i

　　1、链接存储方法  链接方式存储的线性表简称为链表（Linked List）。

　　链表的具体存储表示为：

　　① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）

　　② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针

（pointer）或链(link)）

　　注意：  链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。

　　2、链表的结点结构

┌──--┬──--┐

│data │next│

└──---┴─--─┘

　　data域--存放结点值的数据域

　　next域--存放结点的直接后继的地址（位置）的指针域（链域）

　　注意：

　　①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。

　　②每个结点只有一个链域的链表称为单链表（Single Linked List）。

　　【例】线性表（bat，cat，eat，fat，hat，jat，lat，mat）的单链表示如示意图

　　3、头指针head和终端结点指针域的表示  单链表中每个结点的存储地址是存放在其前趋结点next域中，而开始结点无前趋，故应设头指针head指向开始结点。

　　注意：  链表由头指针唯一确定，单链表可以用头指针的名字来命名。

　　【例】头指针名是head的链表可称为表head。  终端结点无后继，故终端结点的指针域为空，即NULL。

　　4、单链表的一般图示法  由于我们常常只注重结点间的逻辑顺序，不关心每个结点的实际位置，可以用箭头来表示链域中的指针，线性表（bat，cat，fat，hat，jat，lat，mat）的单链表就可以表示为下图形式。  bat->cat->fat->hat->jat->lat->mat

　　5、单链表类型描述

　　typedef char DataType; //假设结点的数据域类型为字符

　　typedef struct node{ //结点类型定义

　　DataType data; //结点的数据域

　　struct node *next;//结点的指针域

　　}ListNode

　　typedef ListNode *LinkList;

　　ListNode *p;

　　LinkList head;

　　注意：

　　①*LinkList和ListNode是不同名字的同一个指针类型（命名的不同是为了概念上更明确）

　　②*LinkList类型的指针变量head表示它是单链表的头指针

　　③ListNode类型的指针变量p表示它是指向某一结点的指针

　　6、指针变量和结点变量

指针变量               │             结点变量

│ 定义     │在变量说明部分显式定义  │在程序执行时，通过标准函数malloc生成

│ 取值     │ 非空时，存放某类型结点 │实际存放结点各域内容的地址

│操作方式│ 通过指针变量名访问       │ 通过指针生成、访问和释放

　　①生成结点变量的标准函数  p=( ListNode *)malloc(sizeof(ListNode))；  //函数malloc分配一个类型为ListNode的结点变量的空间,并将其首地址放入指针变量p中

　　②释放结点变量空间的标准函数  free(p)；//释放p所指的结点变量空间

　　③结点分量的访问  利用结点变量的名字*p访问结点分量

　　方法一：(*p).data和(*p).next

　　方法二：p-﹥data和p-﹥next

　　④指针变量p和结点变量*p的关系

　　 指针变量p的值——结点地址

　　结点变量*p的值——结点内容

　　(*p).data的值——p指针所指结点的data域的值

　　(*p).next的值——*p后继结点的地址

　　*((*p).next)——*p后继结点

　　注意：

　　① 若指针变量p的值为空（NULL），则它不指向任何结点。此时，若通过*p来访问结点就意味着访问一个不存在的变量，从而引起程序的错误。

　　② 有关指针类型的意义和说明方式的详细解释  可见，在链表中插入结点只需要修改指针。但同时，若要在第i个结点之前插入元素，修改的是第i-1个结点的指针。

　　因此，在单链表中第i个结点之前进行插入的基本操作为: 找到线性表中第i-1个结点，然后修改其指向后继的指针。

　　双端链表

　　双端链表与传统的链表非常相似，但是它有一个新增的特性：即对最后一个链结点的引用，就像对第一个链结点的引用一样。

　　对最后一个链结点的引用允许像在表头一样，在表尾直接插入一个链结点。当然，仍然可以在普通的单链表的表尾插入一个链结点，方法是遍历整个链表直到到达表尾，但是这种方法效率很低。

　　对最后一个链结点的引用允许像在表头一样，在表尾直接插入一个链结点。当然，仍然可以在普通的单链表的表尾插入一个链结点，方法是遍历整个链表直到到达表尾，但是这种方法效率很低。

　　像访问表头一样访问表尾的特性，使双端链表更适合于一些普通链表不方便操作的场合，队列的实现就是这样一个情况。

　　下面是一个双端链表的例子。

class Link3{

　　public long dData;

　　public Link3 next;

　　public Link3(long d){

　　　　dData=d;

　　}

　　public void displayLink(){

　　System.out.print(dData+" ");

　　}

}

//////////////////////////////////////////////

class FirstLastList{

　　private Link3 first;

　　private Link3 last;

　　public FirstLastList(){

　　　　first=null;

　　　　last=null;

　　}

　　public boolean isEmpty(){

　　　　return first==null;

　　}

　　public void insertFirst(long dd){

　　　　Link3 newLink=new Link3(dd);   .　　

　　　　if(isEmpty()){

　　　　　　last=newLink;

　　　　　　newLink.next=first;

　　　　　　first=newLink;

　　　　}

　　}

　　public void insertLast(long dd){

　　　　Link3 newLink=new Link3(dd);

　　　　if(isEmpty()){

　　　　　　first=newLink;

　　　　}else{

　　　　　　last.next=newLink;

　　　　　　last=newLink;

　　　　}

　　}

　　public long deleteFirst(){

　　　　long temp=first.dData;

　　　　if(first.next==null){

　　　　last=null;

　　　　first=first.next;

　　　　return temp;

　　　　}

　　}

　　public void displayList(){

　　　　System.out.print("List (first-->last): ");

　　　　Link3 current=first;

　　　　while(current!=null){

　　　　　　current.displayLink();

　　　　　　current=current.next;

　　　　}

　　　　System.out.println("");

　　}

}

//////////////////////////////////////////////////////

public class FirstLastApp {

　　public static void main(String[] args){

　　FirstLastList theList=new FirstLastList();

　　theList.insertFirst(22);

　　theList.insertFirst(44);

　　theList.insertFirst(66);

　　theList.insertLast(11);

　　theList.insertLast(33);

　　theList.insertLast(55);

　　theList.displayList();

　　theList.deleteFirst();

　　theList.deleteFirst();

　　theList.displayList();

　　}

}

　　为了简单起见，在这个程序中，把每个链结点中的数据字段个数从两个压缩到一个。这更容易显示链结点的内容。（记住，在一个正式的程序中，可能会有非常多的数据字段，或者对另外一个对象的引用，那个对象也包含很多数据字段。）

　　这个程序在表头和表尾各插入三个链点，显示插入后的链表。然后删除头两个链结点，再次显示。

　　注意在表头重复插入操作会颠倒链结点进入的顺序，而在表尾的重复插入则保持链结点进入的顺序。

　　双端链表类叫做FirstLastList。它有两个项，first和last，一个指向链表中的第一个链结点，另一个指向最后一个链结点。如果链表中只有一个链结点，first和last就都指向它，如果没有链结点，两者都为Null值。

　　这个类有一个新的方法insertLast()，这个方法在表尾插入一个新的链结点。这个过程首先改变last.next，使其指向新生成的链结点，然后改变last，使其指向新的链结点。   插入和删除方法和普通链表的相应部分类似。然而，两个插入方法都要考虑一种特殊情况，即插入前链表是空的。如果isEmpty()是真，那么insertFirst()必须把last指向新的链结点，insertLast()也必须把first指向新的链结点。

　　如果用insertFirst()方法实现在表头插入，first就指向新的链结点，用insertLast()方法实现在表尾插入，last就指向新的链结点。如果链表只有一个链结点，那么多表头删除也是一种特殊情况：last必须被赋值为null值。

　　不幸的是，用双端链表也不能有助于删除最后一个链结点，因为没有一个引用指向倒数第二个链结点。如果最后一个链结点被删除，倒数第二个链结点的Next字段应该变成Null值。为了方便的删除最后一个链结点，需要一个双向链表。（当然，也可以遍历整个链表找到最后一个链结点，但是那样做效率不是很高。）  有序链表  在有序链表中，数据是按照关键值有序排列的。有序链表的删除常常是只限于删除在链表头部的最小链结点。不过，有时也用Find()方法和Delete()方法在整个链表中搜索某一特定点。

　　一般，在大多数需要使用有序数组的场合也可以使用有序链表。有序链表优于有序数组的地方是插入的速度，另外链表可以扩展到全部有效的使用内存，而数组只能局限于一个固定的大小中。但是，有序链表实现起来比有序数组更困难一些。

　　后而将看到一个有序链表的应用：为数据排序。有序链表也可以用于实现优先级队列，尽管堆是更常用的实现方法。   在有序链表中插入一个数据项的Java代码,为了在一个有序链表中插入数据项，算法必须首先搜索链表，直到找到合适的位置：它恰好在第一个比它大的数据项的前面。

　　当算法找到了要插入的位置，用通常的方式插入数据项：把新链结点的Next字段指向下一个链结点，然后把前一个链结点的Next字段改为指向新的链结点。然而，需要考虑一些特殊情况：链结点有可以插在表头，或者插在表尾。看一下这段代码：

　　Public void insert(long key){

　　　　Link newLink= new Link(key);

　　　　Link previous= null;

　　　　Link current=first;

　　　　While(current!= null&&key>current.dData){

　　　　　　Previous= current;

　　　　　　Current=current.next;

　　　　}

　　　　if(previous== null){

　　　　　　First=newLink;

　　　　}else{

　　　　Previous.next= newLink;

　　　　newLink.next=current;

　　}

　　在链表上移动时，需要用一个previous引用，这样才能把前一个链结点的Next字段指向新的链结点。创建新链结点后，把current变量设为first，准备搜索正确的插入点。这时也把previous设为Null值，这步操作很重要，因为后面要用这个Null值判断是否仍在表头。

　　While循环和以前用来搜索插入点的代码类似，但是有一个附加的条件。如果当前检查的链结点的关键值不再小于待插入的链结点的关键值，则循环结束；这是最常见的情况，即新关键值插在链表中部的某个地方。 然而，如果current为Null值，while循环也会停止。这种情况发生在表尾，或者链表为空时。

　　如果current在表头或者链表为空，previous将为Null值；所以让first指向新的链结点。否则current处在链表中部或结尾，就使previous的next字段指向新的链结点。 不论哪种情况、都让新链结点的Next字段指向current。如果在表尾，current为Null值，则新链结点的Next字段也本应该设为这个值（Null）。

　　下面是有序链表的程序  SortedList.java程序实现了一个SortedList类，它拥有insert()、remove()和displayList()方法。只有insert()方法与无序链表中的insert()方法不同。

　　package 有序链表;

class Link{

　　public long dData;

　　public Link next;

　　public Link(long dd){

　　dData= dd;

　　}

　　//.........................

　　public void displayLink(){

　　　　System.out.print(dData+" ");

　　}

}

////////////////////////////////////////

class SortedList{

　　private Link first;

　　//..........................

　　public SortedList(){

　　　　first=null;

　　}

　　//.........................

　　public boolean isEmpty(){

　　　　return (first== null);

　　}

　　//..........................

　　public void insert(long key){

　　　　Link newLink=new Link(key);

　　　　Link previous= null;

　　　　Link current= first;

　　　　while(current!=null&&key>current.dData){

　　　　previous=current;

　　　　current=current.next;

　　　　}

　　　　if(previous== null){

　　　　　　 first=newLink;

　　　　} else{

　　　　　　previous.next= newLink;

　　　　　　newLink.next=current;

　　　　}

　　//................................

　　public Link remove(){

　　　　Link temp=first;

　　　　first= first.next;

　　　　return temp;

　　}

　　//................................

　　public void displayList(){

　　　　System.out.print("List (first-->last): ");

　　　　Link current= first;

　　　　while(current!=null){

　　　　　　current.displayLink();

　　　　　　current= current.next;

　　　　}

　　　　System.out.println("");

　　}

}

////////////////////////////////////////

public class SortedLinkApp{

　　public static void main(String[] args){

　　　　SortedList theSortedList=new SortedList();

　　　　theSortedList.insert(20);

　　　　theSortedList.insert(40);

　　　　theSortedList.displayList();

　　　　theSortedList.insert(10);

　　　　theSortedList.insert(30);

　　　　theSortedList.insert(50);

　　　　theSortedList.displayList();

　　　　theSortedList.remove();

　　　　theSortedList.displayList();

　　　　System.exit(0);

　　}

}

　　在Main()方法中，插入值为20和40的两个链结点。然后再插入三个链结点，分别是10、30和50。这三个值分别插在表头、表中和表尾。这说明insert()方法正确地处理了特殊情况。最后删除了一个链结点，表现出删除操作总是从表头进行。每一步变化后，都显示整个链表。

　　双向链表

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

　　/* 线性表的双向链表存储结构 */

　　typedef struct DuLNode{

　　　　ElemType data;

　　　　struct DuLNode *prior,*next;

　　}DuLNode,*DuLinkList;

　　/*带头结点的双向循环链表的基本操作(14个) */

　　void InitList(DuLinkList *L){/* 产生空的双向循环链表L */

　　　　*L=(DuLinkList)malloc(sizeof(DuLNode));   if(*L){

　　　　(*L)->next=(*L)->prior=*L;

　　　　}else{

　　　　　　exit(OVERFLOW);

　　　　}

　　void DestroyList(DuLinkList *L){

　　　　/* 操作结果：销毁双向循环链表L */

　　　　DuLinkList q,p=(*L)->next;/* p指向第一个结点 */

　　　　while(p!=*L){

　　　　　　/* p没到表头 */

　　 　　　　q=p->next;

　　　　　　free(p);

　　　　　　p=q;

　　　　}

　　　　free(*L);

　　　　*L=NULL;

　　}

　　void ClearList(DuLinkList L) {/* 不改变L */

　　　　/* 初始条件：L已存在。操作结果：将L重置为空表 */

　　　　DuLinkList q,p=L->next; /* p指向第一个结点 */

　　　　while(p!=L) {/* p没到表头 */

　　　　　　q=p->next;

　　　　　　free(p);

　　　　　　p=q;

　　　　}

　　　　L->next=L->prior=L; /* 头结点的两个指针域均指向自身 */

　　　　}

　　Status ListEmpty(DuLinkList L){ /* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */

　　　　　　if(L->next==L&&L->prior==L){

　　　　　　　　return TRUE;

　　　　　　}else{

　　　　　　　　return FALSE;

　　}

　　int ListLength(DuLinkList L){  /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */

　　　　　　int i=0;

　　　　　　DuLinkList p=L->next; /* p指向第一个结点 */

　　　　　　while(p!=L) {/* p没到表头 */

　　　　　　　　i++;

　　　　　　　　p=p->next;

　　　　　　}

　　　　　　return i;

　　}

　　Status GetElem(DuLinkList L,int i,ElemType *e){

　　　　　　/* 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR */

　　　　　　int j=1; /* j为计数器 */

　　　　　　DuLinkList p=L->next; /* p指向第一个结点 */

　　　　　　while(p!=L&&jnext){

　　　　　　　　j++;

　　　　　　}

　　　　　　if(p==L||j>i) /* 第i个元素不存在 { */

　　　　　　　　return ERROR;

　　　　　　｝

　　　　　　*e=p->data; /* 取第i个元素 */

　　　　　　return OK;

　　}

　　int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType)){

　　　　/* 初始条件：L已存在，compare()是数据元素判定函数 */

　　　　/* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */

　　　　/* 若这样的数据元素不存在，则返回值为0 */

　　　　int i=0;

　　　　DuLinkList p=L->next;/* p指向第1个元素 */

　　　　while(p!=L){

　　　　　　i++;

　　　　　　if(compare(p->data,e)){ /* 找到这样的数据元素 */

　　　　　　return i;

　　　　　　p=p->next;

　　　　}

　　　　return 0;

　　}

　　Status PriorElem(DuLinkList L,ElemType cur_e,ElemType *pre_e)   { /* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */

　　　　 /* 否则操作失败，pre_e无定义 */

　　　　DuLinkList p=L->next->next; /* p指向第2个元素 */

　　　　while(p!=L){ /* p没到表头*/

　　　　　　if(p->data==cur_e){

　　　　　　　　*pre_e=p->prior->data;

　　　　　　　　return TRUE;

　　　　　　}

　　　　　　p=p->next;

　　　　}

　　　　return FALSE;

　　}

　　Status NextElem(DuLinkList L,ElemType cur_e,ElemType *next_e){

　　/* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */

　　/* 否则操作失败，next_e无定义 */

　　　　DuLinkList p=L->next->next; /* p指向第2个元素 */

　　　　while(p!=L){ /* p没到表头 */

　　　　　　if(p->prior->data==cur_e)    {

　　　　　　　　*next_e=p->data;

　　　　　　　　return TRUE;

　　　　　　}

　　　　　　p=p->next;

　　　　}

　　　　return FALSE;

　　}

　　DuLinkList GetElemP(DuLinkList L,int i) {

　　/* 另加 */

　　/* 在双向链表L中返回第i个元素的地址。i为0，返回头结点的地址。若第i个元素不存在，*/

　　/* 返回NULL */

　　　　int j;

　　　　DuLinkList p=L; /* p指向头结点 */

　　　　if(i<0||i>ListLength(L))｛ /* i值不合法 */

　　　　　　return NULL;

　　　　｝

　　　　for(j=1;j<=i;j++)｛

　　　　　　p=p->next;

　　　　　　return p;

　　　　}

　　｝

　　Status ListInsert(DuLinkList L,int i,ElemType e)   { /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */

　　　　/* 改进算法2.18，否则无法在第表长+1个结点之前插入元素 */

　　　　DuLinkList p,s;

　　　　if(i<1||i>ListLength(L)+1)｛ /* i值不合法 */

　　　　　　return ERROR;

　　　　　　p=GetElemP(L,i-1); /* 在L中确定第i个元素前驱的位置指针p */

　　　　｝

　　　　if(!p) ｛/* p=NULL,即第i个元素的前驱不存在(设头结点为第1个元素的前驱) */

　　　　　　return ERROR;

　　　　　　s=(DuLinkList)malloc(sizeof(DuLNode));

　　　　｝

　　　　if(!s)｛

　　　　　　return OVERFLOW;

　　　　｝

　　　　s->data=e;

　　　　s->prior=p; /* 在第i-1个元素之后插入 */

　　　　s->next=p->next;

　　　　p->next->prior=s;

　　　　p->next=s;

　　　　return OK;

　　}

　　Status ListDelete(DuLinkList L,int i,ElemType *e){ /* 删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长 */

　　　　DuLinkList p;

　　　　if(i<1){ /* i值不合法 */

　　　　return ERROR;

　　　　}

　　　　p=GetElemP(L,i); /* 在L中确定第i个元素的位置指针p */

　　　　if(!p) {/* p=NULL,即第i个元素不存在 */

　　　　return ERROR;

　　　　}

　　　　*e=p->data;

　　　　p->prior->next=p->next;

　　　　p->next->prior=p->prior;

　　　　free(p);

　　　　return OK;

　　}

　　void ListTraverse(DuLinkList L,void(*visit)(ElemType))   { /* 由双链循环线性表L的头结点出发，正序对每个数据元素调用函数visit() */

　　　　DuLinkList p=L->next; /* p指向头结点 */

　　　　while(p!=L)   {

　　　　visit(p->data);

　　　　p=p->next;

　　　　}

　　　　printf("\n");

　　}

　　void ListTraverseBack(DuLinkList L,void(*visit)(ElemType))   { /* 由双链循环线性表L的头结点出发，逆序对每个数据元素调用函数visit()。另加 */

　　　　DuLinkList p=L->prior; /* p指向尾结点 */

　　　　while(p!=L)    {

　　　　visit(p->data);

　　　　p=p->prior;

　　　　}

　　　　printf("\n");

　　}

　　迭代器

　　迭代器是一种对象，它能够用来遍历STL容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。迭代器修改了常规指针的接口，所谓迭代器是一种概念上的抽象：那些行为上象迭代器的东西都可以叫做迭代器。然而迭代器有很多不同的能力，它可以把抽象容器和通用算法有机的统一起来。

　　迭代器提供一些基本操作符：*、++、==、！=、=。这些操作和C/C++“操作array元素”时的指针接口一致。不同之处在于，迭代器是个所谓的smart pointers，具有遍历复杂数据结构的能力。其下层运行机制取决于其所遍历的数据结构。因此，每一种容器型别都必须提供自己的迭代器。事实上每一种容器都将其迭代器以嵌套的方式定义于内部。因此各种迭代器的接口相同，型别却不同。这直接导出了泛型程序设计的概念：所有操作行为都使用相同接口，虽然它们的型别不同。

　　功能   迭代器使开发人员能够在类或结构中支持foreach迭代，而不必整个实现IEnumerable或者IEnumerator接口。只需提供一个迭代器，即可遍历类中的数据结构。当编译器检测到迭代器时，将自动生成IEnumerable接口或者IEnumerator接口的Current，MoveNext和Dispose方法。

　　特点

　　1.迭代器是可以返回相同类型值的有序序列的一段代码；

　　2.迭代器可用作方法、运算符或get访问器的代码体；

　　3.迭代器代码使用yield return语句依次返回每个元素，yield break将终止迭代；

　　4.可以在类中实现多个迭代器，每个迭代器都必须像任何类成员一样有惟一的名称，并且可以在foreach语句中被客户端代码调用；

　　5.迭代器的返回类型必须为IEnumerable和IEnumerator中的任意一种；

　　6.迭代器是产生值的有序序列的一个语句块，不同于有一个 或多个yield语句存在的常规语句块；

　　7.迭代器不是一种成员，它只是实现函数成员的方式，理解这一点是很重要的，一个通过迭代器实现的成员，可以被其他可能或不可能通过迭代器实现的成员覆盖和重载；

　　8.迭代器块在C#语法中不是独特的元素，它们在几个方面受到限制，并且主要作用在函数成员声明的语义上，它们在语法上只是语句块而已；