基本数据结构：链表（list）
谈到链表之前，先说一下线性表。线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。线性表有两种存储方式，一种是顺序存储结构，另一种是链式存储结构。
顺序存储结构就是两个相邻的元素在内存中也是相邻的。这种存储方式的优点是查询的时间复杂度为O(1)，通过首地址和偏移量就可以直接访问到某 元素，关于查找的适配算法很多，最快可以达到O(logn)。缺点是插入和删除的时间复杂度最坏能达到O(n)，如果你在第一个位置插入一个元素，你需要 把数组的每一个元素向后移动一位，如果你在第一个位置删除一个元素，你需要把数组的每一个元素向前移动一位。还有一个缺点，就是当你不确定元素的数量时， 你开的数组必须保证能够放下元素最大数量，遗憾的是如果实际数量比最大数量少很多时，你开的数组没有用到的内存就只能浪费掉了。
我们常用的数组就是一种典型的顺序存储结构，如图1。
链式存储结构就是两个相邻的元素在内存中可能不是相邻的，每一个元素都有一个指针域，指针域一般是存储着到下一个元素的指针。这种存储方式的优点是 插入和删除的时间复杂度为O(1)，不会浪费太多内存，添加元素的时候才会申请内存，删除元素会释放内存，。缺点是访问的时间复杂度最坏为O(n)，关于 查找的算法很少，一般只能遍历，这样时间复杂度也是线性（O(n)）的了,频繁的申请和释放内存也会消耗时间。
顺序表的特性是随机读取，也就是访问一个元素的时间复杂度是O(1)，链式表的特性是插入和删除的时间复杂度为O(1)。要根据实际情况去选取适合自己的存储结构。
链表就是链式存储的线性表。根据指针域的不同，链表分为单向链表、双向链表、循环链表等等。
一、 单向链表（slist）
链表中最简单的一种是单向链表，每个元素包含两个域，值域和指针域，我们把这样的元素称之为节点。每个节点的指针域内有一个指针，指向下一个节点，而最后一个节点则指向一个空值。如图2就是一个单向链表。
一个单向链表的节点被分成两个部分。第一个部分保存或者显示关于节点的信息，第二个部分存储下一个节点的地址。单向链表只可向一个方向遍历。
我写了一个简单的C++版单向链表类模板，就用这段代码讲解一下一个具体的单向链表该怎么写（代码仅供学习），当然首先你要具备C++基础知识和简单的模板元编程。
完整代码
首先我们要写一个节点类，链表中的每一个节点就是一个节点类的对象。如图3。
代码如下：
template<class T> class slistNode { public: slistNode(){next=NULL;}//初始化 T data;//值 slistNode* next;//指向下一个节点的指针 };
第二步，写单链表类的声明，包括属性和方法。
代码如下：
template<class T> class myslist { private: unsigned int listlength; slistNode<T>* node;//临时节点 slistNode<T>* lastnode;//头结点 slistNode<T>* headnode;//尾节点 public: myslist();//初始化 unsigned int length();//链表元素的个数 void add(T x);//表尾添加元素 void traversal();//遍历整个链表并打印 bool isEmpty();//判断链表是否为空 slistNode<T>* find(T x);//查找第一个值为x的节点,返回节点的地址,找不到返回NULL void Delete(T x);//删除第一个值为x的节点 void insert(T x,slistNode<T>* p);//在p节点后插入值为x的节点 void insertHead(T x);//在链表的头部插入节点 };
第三步，写构造函数，初始化链表类的属性。
代码如下：
template<class T> myslist<T>::myslist() { node=NULL; lastnode=NULL; headnode=NULL; listlength=0; }
第四步，实现add()方法。
代码如下：
template<class T> void myslist<T>::add(T x) { node=new slistNode<T>();//申请一个新的节点 node->data=x;//新节点赋值为x if(lastnode==NULL)//如果没有尾节点则链表为空,node既为头结点,又是尾节点 { headnode=node; lastnode=node; } else//如果链表非空 { lastnode->next=node;//node既为尾节点的下一个节点 lastnode=node;//node变成了尾节点,把尾节点赋值为node } ++listlength;//元素个数+1 }
第五步，实现traversal()函数，遍历并输出节点信息。
代码如下：
template<class T> void myslist<T>::traversal() { node=headnode;//用临时节点指向头结点 while(node!=NULL)//遍历链表并输出 { cout<<node->data<<ends; node=node->next; } cout<<endl; }
第六步，实现isEmpty()函数，判断链表是否为空，返回真为空，假则不空。
代码如下：
template<class T> bool myslist<T>::isEmpty() { return listlength==0; }
第七步，实现find()函数。
代码如下：
template<class T> slistNode<T>* myslist<T>::find(T x) { node=headnode;//用临时节点指向头结点 while(node!=NULL&&node->data!=x)//遍历链表,遇到值相同的节点跳出 { node=node->next; } return node;//返回找到的节点的地址,如果没有找到则返回NULL }
第八步，实现delete()函数，删除第一个值为x的节点，如图4。
代码如下：
template<class T> void myslist<T>::Delete(T x) { slistNode<T>* temp=headnode;//申请一个临时节点指向头节点 if(temp==NULL) return;//如果头节点为空,则该链表无元素,直接返回 if(temp->data==x)//如果头节点的值为要删除的值,则删除投节点 { headnode=temp->next;//把头节点指向头节点的下一个节点 if(temp->next==NULL) lastnode=NULL;//如果链表中只有一个节点,删除之后就没有节点了,把尾节点置为空 delete(temp);//删除头节点 return; } while(temp->next!=NULL&&temp->next->data!=x)//遍历链表找到第一个值与x相等的节点,temp表示这个节点的上一个节点 { temp=temp->next; } if(temp->next==NULL) return;//如果没有找到则返回 if(temp->next==lastnode)//如果找到的时候尾节点 { lastnode=temp;//把尾节点指向他的上一个节点 delete(temp->next);//删除尾节点 temp->next=NULL; } else//如果不是尾节点,如图4 { node=temp->next;//用临时节点node指向要删除的节点 temp->next=node->next;//要删除的节点的上一个节点指向要删除节点的下一个节点 delete(node);//删除节点 node=NULL; } }
第九步，实现insert()和insertHead()函数，在p节点后插入值为x的节点。如图5。
代码如下：
template<class T> void myslist<T>::insert(T x,slistNode<T>* p) { if(p==NULL) return; node=new slistNode<T>();//申请一个新的空间 node->data=x;//如图5 node->next=p->next; p->next=node; if(node->next==NULL)//如果node为尾节点 lastnode=node; } template<class T> void myslist<T>::insertHead(T x) { node=new slistNode<T>(); node->data=x; node->next=headnode; headnode=node; }
最终，我们完成一个简单的单向链表。此单向链表代码还有很多待完善的地方，以后会修改代码并不定时更新。
二、 双向链表
双向链表的指针域有两个指针，每个数据结点分别指向直接后继和直接前驱。单向链表只能从表头开始向后遍历，而双向链表不但可以从前向后遍历，也可以 从后向前遍历。除了双向遍历的优点，双向链表的删除的时间复杂度会降为O（1），因为直接通过目的指针就可以找到前驱节点，单向链表得从表头开始遍历寻找 前驱节点。缺点是每个节点多了一个指针的空间开销。如图6就是一个双向链表。
三、 循环链表
循环链表就是让链表的最后一个节点指向第一个节点，这样就形成了一个圆环，可以循环遍历。单向循环链表可以单向循环遍历，双向循环链表的头节点的指针也要指向最后一个节点，这样的可以双向循环遍历。如图7就是一个双向循环链表。
四、 链表相关问题
1、如何判断一个单链表有环
2、如何判断一个环的入口点在哪里
3、如何知道环的长度
4、如何知道两个单链表（无环）是否相交
5、如果两个单链表（无环）相交，如何知道它们相交的第一个节点是什么
6、如何知道两个单链表（有环）是否相交
7、如果两个单链表（有环）相交，如何知道它们相交的第一个节点是什么
1、采用快慢步长法。
令两个指针p和q分别指向头结点，p每次前进一步，q每次前进两步，如果p和q能重合，则有环。可以这么理解，这种做法相当于p静止不动，q每次前进一步，所有肯定有追上p的时候。
我们注意到，指针p和q分别以速度为1和2前进。如果以其它速度前进是否可以呢？
假设p和q分别以速度为v1和v2前进。如果有环，设指针p和q第一次进入环时，他们相对于环中第一个节点的偏移地址分别为a和b（可以把偏移地址理解为节点个数）
这样，可以看出，链表有环的充要条件就是某一次循环时，指针p和q的值相等，就是它们相对环中首节点的偏移量相等。我们设环中的结点个数为n,程序循环了m次。
由此可以有下面等式成立：(mod(n)即对n取余)
(a+m*v1)mod(n) = (b+m*v2) mod(n)
设等式左边mod(n)的最大整数为k1，等式右边mod(n)的最大整数为k2，则
(a+m*v1)-k1*n = (b+m*v2)-k2*n
整理以上等式：
m= |((k2-k1)*n+a-b)/( v2-v1)| ①
如果是等式①成立，就要使循环次数m为一整数。显然如果v2-v1为1，则等式成立。
这样p和q分别以速度为v1和v2且|v2-v1|为1时，按以上算法就可找出链表中是否有环。当然|v2-v1|不为1时，也可能可以得出符合条件的m。
bool IsExitsLoop(slist *head) { slist *slow = head, *fast = head; while ( fast && fast->next ) { slow = slow->next; fast = fast->next->next; if ( slow == fast ) break; } return !(fast == NULL || fast->next == NULL); }
时间复杂度分析：假设甩尾（在环外）长度为 len1（结点个数），环内长度为 len2，链表总长度为n，则n=len1+len2 。 当p步长为1，q步长为2时，p指针到达环入口需要len1时间，p到达入口后，q处于哪里不确定，但是肯定在环内，此时p和q开始追赶，q最长需要 len2时间就能追上p（p和q都指向环入口），最短需要1步就能追上p（p指向环入口，q指向环入口的前一个节点）。事实上，每经过一步，q和p的距离 就拉近一步，因此，经过q和p的距离步就可以追上p。因此总时间复杂度为O(n)，n为链表的总长度。
2、分别从链表头和碰撞点，同步地一步一步前进扫描，直到碰撞，此碰撞点即是环的入口。
证明如下：
链表形状类似数字 6 。
假设甩尾（在环外）长度为 a（结点个数），环内长度为 b 。
则总长度（也是总结点数）为 a+b 。
从头开始，0 base 编号。
将第 i 步访问的结点用 S(i) 表示。i = 0, 1 ...
当 i＜a 时，S(i)=i ；
当 i≥a 时，S(i)=a+(i-a)%b 。
分析追赶过程。
两个指针分别前进，假定经过 x 步后，碰撞。则有：S(x)=S(2x)
由环的周期性有：2x=tb+x 。得到 x=tb 。
另，碰撞时，必须在环内，不可能在甩尾段，有 x>=a 。
连接点为从起点走 a 步，即 S(a)。
S(a) = S(tb+a) = S(x+a)。
得到结论：从碰撞点 x 前进 a 步即为连接点。
根据假设易知 S(a-1) 在甩尾段，S(a) 在环上，而 S(x+a) 必然在环上。所以可以发生碰撞。
而，同为前进 a 步，同为连接点，所以必然发生碰撞。
综上，从 x 点和从起点同步前进，第一个碰撞点就是连接点。
slist* FindLoopPort(slist *head) { slist *slow = head, *fast = head; while ( fast && fast->next ) { slow = slow->next; fast = fast->next->next; if ( slow == fast ) break; } if (fast == NULL || fast->next == NULL) return NULL; slow = head; while (slow != fast) { slow = slow->next; fast = fast->next; } return slow; }
时间复杂度分析：假设甩尾（在环外）长度为 len1（结点个数），环内长度为 len2 。则时间复杂度为“环是否存在的时间复杂度”+O（len1）
3、从碰撞点开始，两个指针p和q，q以一步步长前进，q以两步步长前进，到下次碰撞所经过 的操作次数即是环的长度。这很好理解，比如两个运动员A和B从起点开始跑步，A的速度是B的两倍，当A跑玩一圈的时候，B刚好跑完两圈，A和B又同时在起 点上。此时A跑的长度即相当于环的长度。
假设甩尾（在环外）长度为 len1（结点个数），环内长度为 len2 ，则时间复杂度为“环是否存在的时间复杂度”+O(len2)。
4、法一：将链表A的尾节点的next指针指向链表B的头结点，从而构造了一个新链表。问题转化为求这个新链表是否有环的问题。
时间复杂度为环是否存在的时间复杂度，即O（length(A)+length(B)），使用了两个额外指针
法二：两个链表相交，则从相交的节点起，其后的所有的节点都是都是两个链表共有的。因此，如果它们相交，则最后一个节点一定是共有的。因此，判断两链表 相交的方法是：遍历第一个链表，记住最后一个节点。然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交。
时间复杂度：O（length(A)+length(B)），但是只用了一个额外指针存储最后一个节点
5、将链表A的尾节点的next指针指向链表B的头结点，从而构造了一个环。问题转化为求这个环的入口问题。
时间复杂度：求环入口的时间复杂度
6、分别判断两个链表A、B是否有环（注，两个有环链表相交是指这个环属于两个链表共有）
如果仅有一个有环，则A、B不可能相交
如果两个都有环，则求出A的环入口，判断其是否在B链表上，如果在，则说明A、B相交。
时间复杂度：“环入口问题的时间复杂度”+O（length（B））
7、分别计算出两个链表A、B的长度LA和LB（环的长度和环到入口点长度之和就是链表长度），参照问题3。
如果LA>LB，则链表A指针先走LA-LB，链表B指针再开始走，则两个指针相遇的位置就是相交的第一个节点。
如果LB>LA，则链表B指针先走LB-LA，链表A指针再开始走，则两个指针相遇的位置就是相交的第一个节点。
时间复杂度：O（max（LA,LB））