i += i > 0 ? i++ : i --;

int f(int x)
{
	if(x <= 2)
		return 1;
	return f(x - 2) + f(x - 4) + 1;
}

struct Node
{
	int val_;
	Node* next;
};

//轉載請標明出處，原文地址：http://blog.csdn.net/hackbuteer1/article/details/12190807
struct Node
{  
    int val_;  
    Node* next;  
};
Node* reverse_list(Node* phead)   //連結串列反轉
{
	Node *temp ,*curr , *pre , *reverse_head;
	pre = NULL;
	curr = phead;
	while(curr->next)
	{
		temp = curr->next;
		curr->next = pre;
		pre = curr;
		curr = temp;
	}
	curr->next = pre;
	reverse_head = curr;
	return reverse_head;
}

Node* Merge(Node* slow , Node* fast)
{
	if(fast == NULL)
		return slow;
	if(slow == NULL)
		return fast;
	Node *head , *result;
	result = NULL;
	int i = 0;
	while(slow && fast)
	{
		if(0 == i)
		{
			if(NULL == result)
			{
				head = result = slow;
				slow = slow->next;
			}
			else
			{
				result->next = slow;
				slow = slow->next;
				result = result->next;
			}
		}
		else
		{
			if(NULL == result)
			{
				head = result = fast;
				fast = fast->next;
			}
			else
			{
				result->next = fast;
				fast = fast->next;
				result = result->next;
			}
		}
		i ^= 1;
	}//while
	if(slow)
	{
		result->next = slow;
	}
	if(fast)
	{
		result->next = fast;
	}
	return head;
}

Node* reorder_list(Node* phead)
{
	Node *r_head , *slow , *fast;
	r_head = slow = fast = phead;
	while(fast->next != NULL && fast->next->next != NULL)
	{
		slow = slow->next;
		fast = fast->next->next;
	}
	if(slow->next == NULL)
		return r_head;
	fast = slow->next;
	slow->next = NULL;
	slow = phead;
	fast = reverse_list(fast);      //連結串列的後半部分反轉
	r_head = Merge(slow , fast);    //連結串列歸併
	return r_head;
}

轉載請標明出處，原文地址：http://blog.csdn.net/hackbuteer1/article/details/12190807
struct Node
{
	int val_;
	Node* next;
};

//將連結串列分成前後兩部分，前一個連結串列長度 >=  後一連結串列長度
Node* list_half(Node* head)
{
	Node* half = NULL;
	Node* fast = head, *slow = head;

	while(fast && fast->next && fast->next->next)
	{
		slow = slow->next;
		fast = fast->next->next;
	}
	if(slow)
	{
		half = slow->next;
		slow->next = NULL;
	}
	return half;
}

//反轉後一個連結串列
Node* list_reverse(Node* head)
{
	if(NULL == head)
		return NULL;
	Node* prev, *curr, *reverse_head, *temp;
	prev = NULL, curr = head;
	while(curr->next)
	{
		temp = curr->next;
		curr->next = prev;
		prev = curr;
		curr = temp;
	}
	curr->next = prev;
	reverse_head = curr;
	return reverse_head;
}

//合併兩個連結串列
Node* list_merge(Node* first, Node* second)
{
	Node* head = first;
	Node* temp;

	while(second)
	{
		temp = first->next;
		first->next = second;
		second = second->next;
		first->next->next = temp;
		first = temp;
	}
	return head;
}

Node* list_reorder(Node *head)
{
	Node* half = list_half(head);
	Node* half_head = list_reverse(half);
	head = list_merge(head, half_head);
	return head;
}