每日练习——leetcode19和24

2401_83138160

已于 2024-04-10 19:28:27 修改

阅读量586

点赞数 22

文章标签：算法数据结构 leetcode

于 2024-04-08 20:16:05 首次发布

本文链接：https://blog.csdn.net/2401_83138160/article/details/137521381

版权

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

题目描述

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

解题思路

使用双指针。

设置两个指针，一个快指针和一个慢指针，开始时慢指针指向哑节点，快指针指向哑节点的下一个节点（即头结点）。先让快指针向前移动n步，这样快指针和慢指针之间就相隔了n个节点。然后，同时移动快指针和慢指针，每次都向前一步，直到快指针到达链表的末尾。此时，慢指针正好指向要删除的节点的前一个节点。

代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    struct ListNode* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = head;
    struct ListNode* fast = head;
    struct ListNode* slow = dummy;
    for (int i = 0; i < n; i++) {
        fast = fast->next;
    }
    while (fast != NULL) {
        fast = fast->next;
        slow = slow->next;
    }
    slow->next = slow->next->next;
    return dummy->next;
}

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

题目描述

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

提示：

链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100

解题思路

1.创建哑节点：

创建一个哑节点，并将其next指针指向链表的头节点。

2.初始化指针：

current指针用于遍历链表，初始时指向哑节点。left和right指针用于指向当前要交换的节点对。

3.遍历链表：

使用while循环遍历链表，条件是current的下一个节点和下一个节点的下一个节点都存在，即至少还有一对节点可以交换。

4.交换节点对：

在每次循环中，left指向current的下一个节点，right指向left的下一个节点。

更新指针关系：

current->next指向right，即跳过left节点。

left->next指向right->next，即跳过right节点。

right->next指向left，完成交换。

5.移动current指针：

将current指针移动到已交换节点对中的第一个节点（原left节点），为下一轮交换做准备。

6.返回结果：

交换完成后，返回哑节点的下一个节点，即交换后的链表头节点。。

代码实现


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
	struct ListNode* swapPairs(struct ListNode* head) {  
    // 创建一个哑节点，并指向链表的头节点  
    struct ListNode* dummy = malloc(sizeof(struct ListNode));  
    dummy->val = 0;  
    dummy->next = head;  
    // current指针用于遍历链表，初始指向哑节点  
    struct ListNode* current = dummy;  
    // 当current的下一个节点和下一个节点的下一个节点都存在时，继续循环  
    while(current->next && current->next->next){  
        // left指向当前要交换的节点对中的第一个节点  
        struct ListNode* left = current->next;  
        // right指向当前要交换的节点对中的第二个节点  
        struct ListNode* right = current->next->next;  
        // 交换节点对  
        // current的next指向right，即跳过left节点  
        current->next = right;  
        // left的next指向right的下一个节点  
        left->next = right->next;  
        // right的next指向left，完成交换  
        right->next = left;  
        // 移动current指针到已交换节点对中的第一个节点，为下一轮交换做准备  
        current = left;  
    }  
    // 返回交换后的链表的头节点（哑节点的下一个节点）  
    return dummy->next;  
}