创新工场软工题2-1

题目：
1将链表中的所有元素为奇数的节点移到元素为偶数节点的前面，并保证奇数之间顺序不变，偶数之间顺序不变。

示例：
交换前链表的顺序 交换后链表的顺序
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. 不得将链表转化为其他类型数据结构再进行交换，如数组等

---

第一题完整代码：C++
//方法一：交换元素，复杂度较高，需要复制元素

// Source: 
// Author： YangQiang
// Date  ： 2016-8-22

#include<iostream>
using namespace std;

struct node {
struct node *next;
int value;
};
struct node *swap(struct node *list);

struct node *swap(struct node *list)
{
    //处理不合理输入
    if(!list) return NULL;

    //定义两个指针，一个寻奇数，一个寻偶数
    struct node *p1=list;
    struct node *p2=list;
    while( p1 )
    {
        //先寻找偶数
        while( (p1->value)%2!=0 && p1->next)
            p1=p1->next;
        //再寻找偶数后面的奇数
        if(!p1->next) return list;
        p2=p1->next;
        while( (p2->value)%2==0 && p2->next )
            p2=p2->next;
        if(!p2->next) return list;
        //交换元素
        int temp=p1->value;
        p1->value=p2->value;
        p2->value=temp;

        p1=p1->next;    
    }
    return list;
}

struct node *CreatList(int *arr,int n)
{
    if(!arr || n<1) return NULL;
    struct node *head=new struct node;
    head->value=arr[0];
    struct node *p;
    p=head;
    for(int i=1; i<n; i++)
    {
        p->next=new struct node;
        p=p->next;
        p->value=arr[i];
    }
    p->next=NULL;
    return head;
}
int main()
{
    int test1[]={4,5,3,1,2};
    struct node *list1=NULL;
    list1=CreatList(test1,5);

    struct node *result=NULL;
    result=swap(list1);
}

方法二

//方法二:链表更换,时间复杂度降低
struct node *swap(struct node *list)
{
    //处理不合理输入
    if(!list) return NULL;

    //引入一个空的头结点
    struct node *Head=new struct node;
    Head->next=list;
    //定义两个指针，一个寻奇数，一个寻偶数
    struct node *p11=Head;
    struct node *p12=Head;
    struct node *p2=NULL;
    struct node *temp=NULL;

    //先寻找偶数开始的前一个位置p11
    while( p11->next && (p11->next->value)%2!=0 )
        p11=p11->next;
    if( !p11->next ) return list;
    p12=p11->next;

    while( p11 && p12 )
    {   
        //再寻找偶数结束位置p12
        while( p12->next && (p12->next->value)%2==0 )
            p12=p12->next;
        if(!p12->next) return Head->next;

        p2=p12->next; 
        //寻找其后连续奇数的终点p2
        while( p2->next && (p2->next->value)%2!=0 )
            p2=p2->next;

        //更新链表
        temp=p12->next;
        p12->next=p2->next;
        p2->next=p11->next;
        p11->next=temp;

        p11=p2;
        p12=p12->next;
    }
    return Head->next;
}

说明：方法二未贴出完整代码，验证时，只需把方法二算法部分和方法一算法部分替换即可。