链表操作

1链表逆序 http://blog.csdn.net/niuer09/article/details/5961004 

typedef struct tagListNode{
    int data;
    struct tagListNode* next;
}ListNode, *List;

List ReverseList(List head)  
{  
    if(head->next == NULL || head->next->next == NULL)    
    {  
       return head;   /*链表为空或只有一个元素则直接返回*/  
    }  
  
    ListNode *t = NULL,  
             *p = head->next,  
             *q = head->next->next;  
    while(q != NULL)  
    {          
      t = q->next;  
      q->next = p;  
      p = q;  
      q = t;  
    }  
  
    /*此时q指向原始链表最后一个元素，也是逆转后的链表的表头元素*/  
    head->next->next = NULL;  /*设置链表尾*/  
    head->next = p;           /*调整链表头*/  
    return head;  
}

2判断是否有环，环的长度

http://www.cnblogs.com/xudong-bupt/p/3667729.html

///判断链表是否有环
LinkNode* judgeRing(Linklist list){
    LinkNode *fast = list;
    LinkNode *slow = list;

    if(list == NULL)
        return NULL;

    while(true){
        if(slow->next != NULL && fast->next != NULL && fast->next->next != NULL){
            slow = slow->next;
            fast = fast->next->next;
        }
        else
            return NULL;

        if(fast == slow)
            return fast;
    }
}

///获取链表环长
int getRingLength(LinkNode *meetNode){
    int RingLength=0;
    LinkNode *fast = meetNode;
    LinkNode *slow = meetNode;
    for(;;){
        fast = fast->next->next;
        slow = slow->next;
        RingLength++;
        if(fast == slow)
            break;
    }
    return RingLength;
}

///获取链表头到环连接点的长度
int getLenA(Linklist list,LinkNode *meetNode){
    int lenA=0;
    LinkNode *fast = list;
    LinkNode *slow = meetNode;
    for(;;){
        fast = fast->next;
        slow = slow->next;
        lenA++;
        if(fast == slow)
            break;
    }
    return lenA;
}

3两个有序链表的合并

node merge_sorted_list(const node head1,const node head2)
{
    if((NULL == head1) && (NULL == head1))
    {
        return NULL;
    }
    else if(NULL == head1)
    {
        return head2;
    }
    else if(NULL == head2)
    {
        return head1;
    }
    else
    {    
        node head = NULL,p1 = NULL,p2 = NULL;


        if(head1->value >= head2->value)
        {
            head = head1;
            p1 = head1->next;
            p2 = head2;
        }
        else
        {        
            head = head2;
            p2 = head2->next;
            p1 = head1;
        }

        node p = head;

        while((NULL != p1) && (NULL != p2))
        {
            if(p1->value >= p2->value)
            {
            
                p->next = p1;
                p = p1;
                p1 = p1->next;
            }
            else
            {
                p->next = p2;
                p = p2;
                p2 = p2->next;
            }
        }
        
        p->next = p1 ? p1 : p2;
        //if(NULL != p1->next)
        //    p->next = p1;
        //else
        //    p->next = p2;
        return head;        
    }
}


递归方法：
Node * MergeRecursive(Node *head1 , Node *head2)
{
    if ( head1 == NULL )
        return head2 ;

    if ( head2 == NULL)
        return head1 ;

    Node *head = NULL ;

    if ( head1->value > head2->value )
    {
        head = head1 ;
        head->next = MergeRecursive(head1->next,head2);
    }
    else
    {
        head = head2 ;
        head->next = MergeRecursive(head1,head2->next);
    }

    return head ;
}