【Leetcode】Swap Nodes in Pairs

最新推荐文章于 2025-09-11 23:50:21 发布

yyz20002008

最新推荐文章于 2025-09-11 23:50:21 发布

阅读量179

点赞数

文章标签： java leetcode ListNode LinkedList

本文介绍了使用常空间复杂度的链表相邻节点交换算法，包括递归与迭代两种实现方式，通过示例代码详细解释了操作过程。

Given a linked list, swap every two adjacent nodes and return its head.

For example,
Given 1->2->3->4, you should return the list as 2->1->4->3.

Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.

Java:

1.http://blog.youkuaiyun.com/linhuanmars/article/details/19948569

public ListNode swapPairs(ListNode head) {
    if(head == null)
        return null;
    ListNode helper = new ListNode(0);
    helper.next = head;
    ListNode pre = helper;
    ListNode cur = head;
    while(cur!=null && cur.next!=null)
    {
        ListNode next = cur.next.next;
        cur.next.next = cur;
        pre.next = cur.next;
        if(next!=null && next.next!=null)//其实不要这个if也能过 但可能这样减少了一步吧
            cur.next = next.next;
        else
            cur.next = next;
        pre = cur;
        cur = next;
    }
    return helper.next;
}

2.http://blog.youkuaiyun.com/fightforyourdream/article/details/12901841

/** 
 * Definition for singly-linked list. 
 * public class ListNode { 
 *     int val; 
 *     ListNode next; 
 *     ListNode(int x) { 
 *         val = x; 
 *         next = null; 
 *     } 
 * } 
 */  
public class Solution {  
    public ListNode swapPairs(ListNode head) {  
        if(head==null || head.next==null){  
            return head;  
        }  
        ListNode dm = new ListNode(0);  
        dm.next = head;  
        ListNode p=dm, q=head, r;  
        while(q!=null && q.next!=null){  
            p.next = q.next;  
            r = q.next.next;  
            p.next.next = q;  
            q.next = r;  
            p = q;  
            q = r;  
        }  
        return dm.next;  
    }  
}

递归：

public class Solution {  
    public ListNode swapPairs(ListNode head) {  
        return rec(head);  
    }  
      
    public ListNode rec(ListNode head) {  
        if(head == null || head.next == null) {  
            return head;  
        }  
        ListNode p = head;  
        ListNode q = p.next.next;  
        p.next.next = p;  
        ListNode newHead = p.next;  
        p.next = rec(q);  
        return newHead;  
    }  
}

3.http://blog.youkuaiyun.com/u010500263/article/details/18029353

/** 
 * Definition for singly-linked list. 
 * public class ListNode { 
 *     int val; 
 *     ListNode next; 
 *     ListNode(int x) { 
 *         val = x; 
 *         next = null; 
 *     } 
 * } 
 */  
public class Solution {  
    public ListNode swapPairs(ListNode head) {  
        if(head == null || head.next == null) return head;  
        //creat fake header node  
        ListNode fake = new ListNode(0);  
        fake.next = head;  
          
        ListNode pre = fake;  
        ListNode cur = head;  
          
        while(cur != null && cur.next != null){  
            pre.next = cur.next;  
            cur.next = cur.next.next;  
            pre.next.next = cur;  
  
            pre = cur;  
            cur = pre.next;  
        }  
          
        return fake.next;  
    }  
}

递归：

public class Solution {  
    public ListNode swapPairs(ListNode head) {  
        if (head == null || head.next == null) return head;  
          
        return swapSinglePair(head);  
    }  
      
    public ListNode swapSinglePair(ListNode node){  
        if (node == null || node.next == null) return node;  
        // stor next node for recursive call  
        ListNode next = node.next.next;  
          
        // swap node pair  
        ListNode temp = node;  
        node = node.next;  
        node.next = temp;  
          
        // swap next pair of nodes  
        node.next.next = swapSinglePair(next);  
          
        // return header  
        return node;  
    }  
}