leetcode链表题

1. sort_list

Sort a linked list in O(n log n) time using constant space complexity.

分析：时间复杂度是nlogn,所以可以考虑归并排序。取中点，对左边和右边分别递归排序，最后合并。

知识点：快慢指针，用来取链表中点；归并排序。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *sortList(ListNode *head) {
        if(!head||!head->next)return head;
        ListNode *first = head;
        ListNode *second = head->next;
        while(second&&second->next){
            first=first->next;
            second=second->next->next;
        }
        ListNode *left = sortList(first->next);
        first->next = NULL;
        ListNode *right = sortList(head);
        return merge(left,right);
    }
    ListNode *merge(ListNode *head1, ListNode *head2)
     {
         if(head1 == NULL)return head2;
         if(head2 == NULL)return head1;
         ListNode *res , *p ;
         if(head1->val < head2->val)
             {res = head1; head1 = head1->next;}
         else{res = head2; head2 = head2->next;}
         p = res;
         
         while(head1 != NULL && head2 != NULL)
         {
             if(head1->val < head2->val)
             {
                 p->next = head1;
                 head1 = head1->next;
             }
             else
             {
                 p->next = head2;
                 head2 = head2->next;
             }
             p = p->next;
         }
         if(head1 != NULL)p->next = head1;
         else if(head2 != NULL)p->next = head2;
         return res;
     }
};

2. linked-list-cycle-ii

Given a linked list, return the node where the cycle begins. If there is no cycle, returnnull.

Follow up:
Can you solve it without using extra space?

分析：寻找链表的入环节点，也是使用快慢指针，快慢指针第一次相遇后将快指针放回链表头，然后以相同的速度前进，再次相遇的节点就是链表的入环节点。

知识点：快慢指针找入环节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        while(!head||!head->next)return nullptr;
        ListNode *slow = head;
        ListNode *fast = head;
        while(fast != NULL && fast->next != NULL){
            slow=slow->next;
            fast=fast->next->next;
            if(fast==slow)break;
        }
        if(!fast||!fast->next)return nullptr;
        fast=head;
        while(slow != fast){
            slow = slow->next;
            fast = fast->next;
        }
        return slow;
    }
};

 3. convert-sorted-list-to-binary-search-tree

     Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

分析：可以递归建立平衡二叉查找树，将链表中间的值设为树的根，对左边和右边分别建立二叉查找树。

知识点：递归，快慢指针

class Solution {
public:
    TreeNode *sortedListToBST(ListNode *head) {
        return ToBST(head,nullptr);
    }
    TreeNode *ToBST(ListNode *head,ListNode *tail){
        if(head==tail)return nullptr;
        ListNode *fast = head;
        ListNode *slow = head;
        while(fast!=tail&&fast->next!=tail){
            fast=fast->next->next;
            slow=slow->next;
        }
        TreeNode *tr= new TreeNode(slow->val);
        tr->left = ToBST(head,slow);
        tr->right = ToBST(slow->next,tail);
        return tr;
    }
};

 4. partition-list

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.

 分析：将小于某值的节点按顺序移至前面，我这里为了方便直接建立了两个vector分别按序存储值小于x和大于等于x的节点。

class Solution {
public:
    ListNode *partition(ListNode *head, int x) {
        vector<int> a;
        vector<int> b;
        ListNode *li=head;
        while(li){
            if(li->val<x)a.push_back(li->val);
            else b.push_back(li->val);
            li = li->next;
        }
        li = head;
        for(int i=0;i<a.size();i++){
            li->val=a[i];
            li=li->next;
        }
        for(int i=0;i<b.size();i++){
            li->val=b[i];
            li=li->next;
        }
        return head;
    }
};

5. remove-duplicates-from-sorted-list

Given a sorted linked list, delete all duplicates such that each element appear only once.

For example,
Given1->1->2, return1->2.
Given1->1->2->3->3, return1->2->3. 

class Solution {
public:
    ListNode *deleteDuplicates(ListNode *head) {
        ListNode *li = head;
        while(li&&li->next){
            while(li&&li->next&&(li->next->val == li->val))
                li->next = li->next->next;
            li = li->next;
        }
        return head;
    }
};

 6. remove-duplicates-from-sorted-list-ii

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

For example,
Given1->2->3->3->4->4->5, return1->2->5.
Given1->1->1->2->3, return2->3.

分析：这里创建了一个新的头节点，作为第一个不重复的节点；

class Solution {
public:
    ListNode *deleteDuplicates(ListNode *head) {
        if((!head)||(!head->next))return head;
        ListNode *newHead = new ListNode(head->val-1);
        newHead->next = head;
        ListNode *last = newHead;
        ListNode *cur = head;
        while(cur&&cur->next){
            if(cur->val!=cur->next->val){
                last = cur;
            }
            else{
                while(cur&&cur->next&&(cur->val==cur->next->val)){
                    cur = cur->next;
                }
                last->next = cur->next;
            }
            cur = cur->next;
        }
        return newHead->next;
    }
};