成对交换单链表的结点

原题

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

 

 

 

 

首先咱们须要一个多余的节点来存储要交换的两个节点的第一个节点上一级， 而后对着两个节点进行交换， 再完成两个节点的交换以后， 咱们须要将以前存储的第一个节点的上一级进行赋值，使其指向交换后的第一个节点，（这个过程很重要，若是缺失了这一过程，那么咱们将丢失连接）。 而后就这个多余节点赋值为交换以后的第二个节点，也就是为下一次的交换作准备！