数组：奇数在前，偶数在后，要求顺序不变

不要求顺序：http://zhedahht.blog.163.com/blog/static/25411174200741295930898/

要求顺序：http://blog.sina.com.cn/s/blog_5163a02d0101b6u6.html

1.不要求顺序

一个数组，如[3,5,2,4,6,8,9,32,1]，有奇数有偶数，要求把所有奇数放在前面，偶数放在后面。思路是做两个指针或下标，第一个从左边开始遍历，遇到偶数就停下，第二个从右边开始遍历，遇到奇数就停下。交换两个元素，继续遍历，直到相遇。

gen.c：生成测试用的随机数。

#include <stdio.h>
#include <stdlib.h>

int main()
{
    FILE *fp=fopen("in.txt","wt");
    int i;
    fprintf(fp,"%d\n",10);
    for(i=0;i<10;i++)
    {
        int n=5+rand()%20;
        int j;
        fprintf(fp, "%d", n);
        for(j=0; j<n; j++)
        {
            int t=rand()%100;
            fprintf(fp," %d", t);
            
        }
        fprintf(fp,"\n");
        
    }
    
    fclose(fp);
    return 0;
}

gcc gen.c -o gen

生成格式：

3   #三个用例

3 1 2 3  #长度为3

4 1 2 3 4  #长度为4

5 1 2 3 4 5

odd.c:实现算法

#include <stdio.h>
#include <stdlib.h>

int isodd(int x);
void resort(int *p, int n);

int main()
{
    int n;
    int n0;
    scanf("%d", &n);
    n0=n;
    while(n0--)
    {
        int len;
        int *p;
        int i;
        
        scanf("%d", &len);        
        p=(int*)malloc(sizeof(int) * len);
        
        //input
        for(i=0; i<len; i++)
        {
            scanf("%d", p+i);
        }
        
        //do
        resort(p, len);
        //output
        for(i=0; i<len; i++)
            printf("%d ", p[i]);
        printf("\n");
        
        free(p);
    }
    return 0;
}

int isodd(int x)
{
    return (x&1);
}

void resort(int *p, int n)
{
    int index1=0,index2=n-1;
    while(index1<index2)
    {
        int tmp;
        while(isodd (p[index1]) && index1<n)index1++;
        while(!isodd (p[index2]) && index2>=0)index2--;
        if(index1>=index2)
            break;
        tmp=p[index1];
        p[index1]=p[index2];
        p[index2]=tmp;
    }
}

administrator@ubuntu:~/tel$ gcc odd.c -o odd
administrator@ubuntu:~/tel$ ./odd <in.txt 
49 77 15 93 35 86 92 86 
63 27 59 90 62 26 
11 72 36 26 68 
29 69 29 35 23 67 62 30 2 22 58 82 
93 37 11 19 29 73 21 42 84 56 98 24 
13 13 29 91 5 27 73 25 5 81 96 70 62 84 56 36 80 46 26 70 
99 95 51 45 3 67 87 43 64 50 34 8 76 78 88 84 14 82 54 24 32 60 
1 39 17 97 1 67 39 95 70 34 78 94 86 26 2 12 92 52 56 68 80 
41 65 89 71 19 97 29 31 17 40 44 
75 9 27 67 97 56 
administrator@ubuntu:~/tel$ 

2.要求顺序

#include <stdio.h>
#include <stdlib.h>

int isodd(int x);
void resort(int *p, int n);

void swap(int *p, int begin, int end);
void swap2(int *p, int begin, int mid, int end);

int main()
{
    int n;
    int n0;
    scanf("%d", &n);
    n0=n;
    while(n0--)
    {
        int len;
        int *p;
        int i;
        
        scanf("%d", &len);        
        p=(int*)malloc(sizeof(int) * len);
        
        //input
        for(i=0; i<len; i++)
        {
            scanf("%d", p+i);
        }
        
        //do
        resort(p, len);
        //output
        for(i=0; i<len; i++)
            printf("%d ", p[i]);
        printf("\n");
        
        free(p);
    }
    return 0;
}

int isodd(int x)
{
    return (x&1);
}

void resort(int *p, int n)
{
    int ep; //偶数块的下标
    int op; //奇数块的下标
    int end; //结束
    
    int i=0;
    
    while(i<n)
    {
        for(;i<n && isodd(p[i]); i++);  // 找到ep
        if(i>=n)
            break;
        ep=i;
        
        for(;i<n && !isodd(p[i]); i++);  // 找到op
        if(i>=n)
            break;
        op=i;
        
        for(;i<n && isodd(p[i]); i++);  // 找到end
        end=i;
        
        swap2(p, ep, op, end);
        i = ep+end-op;
        
    }
}

// begin ~ end-1
void swap(int *p, int begin, int end)
{
    int i,j;
    for(i=begin,j=end-1; i<j; i++,j--)
    {
        int t;
        t=p[i];
        p[i]=p[j];
        p[j]=t;
    }
}

// begin ~ mid-1
// mid ~ end-1
void swap2(int *p, int begin, int mid, int end)
{
    swap(p, begin, mid);
    swap(p, mid, end);
    swap(p, begin, end);
}

依然用上面的in.txt测试：

administrator@ubuntu:~/tel$ cat in.txt
10
8 86 77 15 93 35 86 92 49
6 62 27 90 59 63 26
5 26 72 36 11 68
12 29 82 30 62 23 67 35 29 2 22 58 69
12 93 56 11 42 29 73 21 19 84 37 98 24
20 70 13 26 91 80 56 73 62 70 96 81 5 25 84 27 36 5 46 29 13
22 24 95 82 45 14 67 34 64 43 50 87 8 76 78 88 84 3 51 54 99 32 60
21 68 39 12 26 86 94 39 95 70 34 78 67 1 97 2 17 92 52 56 1 80
11 41 65 89 44 19 40 29 31 17 97 71
6 75 9 27 67 56 97
administrator@ubuntu:~/tel$ gcc odd2.c -o odd2
administrator@ubuntu:~/tel$ ./odd2 <in.txt 
77 15 93 35 49 86 86 92 
27 59 63 62 90 26 
11 26 72 36 68 
29 23 67 35 29 69 82 30 62 2 22 58 
93 11 29 73 21 19 37 56 42 84 98 24 
13 91 73 81 5 25 27 5 29 13 70 26 80 56 62 70 96 84 36 46 
95 45 67 43 87 3 51 99 24 82 14 34 64 50 8 76 78 88 84 54 32 60 
39 39 95 67 1 97 17 1 68 12 26 86 94 70 34 78 2 92 52 56 80 
41 65 89 19 29 31 17 97 71 44 40 
75 9 27 67 97 56 

第一个数组8个元素：

86 77 15 93 35 86 92 49

以此类推。但是复杂度是不是O(n)呢？？？