线性表的应用1（顺序表的遍历和查找）

已知顺序表L中的数据类型为整型。设计算法将其调整为左右两部分，左边的元素（即排在前面的）均为奇数，右边所有元素（即排在后面的）均为偶数，并要求算法的时间复杂度为O（n）,空间复杂度为O(1)。

由于顺序表的空间已经确定，所以可以遍历查找每个元素，判断其是否为奇数，并将其放入表的头部或者尾部

代码实现：

#include <iostream>
#include <cstdio>
#include <cstdlib>

#define OVERFLOW -2
#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
#define LISTINCREMENT 10  //线性表存储空间的分配增量

using namespace std;

typedef int ElemType;

typedef struct
{
ElemType *elem; //存储空间基址
int length; //当前长度
int listsize; //当前分配的存储容量（以sizeof（ElemType）为单位）
} SeqList;

int InitList(SeqList &L)
{
L.elem=(ElemType *)calloc(LIST_INIT_SIZE,sizeof(ElemType));
if(!L.elem) exit(OVERFLOW);
L.length=0;
L.listsize=LIST_INIT_SIZE;
return 1;
}

int ListInsert(SeqList &L, int i,ElemType e)
{
ElemType *newbase,*p,*q;
if(i<1||i>L.length+1) return 0;
if(L.length>=L.listsize)
{

newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase) exit(OVERFLOW);
L.elem=newbase;
L.listsize+=LISTINCREMENT;
}
q=&(L.elem[i-1]);
for(p=&(L.elem[L.length-1]); p>=q; --q)
{
*(p+1)=*p;
}
*q=e;
++L.length;
return 1;
}

int ListDelet(SeqList &L,int i,ElemType &e)
{
ElemType *p,*q;
if((i<1)||(i>L.length))
return 0;
p=&(L.elem[i-1]);
e=*p;
q=L.elem+L.length-1;
for(++p; p<=q; ++p)
*(p-1)=*p;
--L.length;
return 1;
}

void Output(SeqList &L)
{
for(int i=0; i<L.length; i++)
{
printf("%d ",L.elem[i]);
}
printf("\n");
}
void Output1(SeqList &L)
{
for(int i=0; i<L.listsize; i++)
{
printf("%d ",L.elem[i]);
}
printf("\n");
}

int main()
{
SeqList L;
int flag,e,n;
flag=InitList(L);
if(flag==1)
{
scanf("%d",&n);
for(int i=1; i<=n; i++)
{
scanf("%d",&e);
flag=ListInsert(L,i,e);
if(flag==0)
{
cout<<"Insert Fail1"<<endl;
break;
}
}
Output(L);
//cout<<L.length<<endl;
int k1=0;
int k2=LIST_INIT_SIZE-1;
for(int i=0; i<L.length; i++)
{
int ee=L.elem[i];
L.elem[i]=0;
if(ee%2!=0)
{
L.elem[k1++]=ee;
continue;
}
else
{
L.elem[k2--]=ee;
continue;
}
}
Output1(L);
}
else
{
cout<<"Can not do it!"<<endl;
}
return 0;
}