关于链表的几个常见的算法

说明：这里的链表均为带头结点的单链表

1、链表的有序合并：链表的数据结构如下
struct List
{
    int data;
    struct List *next;
};

已知现在有两个链表头La, Lb，且这两个链表的节点按data递增次序排列，要将这两个链表合并成一个链表Lc（可以破坏链表La，Lb的结构）

1. pc = Lc = La;
2. pa = La->next;
3. pb = Lb->next;
4.  
5.  
6. while(NULL != pa && NULL != pb)
7. {
8.     if( pa->data > pb->data)
9.     {
10.         pc->next = pb; pc = pb; pb++;
11.     }
12.     else
13.     {
14.         pc->next = pa; pc = pa; pa++;
15.     }
16. }
17. pc = pa ? pa : pb;

2、链表的就地逆置：不用额外的空间，将链表的指向反过来，比如原来的链表是：头->a->b->c变成 头->c->b->a

方法一：

1. curr = L->next;
2. nextPtr = NULL;
3.  
4. if( NULL != curr)
5.     nextPtr = curr->next;
6.  
7.  
8. while( NULL != nextPtr )
9. {
10.    temp = nextPtr->next;
11.    nextPtr->next = curr;
12.    curr = nextPtr;
13.    nextPtr = temp;
14. }
15.  
16.  
17. if( NULL != L->next)
18.     L->next->next = NULL;
19. L->next = curr;

方法二：前插

1. curr = L->next;
2.  
3. L->next = NULL;
4.  
5.  
6. while( NULL != curr )
7. {
8.     nextPtr = curr->next;
9.     curr->next = L->next;
10.     L->next = curr;
11.     curr = nextPtr;}

3、判断两个单链表是否相交，如果相交，指出相交处（单链表相交的意思是指部分节点有重合）

方法：如果LA，LB相交，那么最后一个节点肯定重合，只要遍历LA，LB到最后一个节点，判断其地址是否一样即可。

判断相交处的方法：判是否相交时已经遍历了两个链表，则记下这两个链表的长度，假设分别是lenA, lenB;且
lenA > lenB ,那么进行第二次遍历，且令LA先走（lenA - lenB）步，然后两个链表一起遍历，中途遇到的相同地址的节点，肯定是链表的相交处。


4、判断单链表是否是有环。（有环的意思是某个节点的指针域指向该链表先前的节点）

方法：有两个遍历指针，一个指针一次走一步（慢指针），另一个指针一次走两步（快指针）；如果快指针最后为空，则说明无环；如果快指针在遍历的过程中与慢指针相等，则说明有环。

1. bool haveRing(struct List *L)
2. {
3.     struct List *pfast, *pslow;
4.     pfast = pslow = L;
5.  
6.     do
7.     {
8.         pfast = pfast->next;
9.         if( NULL == pfast)
10.             break;
11.         else pfast = pfast->next;
12.  
13.         pslow = pslow->next;
14.         
15.         if( pslow == pfast)
16.              break;
17.     }while(NULL != pfast);
18.     
19.     return (NULL != pfast);
20. }