代码随想录算法训练营第四天| 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交、142.环形链表II

24. 两两交换链表中的节点

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

解题思路：设置头节点，双指针法

时间复杂度：O(n)      空间复杂度：O(1)

C：

struct ListNode* swapPairs(struct ListNode* head) {
    typedef struct ListNode ListNode;
    ListNode *fakehead = (ListNode *)malloc(sizeof(ListNode));
    fakehead->next = head;
    ListNode* right = fakehead->next;
    ListNode* left = fakehead;
    while(left && right && right->next ){
        left->next = right->next;
        right->next = left->next->next;
        left->next->next = right;
        left = right;
        right = left->next;
    }
    return fakehead->next;
}

java：

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dumyhead = new ListNode(-1);
        dumyhead.next = head; 
        ListNode cur = dumyhead;
        ListNode temp; 
        ListNode firstnode; 
        ListNode secondnode;
        while (cur.next != null && cur.next.next != null) {
            temp = cur.next.next.next;
            firstnode = cur.next;
            secondnode = cur.next.next;
            cur.next = secondnode;   
            secondnode.next = firstnode;
            firstnode.next = temp;    
            cur = firstnode; 
        }
        return dumyhead.next;  
    }
}

19.删除链表的倒数第N个节点

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

解题思路：双指针，让其中一个指针先走n步，令最后一个指针走向链表末尾时，第一个指针指向要删除的元素前一个元素

时间复杂度：O(n)      空间复杂度：O(1)

C：

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    typedef struct ListNode ListNode;
    ListNode* FakeNode=(ListNode*)malloc(sizeof(ListNode));
    FakeNode->val=0;
    FakeNode->next=head;
    ListNode *p=FakeNode,*q=head;
    while(n--) q=q->next;
    while(q!=NULL){
        q=q->next;
        p=p->next;
    }
    p->next = p->next->next;
    return FakeNode->next;
}

java：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode FakeNode = new ListNode(0);
        FakeNode.next = head;
        ListNode p = FakeNode, q = head;
        while(n-->0) q=q.next;
        while(q!=null){
            q=q.next;
            p=p.next;
        }
        p.next = p.next.next;
        return FakeNode.next;
    }   
}

面试题 02.07. 链表相交

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

解题思路：先求链表长度，然后求差值，让长度较大的链表指针移动，然后逐步进行比较

时间复杂度：O(n+m)      空间复杂度：O(1)

C：

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    int sizeA=0,sizeB=0;
    typedef struct ListNode ListNode;
    ListNode *p=headA,*q=headB;
    while(p){
        sizeA++;
        p=p->next;
    }
    while(q){
        sizeB++;
        q=q->next;
    }
    int temp;
    p=headA,q=headB;
    if(sizeA>sizeB){
        temp=sizeA-sizeB;
        while(temp--) p=p->next;
    }
    else{
        temp=sizeB-sizeA;
        while(temp--) q=q->next;
    }
    while(p!=q){
        p=p->next;
        q=q->next;
    }
    return p;
}

java：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int sizeA=0,sizeB=0;
        ListNode p=headA,q=headB;
        while(p!=null){
            sizeA++;
            p=p.next;
        }
        while(q!=null){
            sizeB++;
            q=q.next;
        }
        int temp;
        p=headA;
        q=headB;
        if(sizeA>sizeB){
            temp=sizeA-sizeB;
            while(temp-->0) p=p.next;
        }
        else{
            temp=sizeB-sizeA;
            while(temp-->0) q=q.next;
        }
        while(p!=q){
            p=p.next;
            q=q.next;
        }
        return p;
    }
}