【Leetcode】 Swap Nodes in Pairs

最新推荐文章于 2024-10-10 01:02:39 发布

转载最新推荐文章于 2024-10-10 01:02:39 发布 · 112 阅读

本文介绍如何使用Java解决链表中相邻节点交换的问题，包括非递归和递归两种方法，详细解释每种方法的实现逻辑，并提供代码示例。

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://gongxuns.blogspot.com/2012/12/leetcodeswap-nodes-in-pairs.html

/**
 * 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) {
        // Start typing your Java solution below
        // DO NOT write main() function
        ListNode helper = new ListNode(0);
        helper.next = head;
        ListNode n1 = helper, n2=head;
        
        while(n2!=null && n2.next!=null){
            ListNode temp = n2.next.next;
            n2.next.next=n1.next;
            n1.next=n2.next;
            n2.next=temp;
            n1=n2;
            n2=n1.next;
        }
        
        return helper.next;
    }
}

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

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;  
    }  
}

递归

/** 
 * 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;  
          
        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;  
    }