Leetcode 链表解法

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct ListNode
{
    int val;
    ListNode* next;
    ListNode(int x):val(x),next(NULL){}
};

bool cmp1(const ListNode* a,const ListNode* b)
{
    return a->val < b->val;
}

class Solution
{
public:
    /***************************************************
    *  函数功能： 链表逆序 （不可申请额外空间）
    *  参数说明
    *
    *  日期：2018-06-09-16.25
    ***************************************************/
    ListNode* reverseList(ListNode* head)
    {
        ListNode* result=NULL;
        while(head)
        {
            ListNode* temp=head->next;
            head->next=result;
            result=head;
            head=temp;
        }
        return result;
    }
    /***************************************************
    *  函数功能：链表逆序（从m到n逆序，不可申请额外空间）
    *  参数说明
    *
    *  日期：2018-06-09-16.42
    ***************************************************/
    ListNode* reverseBetween(ListNode* head,int m,int n)
    {
        if(head==NULL || m<0 || m>n) return NULL;
        ListNode* result=head;
        ListNode* preStart=NULL;

        int len=n-m+1;
        while(head && --m)
        {
            preStart=head;
            head=head->next;
        }

        ListNode* Start=head;
        ListNode* PreEnds=NULL;

        while(len && head)
        {
            ListNode* temp=head->next;
            head->next=PreEnds;
            PreEnds=head;
            head=temp;
            len--;
        }
        Start->next=head;
        if(preStart)
        {
            preStart->next=PreEnds;
        }else
        {
            result=PreEnds;
        }

        return result;
    }

    /***************************************************
    *  函数功能： 求两个链表的交点
    *  参数说明
    *
    *  日期：2018-06-09-17.24
    ***************************************************/
    int Length_Link(ListNode* head)
    {
        int len=0;
        while(head)
        {
            len++;
            head=head->next;
        }
        return len;
    }
    ListNode* getIntersectionNode(ListNode* headA,ListNode* headB)
    {
        if(headA==NULL || headB==NULL) return NULL;
        int lenA=Length_Link(headA);
        int lenB=Length_Link(headB);
        cout<<"lenA "<<lenA<<"  lenB "<<lenB<<endl;
        int len=0;
        if(lenA>=lenB)
        {
            len=lenA-lenB;
            while(len-- && headA)
            {
                headA=headA->next;
            }

        }else
        {
            len=lenB-lenA;
            while(len-- && headB)
            {
                headB=headB->next;
            }
        }
        while(headB && headA)
        {
            if(headA==headB)
            {
                return headB;
            }
            headB=headB->next;
            headA=headA->next;
        }

        return NULL;
    }

    /***************************************************
    *  函数功能：  链表是否存在环，若有环，则返回环的起始节点，否则返回NULL
    *  参数说明
    *
    *  日期：2018-06-09-17.49
    ***************************************************/
    ListNode* detectCycle(ListNode* head)
    {
        ListNode* slow=head;
        ListNode* fast=head;
        int flag=0;
        while(fast && slow)
        {
            fast=fast->next;
            if(fast==NULL)
            {
                return NULL;
            }
            slow=slow->next;
            fast=fast->next;
            if(slow==fast)
            {
                flag=1;
                break;
            }
        }

        while(flag)
        {
            head=head->next;
            fast=fast->next;
            if(head==fast)
            {
                return fast;
            }

         }
         return NULL;

    }

    /***************************************************
    *  函数功能： 链表的划分，将所有小于X的节点放在大于或等于x的节点前，且保存这些节点的原来相对位置；
    *  参数说明
    *
    *  日期：2018-06-09-18.15
    ***************************************************/
    ListNode* partitionL(ListNode* head,int x)
    {
        ListNode  less_head(0);
        ListNode  more_head(0);
        ListNode* underX=&less_head;
        ListNode* overX=&more_head;

        while(head)
        {
            if(head->val < x)
            {
                underX->next=head;
                underX=head;
            }else
            {
                overX->next=head;
                overX=head;
            }
            head=head->next;
        }

        underX->next=more_head.next;
        overX->next=NULL;
        return less_head.next;
    }
    /***************************************************
    *  函数功能：2个排序链表的合并
    *  参数说明
    *
    *  日期：2018-06-09-19.20
    ***************************************************/
    ListNode* MergeTwoSort(ListNode* headA,ListNode* headB)
    {
        ListNode result(0);
        ListNode* res=&result;
        while(headA && headB)
        {
            if(headA->val <= headB->val)
            {
                res->next=headA;
                res=headA;
                headA=headA->next;
            }else
            {
                res->next=headB;
                res=headB;
                headB=headB->next;
            }
        }
        if(headA)
        {
            res->next=headA;
        }
        if(headB)
        {
            res->next=headB;
        }
        return result.next;
    }
    /***************************************************
    *  函数功能：多个链表的合并 时间复杂度0(knlogkn)
    *  参数说明
    *
    *  日期：2018-06-09-19.33
    ***************************************************/

    ListNode* mergeKLists(std::vector<ListNode*>& lists)
    {
        std::vector<ListNode*> result;
        for(int i=0;i<lists.size();i++)
        {
            ListNode* head=lists[i];
            while(head)
            {
                result.push_back(head);
                head=head->next;
            }
        }
        if(result.size()==0)
        {
            return NULL;
        }


       std::sort(result.begin(), result.end(),cmp1);
        for(int i=1;i<result.size();i++)
        {
            result[i-1]->next=result[i];
        }
        result[result.size()-1]->next=NULL;
        return result[0];

    }

    /***************************************************
    *  函数功能：多个链表的合并 时间复杂度0(knlogk)
    *  参数说明
    *
    *  日期：2018-06-10-08.51
    ***************************************************/
    ListNode* mergeKLists2(std::vector<ListNode*>& lists)
    {
        if(lists.size()==0) return NULL;
        if(lists.size()==1) return lists[0];
        if(lists.size()==2) return MergeTwoSort(lists[0],lists[1]);
        std::vector<ListNode*> l1;
        std::vector<ListNode*> l2;
        int mid=lists.size()/2;
        for(int i=0;i<mid;i++)
        {
            l1.push_back(lists[i]);
        }
        for(int i=mid;i<lists.size();i++)
        {
            l2.push_back(lists[i]);
        }
        ListNode* sub1=mergeKLists2(l1);
        ListNode* sub2=mergeKLists2(l2);
        return MergeTwoSort(sub1,sub2);
    }

};