（1）題目：輸入兩個連結串列，找出它們的第一個公共節點。

思路：
1）計算出連結串列1的長度；
2）計算出連結串列2的長度；
3）計算出連結串列1和連結串列2的長度差dif；
4）長連結串列先走dif步，然後兩條連結串列一起走，直到兩個連結串列的節點第一次相等為止，此時指標位置即為所求。

程式碼實現：

class Solution {
public:
   ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        ListNode *p1=pHead1;
        ListNode *p2=pHead2;
        int
 
 len1=0,len2=0,dif=0;
        while(p1!=NULL){
            p1=p1->next;
            len1++;
        }
        while(p2!=NULL){
            p2=p2->next;
            len2++;
        }
        if(len1>len2){
            dif=len1-len2;
            p1=pHead1;
            p2=pHead2;
        }
        else
 
{
            dif=len2-len1;
            p1=pHead2;
            p2=pHead1;
        }
        for(int i=0;i<dif;i++){
            p1=p1->next;
        }
        while(p1!=NULL && p2!=NULL){
            if(p1==p2)
                break;
            p1=p1->next;
            p2=p2->next
 
;
        }
        return p1;
    }
};

（2）題目：刪除連結串列中重複的節點

程式碼實現：

class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {

       if (pHead==NULL)
            return NULL;
        if (pHead!=NULL && pHead->next==NULL)
            return pHead;

        ListNode* current;

        if ( pHead->next->val==pHead->val){
            current=pHead->next->next;
            while (current != NULL && current->val==pHead->val)
                current=current->next;
            return deleteDuplication(current);                     
        }   
        else {
            current=pHead->next;
            pHead->next=deleteDuplication(current);
            return pHead;
        }    
    }
};

（3）題目：sort-list：Sort a linked list in O(n log n) time using constant space complexity.

思路：
（1）快慢指標法將連結串列從中間分為了l1，l2兩部分
（2）左右兩部分連結串列分別遞迴進行排序
（3）合併兩個子連結串列

程式碼實現：

class Solution {
public:
    ListNode *sortList(ListNode *head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode* p = head;
        ListNode* q = head->next;
        while(q && q->next)
        {
            p = p->next;
            q = q->next->next;
        }

        ListNode* l1 = sortList(p->next);
        p->next = NULL;
        ListNode* l2 = sortList(head);
        return Merge(l1,l2);
    }
        ListNode* Merge(ListNode* l1,ListNode* l2)
        {
            ListNode L(0);
            ListNode* p = &L;
            while(l1&&l2)
            {
                if(l1->val < l2->val)
                {
                    p->next = l1;
                    l1=l1->next;
                }
                else
                {
                    p->next = l2;
                    l2=l2->next;
                }
                p = p -> next;
            }
            if(l1 != NULL)
                p->next = l1;
            if(l2 != NULL)
                p->next = l2;
            return L.next;
        }
};

（4）題目：Given a singly linked list L: L 0→L 1→…→L n-1→L n,
reorder it to: L 0→L n →L 1→L n-1→L 2→L n-2→…
You must do this in-place without altering the nodes’ values.
For example,
Given{1,2,3,4}, reorder it to{1,4,2,3}.

思路：
（1）快慢指標法找到中間節點
（2）對連結串列後半部分進行逆序
（3）合併前半部分和逆序後的後半部分

程式碼實現：

class Solution {
public:
    void reorderList(ListNode *head) {
        if(head == NULL || head->next == NULL || head->next->next == NULL)
            return;

        //快慢指標找中點
        ListNode* fast = head;
        ListNode* low = head;
        while(fast->next != NULL && fast->next->next != NULL)
        {
            fast = fast->next->next;
            low = low->next;
        }

        //對low後面的部分逆序
        fast = low->next;
        low->next = NULL;
        while(fast != NULL){
            ListNode* temp = fast->next;
            fast->next = low->next;
            low->next = fast;
            fast = temp;
        }

        //合併low前面和後面兩部分
        ListNode* p = head;
        ListNode* q = low->next;
        while(p != NULL && q != NULL){
            low->next = q->next;
            q->next = p->next;
            p->next = q;
            p = q->next;
            q = low->next;
        }
    }
};

（5）題目：Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.
You should preserve the original relative order of the nodes in each of the two partitions.
For example,
Given1->4->3->2->5->2and x = 3,
return1->2->2->4->3->5..

思路：
（1）新建兩個節點分別為fast和slow，分別指向兩個頭結點；
（2）從頭到尾遍歷，小於x值的節點連線到p1，大於等於x的值的節點連結到p2；
（3）最後將兩個連結串列相連。

程式碼實現:

class Solution {
public:
    ListNode *partition(ListNode *head, int x) {
        if(head == NULL)
            return NULL;
        ListNode* fast = new ListNode(0);
        ListNode* slow = new ListNode(0);
        ListNode* p1 = slow;
        ListNode* p2 = fast;
        ListNode *p = head;
        while(p!=NULL)
        {
            if(p->val < x)
            {
                p1->next = p;
                p1 = p1->next;
            }
            else
            {
                p2->next = p;
                p2 = p2->next;
            }
            p = p->next;
        }
        p2->next = NULL;
        p1->next = fast->next;
        return slow->next;
    }
};