成對交換單鏈表的結點

原題

　　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.

題目大意

　　給定一個單鏈表，成對交換兩個相鄰的結點。算法法應該作常量輔助空間，不能改結點的值，只能交換結點。

解題思路

　　使用一個頭結點root來輔助操做，對要進行交換的鏈表，每兩個的位置進行交換，而且把交換後的結點接到root的鏈表上，直到全部的結點都處理完。

代碼實現

結點類

public class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
        next = null;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

算法實現類

public class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode node = new ListNode(0); // 頭結點
        node.next = head;

        // p指向新的鏈表的尾結點
        ListNode p = node;
        ListNode tmp;

        // 每兩個進行操做
        while (p.next != null && p.next.next != null) {
            // 記錄下一次要進行處理的位置
            tmp = p.next.next;
            // 下面三句完成兩個結點交換
            p.next.next = tmp.next;
            tmp.next = p.next;
            p.next = tmp;
            // 指向返回鏈表的新的尾結點
            p = tmp.next;
        }

        head = node.next;
        node.next = null;

        return head;
    }
}

 

 

背景： 交換一個鏈表中，連續的兩個節點的位置。好比：1->2->3->4 返回2->1->4->3. 

 

 

[java] view plain copy

print?

1. /** 
2.  * Definition for singly-linked list. 
3.  * public class ListNode { 
4.  *     int val; 
5.  *     ListNode next; 
6.  *     ListNode(int x) { val = x; } 
7.  * } 
8.  */  

 

[java] view plain copy

print?

1. public static ListNode swapPairs(ListNode head){  
2.         if(head == null || head.next == null)return head;   
3.         ListNode dummy = new ListNode(0);  
4.         ListNode l = head.next;  
5.         dummy.next = head;  
6.         while(dummy.next != null && dummy.next.next != null){  
7.             ListNode first = dummy.next;  
8.             ListNode second = dummy.next.next;  
9.               
10.             first.next = second.next;  
11.             second.next = first;  
12.             dummy.next = second;  
13.               
14.             dummy = dummy.next.next;  
15.         }  
16.           
17.         return l;  
18.     }  

 

 

 

 

首先咱們須要一個多餘的節點來存儲要交換的兩個節點的第一個節點上一級， 而後對着兩個節點進行交換， 再完成兩個節點的交換以後， 咱們須要將以前存儲的第一個節點的上一級進行賦值，使其指向交換後的第一個節點，（這個過程很重要，若是缺失了這一過程，那麼咱們將丟失連接）。 而後就這個多餘節點賦值爲交換以後的第二個節點，也就是爲下一次的交換作準備！