三、链表

链结点

在链表中，每个数据项都被包含在‘点“中，一个点是某个类的对象，这个类可认叫做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#语法中不是独特的元素，它们在几个方面受到限制，并且主要作用在函数成员声明的语义上，它们在语法上只是语句块而已；