链表逆序

一、

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* newhead=NULL;
    struct ListNode* next;
    while(head)
    {
    next=head->next;
    head->next=newhead;
    newhead=head;
    head=next;
    }
    return newhead;
}

二、头插法

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode temp_head;
    temp_head.next=NULL;
    struct ListNode* next=NULL;
    while(head){
    next=head->next;
    head->next=temp_head.next;
    temp_head.next=head;
    head=next;}
    return temp_head.next;
}

链表合并

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode a2;
    struct ListNode *a1=&a2;
    while(l1&&l2)
    {
        if(l1->val>l2->val)
        {
            a1->next=l2;
            l2=l2->next;
        }
        else
        {
            a1->next=l1;
            l1=l1->next;
        }
        a1=a1->next;
    }
    if(l1)
        a1->next=l1;
    else
        a1->next=l2;
    return a2.next;
}

求两个链表交点
方法一

class Solution {
public:
   struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    std::set<ListNode*> node_set; //C++
    while(headA)
    {
        node_set.insert(headA);
        headA=headA->next;
    }
    while(headB)
    {
        if(node_set.find(headB)!=node_set.end())  //判断最后等于end否，headB在node_set中是否存在。存在，则！=
        {
            return headB;
        }
        headB=headB->next;
    }
    return NULL;
}
};

方法二

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *forword(struct ListNode *a,int b);
int len(struct ListNode *a);
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    int a,b;
    a=len(headA);
    b=len(headB);
    if(a>b)
    {
        headA=forword(headA,a-b);
    }
    else
    {
        headB=forword(headB,b-a);
    }
    while(headA&&headB)
    {
        if(headA==headB)
        {
            return headA;
        }
        headA=headA->next;
        headB=headB->next;
        
    }
    return NULL;
}
int len(struct ListNode *a)
{
    int i=0;
    while(a)
    {
        a=a->next;
        i=i+1;
    }
    return i;
}
struct ListNode *forword(struct ListNode *a,int b)
{
    while(a&&b)
    {
        a=a->next;
        b--;
    }
    return a;
}

链表是否存在环
方法一

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
    std::set<ListNode*>node_set;
    while(head)
    {
        if(node_set.find(head)!=node_set.end())
        {
            return head;
        }
        node_set.insert(head);
        head=head->next;
    }
    return NULL;
    }
};

方法二

bool hasCycle(struct ListNode *head) {
    struct ListNode *fast=head;
    struct ListNode *slow=head;
    struct ListNode *meet=NULL;
    while(fast)
    {
        fast=fast->next;
        slow=slow->next;
        if(!fast)
        {
            return NULL;
        }
        fast=fast->next;
        if(fast==slow)
        {
            meet=fast;
            break;
        }
    }
    if(meet==NULL)
        return NULL;
    else
    {
        while(head&&meet)
        {
            if(head==meet)
                return head;
            head=head->next;
            meet=meet->next;
        }
    }
    return NULL;
}

链表划分

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode less_head(0);
    	ListNode more_head(0);
    	ListNode *less_ptr = &less_head;
    	ListNode *more_ptr = &more_head;
        while(head){
        	if (head->val < x){
        		less_ptr->next = head;
        		less_ptr = head;
			}
			else {
				more_ptr->next = head;
				more_ptr = head;
			}
        	head = head->next;
        }
        less_ptr->next = more_head.next;
        more_ptr->next = NULL;
        return less_head.next;
    }
    
};