1:第二章 实验题2:2.1 顺序表——调整数据元素
总时间限制: 10000ms 内存限制: 10000kB
描述
假设一个顺序表L中所有元素为整数,设计一个算法调整该顺序表,使其中所有小于零的元素移动到所有大于等于零的元素的前面。
输入
无
输出
2 -1 0 2 -2 3 -3
-3 -1 -2 2 0 3 2
样例输入
无
样例输出
2 -1 0 2 -2 3 -3
-3 -1 -2 2 0 3 2
ac代码:
#include <stdio.h>
#include <iostream>
using namespace std;
#define MaxSize 100
typedef int ElemType; //设置顺序表元素为int类型
typedef struct
{ ElemType data[MaxSize]; //存放顺序表的元素
int length; //顺序表的实际长度
} SqList; //顺序表类型声明
void InitList(SqList &L) //初始化顺序表L
{
L.length=0;
}
void DestroyList(SqList L) //销毁顺序表L
{
}
int GetLength(SqList L) //求长度
{
return L.length;
}
int GetElem(SqList L,int i,ElemType &e) //求第i个元素
{ if (i<1 || i>L.length) //无效的i值
return 0;
else
{ e=L.data[i-1];
return 1;
}
}
int Locate(SqList L,ElemType x) //查找第一个x元素的位置
{ int i=0;
while (i<L.length && L.data[i]!=x)
i++; //查找第1个值为x的元素
if (i>=L.length) return(0); //未找到返回0
else return(i+1); //找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i) //插入x作为第i个元素
{ int j;
if (i<1 || i>L.length+1) //无效的参数i
return 0;
for (j=L.length;j>i;j--) //将位置为i的元素及之后的元素后移
L.data[j]=L.data[j-1];
L.data[i-1]=x; //在位置i处放入x
L.length++; //顺序表长度增1
return 1;
}
int DelElem(SqList &L,int i) //删除第i个元素
{ int j;
if (i<1 || i>L.length) //无效的参数i
return 0;
for (j=i;j<L.length;j++) //将位置为i的元素之后的元素前移
L.data[j-1]=L.data[j];
L.length--; //顺序表长度减1
return 1;
}
void DispList(SqList L) //输出顺序表
{ int i;
for (i=0;i<L.length;i++)
printf("%d ",L.data[i]);
printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n) //整体创建顺序表L
{
int i,k=0; //k累计顺序表L中的元素个数
for (i=0;i<n;i++)
{
L.data[k]=a[i]; //向L中添加一个元素
k++; //L中元素个数增1
}
L.length=k; //设置L的长度
}
void Move(SqList &L)
{
int j=L.length-1;
for(int i=0;i<L.length/2;i++)
{
if(L.data[i]>=0&&L.data[j]<=0)
{
int k=L.data[i];
L.data[i]=L.data[j];
L.data[j]=k;
}
j--;
}
}
int main()
{
SqList L;
int a[]={2,-1,0,2,-2,3,-3};
int n=sizeof(a)/sizeof(a[0]);
CreateList(L,a,n);
DispList(L);
Move(L);// 移动求解算法
DispList(L);
DestroyList(L);
return 0;
}
2:第二章 实验题2:2.2 顺序表——删除最大值
总时间限制: 10000ms 内存限制: 10000kB
描述
有一个整数序列,采用顺序表L存储。设计尽可能高效的算法删除L中最大值的元素(假设这样的元素有多个)。
输入
无
输出
2 1 5 4 2 5 1 5 4
2 1 4 2 1 4
样例输入
无
样例输出
2 1 5 4 2 5 1 5 4
2 1 4 2 1 4
ac代码:
#include <stdio.h>
#include<iostream>
using namespace std;
#define MaxSize 100
typedef int ElemType; //设置顺序表元素为int类型
typedef struct
{ ElemType data[MaxSize]; //存放顺序表的元素
int length; //顺序表的实际长度
} SqList; //顺序表类型声明
void InitList(SqList &L) //初始化顺序表L
{
L.length=0;
}
void DestroyList(SqList L) //销毁顺序表L
{
}
int GetLength(SqList L) //求长度
{
return L.length;
}
int GetElem(SqList L,int i,ElemType &e) //求第i个元素
{ if (i<1 || i>L.length) //无效的i值
return 0;
else
{ e=L.data[i-1];
return 1;
}
}
int Locate(SqList L,ElemType x) //查找第一个x元素的位置
{ int i=0;
while (i<L.length && L.data[i]!=x)
i++; //查找第1个值为x的元素
if (i>=L.length) return(0); //未找到返回0
else return(i+1); //找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i) //插入x作为第i个元素
{ int j;
if (i<1 || i>L.length+1) //无效的参数i
return 0;
for (j=L.length;j>i;j--) //将位置为i的元素及之后的元素后移
L.data[j]=L.data[j-1];
L.data[i-1]=x; //在位置i处放入x
L.length++; //顺序表长度增1
return 1;
}
int DelElem(SqList &L,int i) //删除第i个元素
{ int j;
if (i<1 || i>L.length) //无效的参数i
return 0;
for (j=i;j<L.length;j++) //将位置为i的元素之后的元素前移
L.data[j-1]=L.data[j];
L.length--; //顺序表长度减1
return 1;
}
void DispList(SqList L) //输出顺序表
{ int i;
for (i=0;i<L.length;i++)
printf("%d ",L.data[i]);
printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n) //整体创建顺序表L
{
int i,k=0; //k累计顺序表L中的元素个数
for (i=0;i<n;i++)
{
L.data[k]=a[i]; //向L中添加一个元素
k++; //L中元素个数增1
}
L.length=k; //设置L的长度
}
void Deletex(SqList &L,ElemType x)
{ int i,k=0;
for (i=0;i<L.length;i++)
if (L.data[i]!=x) //将不为x的元素插入到L中
{ L.data[k]=L.data[i];
k++;
}
L.length=k; //重置L的长度
}
int Delmaxe(SqList &L)
{int max=L.data[0];
for(int i=0;i<L.length-1;i++)
{
if(L.data[i]<L.data[i+1])
{
max=L.data[i+1];
}
}
//printf("%d\n",max);
for(int i=0;i<L.length;i++)
{
if(L.data[i]==max)
{
//printf("%d\n",L.data[i]);
DelElem(L,i+1);
}
}
}
int main()
{
SqList L;
int a[]={2,1,5,4,2,5,1,5,4};
int n=sizeof(a)/sizeof(a[0]);
CreateList(L,a,n);
DispList(L);
Delmaxe(L);
DispList(L);
DestroyList(L);
return 0;
}
3:第二章 实验题2:2.5 有序顺序表——删除重复元素
总时间限制: 10000ms 内存限制: 10000kB
描述
设计一个算法从有序顺序表中删除重复的元素,多个值相同的元素仅保留第一个。
输入
无
输出
1 2 2 2 5 5 5
1 2 5
样例输入
无
样例输出
1 2 2 2 5 5 5
1 2 5
ac代码:
#include <stdio.h>
#include<iostream>
using namespace std;
#define MaxSize 100
typedef int ElemType; //设置顺序表元素为int类型
typedef struct
{ ElemType data[MaxSize]; //存放顺序表的元素
int length; //顺序表的实际长度
} SqList; //顺序表类型声明
void InitList(SqList &L) //初始化顺序表L
{
L.length=0;
}
void DestroyList(SqList L) //销毁顺序表L
{
}
int GetLength(SqList L) //求长度
{
return L.length;
}
int GetElem(SqList L,int i,ElemType &e) //求第i个元素
{ if (i<1 || i>L.length) //无效的i值
return 0;
else
{ e=L.data[i-1];
return 1;
}
}
int Locate(SqList L,ElemType x) //查找第一个x元素的位置
{ int i=0;
while (i<L.length && L.data[i]!=x)
i++; //查找第1个值为x的元素
if (i>=L.length) return(0); //未找到返回0
else return(i+1); //找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i) //插入x作为第i个元素
{ int j;
if (i<1 || i>L.length+1) //无效的参数i
return 0;
for (j=L.length;j>i;j--) //将位置为i的元素及之后的元素后移
L.data[j]=L.data[j-1];
L.data[i-1]=x; //在位置i处放入x
L.length++; //顺序表长度增1
return 1;
}
int DelElem(SqList &L,int i) //删除第i个元素
{ int j;
if (i<1 || i>L.length) //无效的参数i
return 0;
for (j=i;j<L.length;j++) //将位置为i的元素之后的元素前移
L.data[j-1]=L.data[j];
L.length--; //顺序表长度减1
return 1;
}
void DispList(SqList L) //输出顺序表
{ int i;
for (i=0;i<L.length;i++)
printf("%d ",L.data[i]);
printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n) //整体创建顺序表L
{
int i,k=0; //k累计顺序表L中的元素个数
for (i=0;i<n;i++)
{
L.data[k]=a[i]; //向L中添加一个元素
k++; //L中元素个数增1
}
L.length=k; //设置L的长度
}
void DelSame(SqList &L)
{
for(int i=0;i<L.length;i++)
{
int k=L.data[i];
for(int j=i+1;j<L.length;j++)
{
if(L.data[j]==L.data[i])
{
DelElem(L,j);
j--;
}
}
}
}
int main()
{
SqList L;
int a[]={1,2,2,2,5,5,5};
int n=sizeof(a)/sizeof(a[0]);
CreateList(L,a,n);
DispList(L);
DelSame(L); //删除重复元素
DispList(L);
DestroyList(L);
}
4:顺序表区间元素删除
总时间限制: 5000ms 内存限制: 5000kB
描述
若一个线性表L采用顺序存储结构存储,其中所有的元素为整数。设计一个算法,删除元素值在[x,y]之间的所有元素,要求算法的时间复杂度为O(n),空间复杂度为O(1)。
输入
三行数据,第一行是顺序表的元素个数,第二行是顺序表的元素,第三行是x和y。
输出
删除元素值在[x,y]之间的所有元素后的顺序表。
样例输入
10
5 1 9 10 67 12 8 33 6 2
3 10
样例输出
1 67 12 33 2
ac代码:
#include <stdio.h>
#include<iostream>
using namespace std;
#define MaxSize 100
typedef int ElemType; //设置顺序表元素为int类型
typedef struct
{ ElemType data[MaxSize]; //存放顺序表的元素
int length; //顺序表的实际长度
} SqList; //顺序表类型声明
void InitList(SqList &L) //初始化顺序表L
{
L.length=0;
}
void DestroyList(SqList L) //销毁顺序表L
{
}
int GetLength(SqList L) //求长度
{
return L.length;
}
int GetElem(SqList L,int i,ElemType &e) //求第i个元素
{ if (i<1 || i>L.length) //无效的i值
return 0;
else
{ e=L.data[i-1];
return 1;
}
}
int Locate(SqList L,ElemType x) //查找第一个x元素的位置
{ int i=0;
while (i<L.length && L.data[i]!=x)
i++; //查找第1个值为x的元素
if (i>=L.length) return(0); //未找到返回0
else return(i+1); //找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i) //插入x作为第i个元素
{ int j;
if (i<1 || i>L.length+1) //无效的参数i
return 0;
for (j=L.length;j>i;j--) //将位置为i的元素及之后的元素后移
L.data[j]=L.data[j-1];
L.data[i-1]=x; //在位置i处放入x
L.length++; //顺序表长度增1
return 1;
}
int DelElem(SqList &L,int i) //删除第i个元素
{ int j;
if (i<1 || i>L.length) //无效的参数i
return 0;
for (j=i;j<L.length;j++) //将位置为i的元素之后的元素前移
L.data[j-1]=L.data[j];
L.length--; //顺序表长度减1
return 1;
}
void DispList(SqList L) //输出顺序表
{ int i;
for (i=0;i<L.length;i++)
printf("%d ",L.data[i]);
printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n) //整体创建顺序表L
{
int i,k=0; //k累计顺序表L中的元素个数
for (i=0;i<n;i++)
{
L.data[k]=a[i]; //向L中添加一个元素
k++; //L中元素个数增1
}
L.length=k; //设置L的长度
}
void Del(SqList &L,int x,int y)
{
for(int i=0;i<L.length;i++)
{
if(L.data[i]>=x&&L.data[i]<=y)
{
//printf("%d%d\n",i,L.data[i]);
DelElem(L,i+1);
i--;
}
}
}
int main()
{
SqList L;
int n;
scanf("%d",&n);
int a[n];
//int n=sizeof(a)/sizeof(a[0]);
for(int i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
CreateList(L,a,n);
int x,y;
scanf("%d%d",&x,&y);
// printf("%d %d\n",x,y);
// for(int i=0;i<L.length;i++)
// {
// printf("%d\n",L.data[i]);
// }
Del(L,x,y);
DispList(L);
DestroyList(L);
}
5:顺序有序表中删除多余元素
总时间限制: 1000ms 内存限制: 65535kB
描述
编写算法,在一个非递减有序的顺序表中删除所有值相等的多余的元素。要求时间复杂度为O(n),空间复杂度为O(1)。
输入
两行,第一行为数据元素的个数n,第二行为n个元素,n<=1000000
输出
删除多余元素后的数据序列
样例输入
10
-1 -1 1 2 2 3 3 3 4 5
样例输出
-1 1 2 3 4 5
ac代码:
#include <stdio.h>
#include<iostream>
using namespace std;
#define MaxSize 1000000
typedef int ElemType; //设置顺序表元素为int类型
typedef struct
{ ElemType data[MaxSize]; //存放顺序表的元素
int length; //顺序表的实际长度
} SqList; //顺序表类型声明
void InitList(SqList &L) //初始化顺序表L
{
L.length=0;
}
void DestroyList(SqList L) //销毁顺序表L
{
}
int GetLength(SqList L) //求长度
{
return L.length;
}
int GetElem(SqList L,int i,ElemType &e) //求第i个元素
{ if (i<1 || i>L.length) //无效的i值
return 0;
else
{ e=L.data[i-1];
return 1;
}
}
int Locate(SqList L,ElemType x) //查找第一个x元素的位置
{ int i=0;
while (i<L.length && L.data[i]!=x)
i++; //查找第1个值为x的元素
if (i>=L.length) return(0); //未找到返回0
else return(i+1); //找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i) //插入x作为第i个元素
{ int j;
if (i<1 || i>L.length+1) //无效的参数i
return 0;
for (j=L.length;j>i;j--) //将位置为i的元素及之后的元素后移
L.data[j]=L.data[j-1];
L.data[i-1]=x; //在位置i处放入x
L.length++; //顺序表长度增1
return 1;
}
int DelElem(SqList &L,int i) //删除第i个元素
{ int j;
if (i<1 || i>L.length) //无效的参数i
return 0;
for (j=i;j<L.length;j++) //将位置为i的元素之后的元素前移
L.data[j-1]=L.data[j];
L.length--; //顺序表长度减1
return 1;
}
void DispList(SqList L) //输出顺序表
{ int i;
for (i=0;i<L.length;i++)
printf("%d ",L.data[i]);
printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n) //整体创建顺序表L
{
int i,k=0; //k累计顺序表L中的元素个数
for (i=0;i<n;i++)
{
L.data[k]=a[i]; //向L中添加一个元素
k++; //L中元素个数增1
}
L.length=k; //设置L的长度
}
void DelSame(SqList &L)
{
int k=0;
for(int i=0;i<=L.length;i++)
{
if(L.data[i]!=L.data[k])
{
k++;
L.data[k]=L.data[i];
}
}
L.length=k;
}
int main()
{
SqList L;
int n;
cin>>n;
int a[1000000];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
CreateList(L,a,n);
DelSame(L); //删除重复元素
DispList(L);
DestroyList(L);
}
6:整数顺序表的基本运算
总时间限制: 10000ms 内存限制: 10000kB
描述
设计整数顺序表的基本运算程序,并用相关数据进行测试
输入
顺序输入顺序表A的元素个数及各个元素
输出
第一行:创建顺序表A后,输出所有元素
第二行:删除第一个元素,输出删除后的所有元素
第三行:输出删除元素后顺序表的长度
第四行:在第二元素处插入一个新的元素100
第五行:输出第一个元素100所在位置
样例输入
6
1 2 3 4 0 9
样例输出
1 2 3 4 0 9
2 3 4 0 9
5
2 100 3 4 0 9
2
ac代码:
#include <stdio.h>
#include<iostream>
using namespace std;
#define MaxSize 100
typedef int ElemType; //设置顺序表元素为int类型
typedef struct
{ ElemType data[MaxSize]; //存放顺序表的元素
int length; //顺序表的实际长度
} SqList; //顺序表类型声明
void InitList(SqList &L) //初始化顺序表L
{
L.length=0;
}
void DestroyList(SqList L) //销毁顺序表L
{
}
int GetLength(SqList L) //求长度
{
return L.length;
}
int GetElem(SqList L,int i,ElemType &e) //求第i个元素
{ if (i<1 || i>L.length) //无效的i值
return 0;
else
{ e=L.data[i-1];
return 1;
}
}
int Locate(SqList L,ElemType x) //查找第一个x元素的位置
{ int i=0;
while (i<L.length && L.data[i]!=x)
i++; //查找第1个值为x的元素
if (i>=L.length) return(0); //未找到返回0
else return(i+1); //找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i) //插入x作为第i个元素
{ int j;
if (i<1 || i>L.length+1) //无效的参数i
return 0;
for (j=L.length;j>=i;j--) //将位置为i的元素及之后的元素后移
L.data[j]=L.data[j-1];
L.data[i-1]=x; //在位置i处放入x
L.length++; //顺序表长度增1
return 1;
}
int DelElem(SqList &L,int i) //删除第i个元素
{ int j;
if (i<1 || i>L.length) //无效的参数i
return 0;
for (j=i;j<L.length;j++) //将位置为i的元素之后的元素前移
L.data[j-1]=L.data[j];
L.length--; //顺序表长度减1
return 1;
}
void DispList(SqList L) //输出顺序表
{ int i;
for (i=0;i<L.length;i++)
printf("%d ",L.data[i]);
printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n) //整体创建顺序表L
{
int i,k=0; //k累计顺序表L中的元素个数
for (i=0;i<n;i++)
{
L.data[k]=a[i]; //向L中添加一个元素
k++; //L中元素个数增1
}
L.length=k; //设置L的长度
}
void DelSame(SqList &L)
{
int k=0;
for(int i=0;i<=L.length;i++)
{
if(L.data[i]!=L.data[k])
{
k++;
L.data[k]=L.data[i];
}
}
L.length=k;
}
int main()
{
SqList L;
int n;
cin>>n;
int a[100];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
CreateList(L,a,n);
DispList(L);
DelElem(L,1);
DispList(L);
cout<<L.length<<endl;
InsElem(L,100,2);
DispList(L);
cout<<Locate(L,100)<<endl;
DestroyList(L);
}
7:整数顺序表的并集、差集和交集
查看提交统计提问
总时间限制: 10000ms 内存限制: 10000kB
描述
采用顺序表存储非空整数集合(同一个集合中没有相同的元素,两个集合中可能存在相同的元素),设计完成如下功能的算法并用相关数据进行测试。
①求两个集合A、B的并集C=A∪B
②求两个集合A、B的差集C=A-B
③求两个集合A、B的交集C=A∩B
输入
顺序输入集合A的元素个数及各个元素,集合B的元素个数及各个元素
输出
如果A集合或B集合内有重复,输出“Repeat Error!”
如果A集合和B集合合法,则输出并集(输出提示标识为CU)、差集(输出提示标识为CD)、交集(输出提示标识为CI)。
样例输入
4
1 2 3 4
5
3 4 5 6 7
样例输出
CU:1 2 3 4 5 6 7
CD:1 2
CI:3 4
ac代码:
#include <stdio.h>
#include <iostream>
using namespace std;
#define MaxSize 100
typedef int ElemType; //设置顺序表元素为int类型
typedef struct
{ ElemType data[MaxSize]; //存放顺序表的元素
int length; //顺序表的实际长度
} SqList; //顺序表类型声明
void InitList(SqList &L) //初始化顺序表L
{
L.length=0;
}
void DestroyList(SqList L) //销毁顺序表L
{
}
int GetLength(SqList L) //求长度
{
return L.length;
}
int GetElem(SqList L,int i,ElemType &e) //求第i个元素
{ if (i<1 || i>L.length) //无效的i值
return 0;
else
{ e=L.data[i-1];
return 1;
}
}
int Locate(SqList L,ElemType x) //查找第一个x元素的位置
{ int i=0;
while (i<L.length && L.data[i]!=x)
i++; //查找第1个值为x的元素
if (i>=L.length) return(0); //未找到返回0
else return(i+1); //找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i) //插入x作为第i个元素
{ int j;
if (i<1 || i>L.length+1) //无效的参数i
return 0;
for (j=L.length;j>=i;j--) //将位置为i的元素及之后的元素后移
L.data[j]=L.data[j-1];
L.data[i-1]=x; //在位置i处放入x
L.length++; //顺序表长度增1
return 1;
}
int DelElem(SqList &L,int i) //删除第i个元素
{ int j;
if (i<1 || i>L.length) //无效的参数i
return 0;
for (j=i;j<L.length;j++) //将位置为i的元素之后的元素前移
L.data[j-1]=L.data[j];
L.length--; //顺序表长度减1
return 1;
}
void DispList(SqList L) //输出顺序表
{ int i;
for (i=0;i<L.length;i++)
printf("%d ",L.data[i]);
printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n) //整体创建顺序表L
{
int i,k=0; //k累计顺序表L中的元素个数
for (i=0;i<n;i++)
{
L.data[k]=a[i]; //向L中添加一个元素
k++; //L中元素个数增1
}
L.length=k; //设置L的长度
}
// 在此处补充你的代码
int FindSame(SqList &L,SqList &L1)
{
int m=0;//记录发现
int k=0;//用于L
int p=0;//用于L1
for(int i=0;i<L.length-1;i++)
{
if(k==1)
{
break;
}
for(int j=i+1;j<L.length;j++)
{
if(k!=1&&(L.data[i]==L.data[j]))
{
m++;
k=1;
break;
}
else if(k==1)
break;
}
}
for(int i=0;i<L1.length-1;i++)
{
if(p==1)
{
break;
}
for(int j=i+1;j<L1.length;j++)
{
if(p!=1&&(L1.data[i]==L1.data[j]))
{
m++;
p=1;
break;
}
else if(p==1)
break;
}
}
if(m>=1)
return 0;
else
return 1;
}
void DelSame(SqList &L)
{
for(int i=0;i<L.length;i++)
{
for(int j=i+1;j<L.length;j++)
{
if(L.data[j]==L.data[i])
{
DelElem(L,j+1);
j--;
}
}
}
}
void cu(SqList &L,SqList &L1,SqList &L2)
{
for(int i=0;i<L1.length;i++)
{
InsElem(L2,L1.data[i],L.length+i+1);
}
DelSame(L2);
}
void cha(SqList &L,SqList &L1,SqList &L2)
{
int k=0;
for(int i=0;i<L2.length;i++)
{
if((Locate(L1,L2.data[i])<1) || (Locate(L1,L2.data[i])>L1.length))
{
L2.data[k]=L2.data[i];
k++;
}
}
L2.length=k;
}
void jiao(SqList &L,SqList &L1,SqList &L2)
{
int k=0;
for(int i=0;i<L.length;i++)
{
if((Locate(L2,L.data[i])<1)||(Locate(L2,L.data[i])>L2.length))
{
InsElem(L2,L.data[i],k+1);
k++;
}
}
L2.length=k;
}
int main()
{
SqList L;
SqList L1;
SqList L2;
int n,n1;
int a[MaxSize],b[MaxSize],c[MaxSize];
cin>>n;
for(int i=0;i<n;i++)
{
cin>>a[i];
}
CreateList(L,a,n);
cin>>n1;
for(int i=0;i<n1;i++)
{
cin>>b[i];
}
CreateList(L1,b,n1);
CreateList(L2,a,n);
if(FindSame(L,L1)){
cu(L,L1,L2);
cout<<"CU:";
DispList(L2);
cha(L,L1,L2);
cout<<"CD:";
DispList(L2);
jiao(L,L1,L2);
cout<<"CI:";
DispList(L2);
DestroyList(L);
DestroyList(L1);
DestroyList(L2);
}
else
{
cout<<"Repeat Error!"<<endl;
}
return 0;
}
8:奇偶顺序表
总时间限制: 10000ms 内存限制: 10000kB
描述
设有一个顺序表L,其元素均为正整数,设计一个算法将L中所有偶数删除并存到另一个顺序表L1中,而顺序表保留原来的所有奇数。并用相关数据进行测试。
输入
输入第一行:数据长度
输入第二行:数据具体数值
输出
输出第一行:数据中包含基数
输出第二行:数据中包含偶数
样例输入
8
1 9 2 8 3 7 4 6
样例输出
1 9 3 7
2 8 4 6
#include <stdio.h>
#define MaxSize 100
#include<iostream>
using namespace std;
const int MAXSIZE=100;
typedef int ElemType; //设置顺序表元素为int类型
typedef struct
{ ElemType data[MaxSize]; //存放顺序表的元素
int length; //顺序表的实际长度
} SqList; //顺序表类型声明
void InitList(SqList &L) //初始化顺序表L
{
L.length=0;
}
void DestroyList(SqList L) //销毁顺序表L
{
}
int GetLength(SqList L) //求长度
{
return L.length;
}
int GetElem(SqList L,int i,ElemType &e) //求第i个元素
{ if (i<1 || i>L.length) //无效的i值
return 0;
else
{ e=L.data[i-1];
return 1;
}
}
int Locate(SqList L,ElemType x) //查找第一个x元素的位置
{ int i=0;
while (i<L.length && L.data[i]!=x)
i++; //查找第1个值为x的元素
if (i>=L.length) return(0); //未找到返回0
else return(i+1); //找到后返回其逻辑序号
}
int InsElem(SqList &L,ElemType x,int i) //插入x作为第i个元素
{ int j;
if (i<1 || i>L.length+1) //无效的参数i
return 0;
for (j=L.length;j>i;j--) //将位置为i的元素及之后的元素后移
L.data[j]=L.data[j-1];
L.data[i-1]=x; //在位置i处放入x
L.length++; //顺序表长度增1
return 1;
}
int DelElem(SqList &L,int i) //删除第i个元素
{ int j;
if (i<1 || i>L.length) //无效的参数i
return 0;
for (j=i;j<L.length;j++) //将位置为i的元素之后的元素前移
L.data[j-1]=L.data[j];
L.length--; //顺序表长度减1
return 1;
}
void DispList(SqList L) //输出顺序表
{ int i;
for (i=0;i<L.length;i++)
printf("%d ",L.data[i]);
printf("\n");
}
void CreateList(SqList &L,ElemType a[],int n) //整体创建顺序表L
{
int i,k=0; //k累计顺序表L中的元素个数
for (i=0;i<n;i++)
{
L.data[k]=a[i]; //向L中添加一个元素
k++; //L中元素个数增1
}
L.length=k; //设置L的长度
}
//开始补充代码
void Split(SqList &L,SqList &L1)
{
int k=0;
for(int i=0;i<L.length;i++)
{
if(L.data[i]%2==0)
{
InsElem(L1,L.data[i],k+1);
DelElem(L,i+1);
i--;
k++;
}
}
}
int main()
{
SqList L,L1;
int n,a[MAXSIZE];
cin>>n;
for(int i=0;i<n;i++)
cin>>a[i];
CreateList(L,a,n);
Split(L,L1);
DispList(L);
DispList(L1);
DestroyList(L);
DestroyList(L1);
return 0;
}