算法刷题-链表-两两交换链表中的节点

news2025/2/1 1:53:22

两两交换链表中的节点

    • 24. 两两交换链表中的节点
    • 思路
    • 其他语言版本

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

力扣题目链接

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

24.两两交换链表中的节点-题意

思路

这道题目正常模拟就可以了。

建议使用虚拟头结点，这样会方便很多，要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。

对虚拟头结点的操作，还不熟悉的话，可以看这篇链表：听说用虚拟头节点会方便很多？。

接下来就是交换相邻两个元素了，此时一定要画图，不画图，操作多个指针很容易乱，而且要操作的先后顺序

初始时，cur指向虚拟头结点，然后进行如下三步：

在这里插入图片描述

操作之后，链表如下：

在这里插入图片描述

看这个可能就更直观一些了：

在这里插入图片描述

对应的C++代码实现如下： （注释中详细和如上图中的三步做对应）

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr) {
            ListNode* tmp = cur->next; // 记录临时节点
            ListNode* tmp1 = cur->next->next->next; // 记录临时节点

            cur->next = cur->next->next;    // 步骤一
            cur->next->next = tmp;          // 步骤二
            cur->next->next->next = tmp1;   // 步骤三

            cur = cur->next->next; // cur移动两位，准备下一轮交换
        }
        return dummyHead->next;
    }
};
  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

其他语言版本

C:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
//递归版本
struct ListNode* swapPairs(struct ListNode* head){
    //递归结束条件：头节点不存在或头节点的下一个节点不存在。此时不需要交换，直接返回head
    if(!head || !head->next)
        return head;
    //创建一个节点指针类型保存头结点下一个节点
    struct ListNode *newHead = head->next;
    //更改头结点+2位节点后的值，并将头结点的next指针指向这个更改过的list
    head->next = swapPairs(newHead->next);
    //将新的头结点的next指针指向老的头节点
    newHead->next = head;
    return newHead;
}

//迭代版本
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) {
        // base case 退出提交
        if(head == null || head.next == null) return head;
        // 获取当前节点的下一个节点
        ListNode next = head.next;
        // 进行递归
        ListNode newNode = swapPairs(next.next);
        // 这里进行交换
        next.next = head;
        head.next = newNode;

        return next;
    }
} 

class Solution {
  public ListNode swapPairs(ListNode head) {
        ListNode dumyhead = new ListNode(-1); // 设置一个虚拟头结点
        dumyhead.next = head; // 将虚拟头结点指向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; // cur移动，准备下一轮交换
        }
        return dumyhead.next;  
    }
}

Python：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        res = ListNode(next=head)
        pre = res
        
        # 必须有pre的下一个和下下个才能交换，否则说明已经交换结束了
        while pre.next and pre.next.next:
            cur = pre.next
            post = pre.next.next
            
            # pre，cur，post对应最左，中间的，最右边的节点
            cur.next = post.next
            post.next = cur
            pre.next = post

            pre = pre.next.next
        return res.next

Go：

func swapPairs(head *ListNode) *ListNode {
    dummy := &ListNode{
        Next: head,
    }
    //head=list[i]
    //pre=list[i-1]
    pre := dummy 
    for head != nil && head.Next != nil {
        pre.Next = head.Next
        next := head.Next.Next
        head.Next.Next = head
        head.Next = next
        //pre=list[(i+2)-1]
        pre = head 
        //head=list[(i+2)]
        head = next
    }
    return dummy.Next
}

// 递归版本
func swapPairs(head *ListNode) *ListNode {
    if head == nil || head.Next == nil {
        return head
    }
    next := head.Next
    head.Next = swapPairs(next.Next)
    next.Next = head
    return next
}

Javascript:

var swapPairs = function (head) {
  let ret = new ListNode(0, head), temp = ret;
  while (temp.next && temp.next.next) {
    let cur = temp.next.next, pre = temp.next;
    pre.next = cur.next;
    cur.next = pre;
    temp.next = cur;
    temp = pre;
  }
  return ret.next;
};

TypeScript：

function swapPairs(head: ListNode | null): ListNode | null {
    const dummyNode: ListNode = new ListNode(0, head);
    let curNode: ListNode | null = dummyNode;
    while (curNode && curNode.next && curNode.next.next) {
        let firstNode: ListNode = curNode.next,
            secNode: ListNode = curNode.next.next,
            thirdNode: ListNode | null = curNode.next.next.next;
        curNode.next = secNode;
        secNode.next = firstNode;
        firstNode.next = thirdNode;
        curNode = firstNode;
    }
    return dummyNode.next;
};

Kotlin:

fun swapPairs(head: ListNode?): ListNode? {
    val dummyNode = ListNode(0).apply { 
        this.next = head
    }
    var cur: ListNode? = dummyNode
    while (cur?.next != null && cur.next?.next != null) {
        val temp = cur.next
        val temp2 = cur.next?.next?.next
        cur.next = cur.next?.next
        cur.next?.next = temp
        cur.next?.next?.next = temp2
        cur = cur.next?.next
    }
    return dummyNode.next
}

Swift:

func swapPairs(_ head: ListNode?) -> ListNode? {
    if head == nil || head?.next == nil {
        return head
    }
    let dummyHead: ListNode = ListNode(-1, head)
    var current: ListNode? = dummyHead
    while current?.next != nil && current?.next?.next != nil {
        let temp1 = current?.next
        let temp2 = current?.next?.next?.next
        
        current?.next = current?.next?.next
        current?.next?.next = temp1
        current?.next?.next?.next = temp2
        
        current = current?.next?.next
    }
    return dummyHead.next
}

Scala:

// 虚拟头节点
object Solution {
  def swapPairs(head: ListNode): ListNode = {
    var dummy = new ListNode(0, head) // 虚拟头节点
    var pre = dummy
    var cur = head
    // 当pre的下一个和下下个都不为空，才进行两两转换
    while (pre.next != null && pre.next.next != null) {
      var tmp: ListNode = cur.next.next // 缓存下一次要进行转换的第一个节点
      pre.next = cur.next // 步骤一
      cur.next.next = cur // 步骤二
      cur.next = tmp // 步骤三
      // 下面是准备下一轮的交换
      pre = cur
      cur = tmp
    }
    // 最终返回dummy虚拟头节点的下一个，return可以省略
    dummy.next
  }
}

PHP:

//虚拟头结点
function swapPairs($head) {
    if ($head == null || $head->next == null) {
        return $head;
    }

    $dummyNode = new ListNode(0, $head);
    $preNode = $dummyNode; //虚拟头结点
    $curNode = $head;
    $nextNode = $head->next;
    while($curNode && $nextNode) {
        $nextNextNode = $nextNode->next; //存下一个节点
        $nextNode->next = $curNode; //交换curHead 和 nextHead
        $curNode->next = $nextNextNode;
        $preNode->next = $nextNode; //上一个节点的下一个指向指向nextHead

        //更新当前的几个指针
        $preNode = $preNode->next->next;
        $curNode = $nextNextNode;
        $nextNode = $nextNextNode->next;
    }

    return $dummyNode->next;
}

//递归版本
function swapPairs($head)
{
    // 终止条件
    if ($head === null || $head->next === null) {
        return $head;
    }

    //结果要返回的头结点
    $next = $head->next;
    $head->next = $this->swapPairs($next->next); //当前头结点->next指向更新
    $next->next = $head;  //当前第二个节点的->next指向更新
    return $next;  //返回翻转后的头结点
}

Rust:

// 虚拟头节点
impl Solution {
    pub fn swap_pairs(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        let mut dummy_head = Box::new(ListNode::new(0));
        dummy_head.next = head;
        let mut cur = dummy_head.as_mut();
        while let Some(mut node) = cur.next.take() {
            if let Some(mut next) = node.next.take() {
                node.next = next.next.take();
                next.next = Some(node);
                cur.next = Some(next);
                cur = cur.next.as_mut().unwrap().next.as_mut().unwrap();
            } else {
                cur.next = Some(node);
                cur = cur.next.as_mut().unwrap();
            }
        }
        dummy_head.next
    }
}

// 递归
impl Solution {
    pub fn swap_pairs(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        if head == None || head.as_ref().unwrap().next == None {
            return head;
        }

        let mut node = head.unwrap();

        if let Some(mut next) = node.next.take() {
            node.next = Solution::swap_pairs(next.next);
            next.next = Some(node);
            Some(next)
        } else {
            Some(node)
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/631503.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

黄金回收小程序开发功能有哪些？

黄金回收小程序开发功能有哪些？

一、用户端&#xff1a; 1、实时查询&#xff1a;通过对接三方接口实现实时金价动态查看&#xff1b; 2、多种类珠宝实时回收&#xff1a;小程序支持多品类珠宝的实时回收包含黄金饰品、金条、铂金、K金、白银等&#xff0c;同步实现价格实时更新&#xff1b; …
阅读更多...
计算机内核态、用户态和零拷贝技术详解

计算机内核态、用户态和零拷贝技术详解

存储介质的性能 话不多说&#xff0c;先看一张图&#xff0c;下图左边是磁盘到内存的不同介质&#xff0c;右边形象地描述了每种介质的读写速率。一句话总结就是越靠近cpu&#xff0c;读写性能越快。了解了不同硬件介质的读写速率后&#xff0c;你会发现零拷贝技术是多么的香&a…
阅读更多...
JDBC 事务和批处理 详解（通俗易懂）

JDBC 事务和批处理 详解（通俗易懂）

目录 一、前言 二、事务 1.事务介绍 : 2.事务处理 : Δ准备工作 Δ不使用事务的情况 Δ使用事务的情况 三、批处理 1.介绍 : 2.常用方法 : 3.应用 : 4.源码分析(JDK17.0版本&#xff09; : 四、总结 一、前言 第四节内容&#xff0c;up主要和大家…
阅读更多...
阿里背调，征信不好也会被pass

阿里背调，征信不好也会被pass

大厂背调&#xff0c;我一直认为是唬人的&#xff0c;走下流程而已&#xff0c;没想到这么严格。这次提供的背调信息&#xff0c;我填写了上家公司三个联系人&#xff0c;HR、领导、同事&#xff1b;上上家公司三个联系人&#xff0c;HR、领导、同事。根据朋友的反馈来看&#…
阅读更多...
python 第五章 列表list [ ]

python 第五章 列表list [ ]

系列文章目录 第一章 初识python 第二章 变量 第三章 基础语句 第四章 字符串str 文章目录 5.1列表的应用场景5.2列表的格式5.3列表的常用操作查找下标函数查找函数index()count()len() 判断是否存在innot in 增加append()extend()insert() 删除delpop()remove()clear() 清空列…
阅读更多...
Java并发回顾

Java并发回顾

树叶柔和爽朗的呼吸 诗人一路吹着口哨回家 一路踢着石子妙想连篇 感到夕阳和晚风自古多情 自己现在和将来 都是个幸福的人 系列文章目录 Java常见知识点汇总Java集合回顾Java并发回顾… 文章目录 系列文章目录什么是线程和进程?线程与进程的关系,区别及优缺点&#xff1f;图解…
阅读更多...
Tcp的三次握手及netty和实际开发如何设置全连接队列参数

Tcp的三次握手及netty和实际开发如何设置全连接队列参数

上图 第一次握手&#xff0c;client 发送 SYN 到 server&#xff0c;状态修改为 SYN_SEND&#xff0c;server 收到&#xff0c;状态改变为 SYN_REVD&#xff0c;并将该请求放入 sync queue 队列 第二次握手&#xff0c;server 回复 SYN ACK 给 client&#xff0c;client 收到…
阅读更多...
【Prometheus】mysqld_exporter采集+Grafana出图+AlertManager预警

【Prometheus】mysqld_exporter采集+Grafana出图+AlertManager预警

前提环境&#xff1a;已经安装和配置好prometheus server 所有组件对应的版本&#xff1a; prometheus-2.44.0 mysqld_exporter-0.14.0 grafana-enterprise-9.1.2-1.x86_64.rpm alertmanager-0.25.0 prometheus-webhook-dingtalk-2.1.0 简介 mysql_exporter是用来收集MysQL或…
阅读更多...
spring 事务超时

spring 事务超时

Transactional(timeout 10) 表示设置事务的超时时间为10秒 表示超过10秒如果该事务中所有的DML语句还没有执行完毕的话&#xff0c;最终结果会选择回滚 默认值-1&#xff0c;表示没有时间限制。 如果最后一条DML语句后面还有很多业务逻辑&#xff0c;这些业务代码执行的时间不…
阅读更多...
setState详解

setState详解

this. setState( [partialState], [callback]) 1.[partialState] :支持部分状态更改 this, setState({ x:100 //不论总共有多少状态&#xff0c;我们只修改了x&#xff0c;其余的状态不动 });callback :在状态更改/视图更新完毕后触发执行&#xff0c;也可以说只要执行了setS…
阅读更多...
lightGBM的介绍

lightGBM的介绍

一、lightGBM的介绍 1.lightGBM的演进过程 2.AdaBoost算法 AdaBoost&#xff08;Adaptive Boosting&#xff09;是一种集成学习算法&#xff0c;通过组合多个弱分类器来构建一个强分类器。它是由Freund和Schapire在1996年提出的&#xff0c;是集成学习中最早被广泛应用的算法…
阅读更多...
JDK8-1-Lambda表达式（5）-复合 Lambda 表达式

JDK8-1-Lambda表达式（5）-复合 Lambda 表达式

JDK8-1-Lambda表达式&#xff08;5&#xff09;-复合 Lambda 表达式 JDK8 在 java.util.function 包下定义了一些默认的 函数式接口 &#xff0c;如 Predicate、Consumer、Function、 Comparator &#xff08;在 java.util.包下&#xff09; &#xff0c;这些接口提供了一些复…
阅读更多...
运营-21.常见的内容生产方式

运营-21.常见的内容生产方式

常见的 内容生产方式 PGC&#xff08;Professionally-generated Content&#xff09;专业生产内容 传统的门户网站内容生产方式&#xff0c;内容多由官方工作人员身或者专业的内容创造者&#xff08;比如新闻记者等&#xff09;创造。 UGC&#xff08;User Generated Content&a…
阅读更多...
【好书精读】网络是怎样连接的 浏览器生成消息

【好书精读】网络是怎样连接的 浏览器生成消息

如果只是讲解 TCP/IP 、 以太网这些单独的技 术 &#xff0c; 读者就无法理解网络这个系统的全貌 &#xff1b; 如果无法理解网络的全貌 &#xff0c; 也 就无法理解每一种网络技术背后的本质意义 &#xff1b; 而如果无法理解其本质意义 &#xff0c; 就只能停留在死记硬背的…
阅读更多...
MMDetection代码实战

MMDetection代码实战

title: mmdet代码实战 date: 2023-06-10 17:01:45 tags: [detection,pytorch] MMDetection代码实战 这一届主要讲解了&#xff0c;如何构建cfg&#xff0c;如何在目标检测上设置自己的配置文件。主要的思维导图如下 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下…
阅读更多...
第3章“程序的机器级表示”：对齐（alignment）

第3章“程序的机器级表示”：对齐（alignment）

许多计算机系统对基本数据类型的可允许地址做出了一些限制&#xff0c;要求某种类型的对象的地址必须是某个值 k k k &#xff08;通常是2、4 或 8&#xff09;的倍数。这种 对齐限制 简化了处理器和存储器系统之间接口的硬件设计。例如&#xff0c;假设一个处理器总是从存储器…
阅读更多...
pikachu靶场-File Inclusion

pikachu靶场-File Inclusion

文件包含漏洞概述 在web后台开发中&#xff0c;程序员往往为了提高效率以及让代码看起来更加简介&#xff0c;会使用”包含“函数功能。比如把一系列功能函数都写进function.php中&#xff0c;之后当某个文件需要调用的时候就直接在文件头上写上一句<?php include functio…
阅读更多...
多叉树的构建，条件查询，修改删除节点

多叉树的构建，条件查询，修改删除节点

多叉树的构建查询&#xff0c;新增&#xff0c;修改&#xff0c;删除 文章目录 多叉树的构建查询&#xff0c;新增&#xff0c;修改&#xff0c;删除一&#xff0c;数据库表设计二、新增相对应数据库表的实体类三、新建多叉树树工具类四、多叉树树的条件查询五、多叉树的节点新…
阅读更多...
关于【Git】push失败与使用小乌龟（TortoiseGit）时的一些报错解决方案

关于【Git】push失败与使用小乌龟（TortoiseGit）时的一些报错解决方案

1.报错:No supported authentication methods available (server sent: publickey) 原因.小乌龟没有设置git路径&#xff0c;解决如下 将红框标注的地址改为自己的git安装地址即可。 2.使用git推送到远程仓库的时候报错Failed to connect to 127.0.0.1 port 7890: 拒绝连接 …
阅读更多...
C# 让程序代码在固定的线程里运行

C# 让程序代码在固定的线程里运行

一、概述 在平时我们的开发中&#xff0c;多线程也是经常用到的&#xff0c;尤其是我们做上位机行业的&#xff0c;平时更是必不可少&#xff0c;在以前我做 Unity3d 开发时&#xff0c;其实并不用关心线程的问题&#xff0c;在 Unity 的开发中&#xff0c;所有代码基本都是单…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023