day04打卡

最新推荐文章于 2024-06-17 19:40:50 发布

沉着冷静2024

最新推荐文章于 2024-06-17 19:40:50 发布

阅读量526

点赞数 8

分类专栏：代码文章标签： leetcode 算法

本文链接：https://blog.csdn.net/dev1cce/article/details/135577656

版权

代码专栏收录该内容

41 篇文章 0 订阅

订阅专栏

本文介绍了三种链表操作的解决方案：1)判断两个链表是否相交，使用O(N)时间和O(1)空间；2)删除链表的倒数第N个节点，同样时间复杂度为O(N)，空间复杂度O(1)；3)两两交换链表节点，通过迭代或递归实现，时间复杂度O(N)。

摘要由CSDN通过智能技术生成

day04打卡

面试题 02.07. 链表相交

时间复杂度：O(N)，空间复杂度：O(1)

第一想法：求出两个链表长度，走差距步，再遍历找有没有相交

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* a = headA, * b = headB;
        //求出 两个链表的长度
        int lenA = 0, lenB = 0;
        while(a != NULL) 
        {
            lenA++;
            a = a->next;
        }
        while(b != NULL)
        {
            lenB++;
            b = b->next;
        }
        a = headA, b = headB;
        //让两个链表长度统一
        //让a做长的链表
        if(lenA < lenB)
        {
            swap(lenA, lenB);
            swap(a, b);
        }
        int n = lenA - lenB;
        //a走差距步
        while(n--)
        {
            a = a->next;
        }
        //遍历链表，看看有没有相交
        while(a != NULL)
        {
            if(a == b) return a;
            else 
            {
                a = a->next;
                b = b->next;
            }
        }
        return NULL;
    }
};

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

时间复杂度：O(N)，空间复杂度：O(1)

第一想法：双指针，快指针先走n步，再同时走，走到快指针到空时，修改慢指针的连接即可

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* newHead = new ListNode;
        newHead->next = head;
        ListNode* fast = head, * slow = newHead;
        //快指针先走n步
        while(n--) fast = fast->next;
        //同时走，快指针到空时，slow就是倒数第n个节点
        while(fast != nullptr)
        {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        ListNode* ret = newHead->next;
        delete newHead;
        return ret;
    }
};

24. 两两交换链表中的节点 - 力扣（LeetCode）

时间复杂度：O(N)，空间复杂度：O(1)

第一想法：迭代，设置一个虚拟头结点，设定三个指针，prev，cur，next。修改链表关系即可

困难：没有把握好三个指针的连接关系

看了题解：画图实现了三个指针的链接关系和递归解法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        //迭代
        // if(head == nullptr || head->next == nullptr) return head;
        // ListNode* newHead = new ListNode;
        // newHead->next = head;
        // ListNode* prev = newHead, * cur = head, * next = head->next;
        // while(cur != nullptr && next != nullptr)
        // {
        //     prev->next = next;
        //     cur->next = next->next;
        //     next->next = cur;
        //     //交换节点
        //     prev = cur;
        //     cur = cur->next;
        //     if(cur) next = cur->next;
        // }
        // return newHead->next;
        //递归
        //递归出口
        if(head == nullptr || head->next == nullptr) return head;
        //子问题
        ListNode* newHead = swapPairs(head->next->next);
        ListNode* ret = head->next;
        head->next = newHead;
        ret->next = head;
        return ret;
    }
};