链表 leetcode 1721. 交换链表中的节点

最新推荐文章于 2022-05-07 21:24:15 发布

zqhwboy

最新推荐文章于 2022-05-07 21:24:15 发布

阅读量168

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/mogbox/article/details/113727421

版权

leetcode 专栏收录该内容

73 篇文章 0 订阅

订阅专栏

本文介绍了一种使用双指针的方法解决链表问题，通过遍历找到正数第k个和倒数第k个节点，并交换它们的值，适用于LeetCode上的相关题目。关键在于维护两个指针，一个跟踪正数k，一个从头开始按k步间隔前进。

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

题目内容

交换链表正数第 k 个节点和倒数第 k 个节点的值后，返回链表的头节点（链表从 1 开始索引）。
在这里插入图片描述

示例 1：

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

示例 2：

输入：head = [7,9,6,6,7,8,3,0,9,5], k = 5
输出：[7,9,6,6,8,7,3,0,9,5]

示例 3：

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

示例 4：

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

示例 5：

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

提示：

链表中节点的数目是 n
1 <= k <= n <= 105
0 <= Node.val <= 100

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/swapping-nodes-in-a-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

c语言解答

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 * 让我想起来了剑指offer的链表中的倒数第K个节点的题.遍历一遍链表就行
 * 设置两个指针,然后
 */


struct ListNode* swapNodes(struct ListNode* head, int k){
    //用来计数
    int count=0;
    //first记录正数k节,,刚开始都指头
    struct ListNode*first=head;
    //second记录倒数k节,刚开始都指头
    struct ListNode*secode=head;
    //用来遍历的指针
    struct ListNode*zou=head;
    while(zou!=NULL){
        //当还没到整数k的时候,count++
        if(count<k-1){
            
            count++;
        }
        //当找到整数k的时候,赶快用first指针记录下来
        else if(count==k-1){
            //此时这个是正数第k个字节,然后此时zou指针再往前走一个,那么第二个指针也将往前走        
            count++;
            first=zou;
        }
        //当count>k-1时候,zou指针往前走一步,然后second开始从第一个节点开始走,两者间距离一直是k-1,思路和我剑指offer一样
        else{
            count++;
            secode=secode->next;
        }
        zou=zou->next;
    }
    //交换俩指针间的值
    int temp=first->val;
    first->val=secode->val;
    secode->val=temp;
    //返回交换好后的链表
    return head;
}

java语言解答

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapNodes(ListNode head, int k) {
        //用来计数
        int count=0;
        //first记录正数k节,,刚开始都指头
        ListNode first=head;
        //second记录倒数k节,刚开始都指头
        ListNode secode=head;
        //用来遍历的指针
        ListNode zou=head;
        while(zou!=null){
            //当还没到整数k的时候,count++
            if(count<k-1){
                count++;
            }
            //当找到整数k的时候,赶快用first指针记录下来
            else if(count==k-1){
                count++;
                first=zou;
            }
            //当count>k-1时候,zou指针往前走一步,然后second开始从第一个节点开始走,两者间距离一直是k-1,思路和我剑指offer一样
            else{
                count++;
                secode=secode.next;
            }
            zou=zou.next;
        }
        //交换俩指针间的值
        int temp=first.val;
        first.val=secode.val;
        secode.val=temp;
        //返回交换好后的链表
        return head;
    }
}