剑☞offer~转自牛客网

算法1：

输入一个链表，反转链表后，输出链表的所有元素。

/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode *ans = NULL;
        ListNode *temp = NULL;
        
        while(pHead){
            temp = ans;
            ans = pHead;
            pHead = pHead->next;
            ans->next = temp;
        }
        
        return ans;
    }
};
/*
*链表的逆转是可以让我们从一个链表中取到数据然后再加入另一个链表
*在此过程中我们需要把新建数据保存起来，后面再以此加入到我们新的数据后面->next
*/

算法2：

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        if(pHead1 == NULL && pHead2 == NULL){
            return NULL;
        }
        if(pHead1 == NULL || pHead2 == NULL){
            return pHead1 == NULL ? pHead2 : pHead1;
        }
        ListNode *pt1 = pHead1;
        ListNode *pt2 = pHead2;
        ListNode *temp = NULL;
        ListNode *newList = NULL;
        
        if(pt1->val <= pt2->val){
               temp = newList = pt1;
                pt1 = pt1->next;
            }else{
                temp = newList = pt2;
                pt2 = pt2->next;
        }
        
        while(pt1 != NULL && pt2 != NULL)
        {
            if(pt1->val <= pt2->val){
                temp->next = pt1;
                pt1 = pt1->next;
            }else{
                temp->next = pt2;
                pt2 = pt2->next;
            }
            temp = temp->next;
        }
        if(pt2 != NULL)
        {
           temp->next = pt2;       
        }
        if(pt1 != NULL)
        {
           temp->next = pt1;
        }
        return newList;
    }
};