將鏈表中的全部元素爲奇數的節點移到元素爲偶數節點的前面，並保證奇數之間順序不變，偶數之間順序不變。

2.將鏈表中的全部元素爲奇數的節點移到元素爲偶數節點的前面，並保證奇數之間順序不變，偶數之間順序不變。

示例：

交換前鏈表的順序             交換後鏈表的順序

4→5→3→1→2   ==>  5→3→1→4→2

1 ==> 1                   （鏈表僅含一個元素)

2→1 ==>1→2 

        ==>         (鏈表爲空)

 

C/C++:

鏈表節點定義爲：

struct node {

struct node *next;

int value;

};

struct node *swap(struct node *list);

Java:

鏈表節點定義爲：

class Node {

public Node next;

public int value

}

Node swap(Node list)

 

注意點和要求以下:

1. swap函數要求對節點的指針/引用進行操做（不得建立任何新的鏈表節點）

2. 不得使用任何庫函數/API，如需使用相似功能, 請自行實現

3. 不得將鏈表轉化爲其餘類型數據結構再進行交換，如數組等

package offer;
/**
 * 樹結構
 * @author cxx
 *
 */
public class ListNode {

	int val;
	ListNode next = null;

	ListNode(int val) {
		this.val = val;
	}
	
	ListNode() {
		
	}

}














package offer;

/**
 * 將鏈表中的全部元素爲奇數的節點移到元素爲偶數節點的前面，並保證奇數之間順序不變，偶數之間順序不變。
 * @author cxx
 *
 */
public class Main {

	public static void main(String[] args) {
		ListNode listNde1 = new ListNode(4);
		ListNode listNde2 = new ListNode(5);
		ListNode listNde3 = new ListNode(3);
		ListNode listNde4 = new ListNode(1);
		ListNode listNde5 = new ListNode(2);

		listNde1.next = listNde2;
		listNde2.next = listNde3;
		listNde3.next = listNde4;
		listNde4.next = listNde5;

		Main main = new Main();

		ListNode listNde = main.swap(listNde1);

		// 53142
		while (listNde != null) {

			System.out.println(listNde.val);
			listNde = listNde.next;
		}

	}

	/**
	 * 鏈表元素的交換方法  奇數的節點移到元素爲偶數節點的前面
	 * 1.查找尾元素，肯定程序的結束點
	 * 1.找到第一個奇數元素，並將該元素以前的偶數放到尾部
	 * 
	 * 
	 * 
	 * @param listNode
	 * @return
	 */
	public ListNode swap(ListNode listNode) {
		if(listNode == null){
			return null;
		}
		if(listNode.next == null){
			return listNode;
		}
		
		ListNode end = listNode;//尾元素
		ListNode prev = null;//指針移動的前一個節點
		ListNode curr = listNode;//指針移動的當前節點

		/**
		 * 循環，查找尾節點
		 */
		while (end.next != null) {
			end = end.next;
		}
		ListNode newEnd = end;// 新的尾節點，不斷的存放接收的偶數元素。

		// 將第一個奇數前的偶數放到鏈尾
		while (curr.val % 2 == 0 && curr != end) {
			newEnd.next = curr;
			curr = curr.next;
			newEnd.next.next = null;
			newEnd = newEnd.next;
		}

		// 元素是奇數
		if (curr.val % 2 != 0) {
			/* 頭結點爲第一個奇數 */
			listNode = curr;
		
			while (curr != end) {
				if ((curr.val) % 2 != 0) {//奇數
					prev = curr;
					curr = curr.next;
				} else {
					// 將pre指向後一個節點
					prev.next = curr.next;
					curr.next = null;
					newEnd.next = curr;// 將當前的偶數放到鏈尾
					// 鏈尾後移
					newEnd = curr;
					// 繼續判斷
					curr = prev.next;
				}
			}
		} else {
			//根據理論，此時curr只有多是尾節點，有while (curr.val % 2 == 0 && curr != end) 判斷
			prev = curr;
		}

		// 尾節點的特殊處理
		if ((end.val) % 2 == 0) {
			prev.next = end.next;
			end.next = null;
			newEnd.next = end;
		}

		return listNode;
	}

}