数据结构与算法1顺序表.docx
《数据结构与算法1顺序表.docx》由会员分享，可在线阅读，更多相关《数据结构与算法1顺序表.docx（18页珍藏版）》请在冰豆网上搜索。
数据结构与算法1顺序表
顺序表应用1：
多余元素删除之移位算法
TimeLimit:
1000MSMemorylimit:
650K
题目描述
一个长度不超过10000数据的顺序表，可能存在着一些值相同的“多余”数据元素（类型为整型），编写一个程序将“多余”的数据元素从顺序表中删除，使该表由一个“非纯表”（值相同的元素在表中可能有多个）变成一个“纯表”（值相同的元素在表中只保留第一个）。
要求：
1、必须先定义线性表的结构与操作函数，在主函数中借助该定义与操作函数调用实现问题功能；
2、本题的目标是熟悉顺序表的移位算法，因此题目必须要用元素的移位实现删除；
输入
第一行输入整数n，代表下面有n行输入；
之后输入n行，每行先输入整数m，之后输入m个数据，代表对应顺序表的每个元素。
输出
输出有n行，为每个顺序表删除多余元素后的结果
示例输入
45696893555598765101234554213
示例输出
69859876512345
#include
usingnamespacestd;
typedefstruct
{
int*elem;
intlength;
intlistsize;
}List;
voidcreate（List&L,intn）
{
L.elem=newint[10001];
L.length=0;
for（inti=0;i{
scanf（"%d",&L.elem[i]）;
L.length++;
}
L.listsize=10001;
}
voidDeleteRepeat（List&L）
{
intj,k,i;
for（i=0;i{
for（j=i+1;j{
if（L.elem[i]==L.elem[j]）
{
for（k=j;k{
L.elem[k]=L.elem[k+1];
}
L.length--;
j--;
}
}
}
}
/*或运用指针写
voidDeleteRepeat（List&L）
{
int*p,*q;
p=L.elem;
q=L.elem+L.length;
for（;p{
for（int*t=p+1;t{
if（*p==*t）
{
for（int*k=t;k{
*k=*（k+1）;
}
L.length--;
q--;
t--;
}
}
}
}*/
intmain（）
{
intn;
scanf（"%d",&n）;
while（n--）
{
intm;
scanf（"%d",&m）;
Listp;
create（p,m）;
DeleteRepeat（p）;
for（inti=0;i{
if（i==p.length-1）
printf（"%d\n",p.elem[i]）;
else
printf（"%d",p.elem[i]）;
}
}
return0;
}
顺序表应用2：
多余元素删除之建表算法
TimeLimit:
3MSMemorylimit:
600K
题目描述
一个长度不超过10000数据的顺序表，可能存在着一些值相同的“多余”数据元素（类型为整型），编写一个程序将“多余”的数据元素从顺序表中删除，使该表由一个“非纯表”（值相同的元素在表中可能有多个）变成一个“纯表”（值相同的元素在表中只保留第一个）。
要求：
1、必须先定义线性表的结构与操作函数，在主函数中借助该定义与操作函数调用实现问题功能；
2、本题的目标是熟悉在顺序表原表空间基础上建新表的算法，要在原顺序表空间的基础上完成完成删除，建表过程不得开辟新的表空间；
3、不得采用原表元素移位删除的方式。
输入
第一行输入整数n，代表下面有n行输入；
之后输入n行，每行先输入整数m，之后输入m个数据，代表对应顺序表的每个元素。
输出
输出有n行，为每个顺序表删除多余元素后的结果
示例输入
45696893555598765101234554213
示例输出
69859876512345
#include
usingnamespacestd;
typedefstruct
{
int*elem;
intlength;
intlen;
intlistsize;
}List;
voidcreate（List&L,intn）
{
L.elem=newint[10001];
L.length=0;
for（inti=0;i{
scanf（"%d",&L.elem[i]）;
L.length++;
}
L.listsize=10001;
}
voidDeleteRepeat（List&L）
{
intk,j,i;
L.len=0;
for（i=1;i{
for（j=0;j<=L.len;j++）
{
if（L.elem[j]==L.elem[i]）
break;
else
continue;
}
if（j==L.len+1）
{
L.elem[L.len]=L.elem[i];
L.len++;
}
}
}
intmain（）
{
intn;
scanf（"%d",&n）;
while（n--）
{
intm;
scanf（"%d",&m）;
Listp;
create（p,m）;
DeleteRepeat（p）;
for（inti=0;i{
if（i==p.len）
printf（"%d\n",p.elem[i]）;
else
printf（"%d",p.elem[i]）;
}
}
return0;
}
顺序表应用3：
元素位置互换之移位算法
TimeLimit:
1000MSMemorylimit:
570K
题目描述
一个长度为len（1<=len<=1000000）的顺序表，数据元素的类型为整型，将该表分成两半，前一半有m个元素，后一半有len-m个元素（1<=m<=len），借助元素移位的方式，设计一个空间复杂度为O
（1）的算法，改变原来的顺序表，把顺序表中原来在前的m个元素放到表的后段，后len-m个元素放到表的前段。
注意：
先将顺序表元素调整为符合要求的内容后，再做输出，输出过程只能用一个循环语句实现，不能分成两个部分。
输入
第一行输入整数n，代表下面有n行输入；
之后输入n行，每行先输入整数len与整数m（分别代表本表的元素总数与前半表的元素个数），之后输入len个整数，代表对应顺序表的每个元素。
输出
输出有n行，为每个顺序表前m个元素与后（len-m）个元素交换后的结果
示例输入
210312345678910531030205080
示例输出
456789101235080103020
提示
注意：
先将顺序表元素调整为符合要求的内容后，再做输出，输出过程只能在一次循环中完成，不能分成两个部分输出。
#include
usingnamespacestd;
typedefstruct
{
int*elem;
intlength;
intlistsize;
}List;
voidcreate（List&L,intn）
{
L.elem=newint[10001];
L.length=0;
for（inti=0;i{
scanf（"%d",&L.elem[i]）;
L.length++;
}
L.listsize=10001;
}
voidListexchange（List&L,intlen,intm）
{
inti,k;
while（m--）
{
k=L.elem[0];
for（i=0;i{
L.elem[i]=L.elem[i+1];
}
L.elem[len-1]=k;
}
}
intmain（）
{
intn;
scanf（"%d",&n）;
while（n--）
{
intlen,m;
scanf（"%d%d",&len,&m）;
Listp;
create（p,len）;
Listexchange（p,len,m）;
for（inti=0;i{
if（i==len-1）
printf（"%d\n",p.elem[i]）;
else
printf（"%d",p.elem[i]）;
}
}
return0;
}
顺序表应用4：
元素位置互换之逆置算法
TimeLimit:
10MSMemorylimit:
570K
题目描述
一个长度为len（1<=len<=1000000）的顺序表，数据元素的类型为整型，将该表分成两半，前一半有m个元素，后一半有len-m个元素（1<=m<=len），设计一个时间复杂度为O（N）、空间复杂度为O
（1）的算法，改变原来的顺序表，把顺序表中原来在前的m个元素放到表的后段，后len-m个元素放到表的前段。
注意：
先将顺序表元素调整为符合要求的内容后，再做输出，输出过程只能用一个循环语句实现，不能分成两个部分。
输入
第一行输入整数n，代表下面有n行输入；
之后输入n行，每行先输入整数len与整数m（分别代表本表的元素总数与前半表的元素个数），之后输入len个整数，代表对应顺序表的每个元素。
输出
输出有n行，为每个顺序表前m个元素与后（len-m）个元素交换后的结果
示例输入
210312345678910531030205080
示例输出
456789101235080103020
提示
注意：
先将顺序表元素调整为符合要求的内容后，再做输出，输出过程只能用一个循环语句实现，不能分成两个部分。
#include
usingnamespacestd;
typedefstruct
{
int*elem;
intlength;
intlength2;
intlistsize;
}List;
voidcreate（List&L,intn）
{
L.elem=newint[10001];
L.length=0;
for（inti=0;i{
scanf（"%d",&L.elem[i]）;
L.length++;
}
L.listsize=10001;
}
voidListexchange（List&L,intlen,intm）
{
inti,k,j,l;
l=len/2;
for（i=0;i<=l;i++）
{
for（k=0,j=len-1;k<=l,j>=l;k++,j--）
{
intt;
t=L.elem[k];
L.elem[k]=L.elem[j];
L.elem[j]=t;
}
}
}
intmain（）
{
intn;
scanf（"%d",&n）;
while（n--）
{
intlen,m;
scanf（"%d%d",&len,&m）;
Listp;
create（p,len）;
Listexchange（p,len,m）;
for（inti=0;i{
if（i==len-1）
printf（"%d\n",p.elem[i]）;
else
printf（"%d",p.elem[i]）;
}
}
return0;
}
顺序表应用5：
有序顺序表归并
TimeLimit:
100MSMemorylimit:
800K
题目描述
已知顺序表A与B是两个有序的顺序表，其中存放的数据元素皆为普通整型，将A与B表归并为C表，要求C表包含了A、B表里所有元素，并且C表仍然保持有序。
输入
输入分为三行：
第一行输入m、n（1<=m,n<=10000）的值，即为表A、B的元素个数；
第二行输入m个有序的整数，即为表A的每一个元素；
第三行输入n个有序的整数，即为表B的每一个元素；
输出
输出为一行，即将表A、B合并为表C后，依次输出表C所存放的元素。
示例输入
53
13569
2410
示例输出
123456910
#include
#include
usingnamespacestd;
voidmergelist（list&L1,list&L2,list&L3）
{
int*pa,*pa_last,*pb_last,*pc,*pb;
pa=L1.elem;
pb=L2.elem;
L3.listsize=L3.length=L1.length+L2.length;
pc=L3.elem=newint[20000];
pa_last=L1.elem+L1.length-1;//
pb_last=L2.elem+L2.length-1;//
while（pa<=pa_last&&pb<=pb_last）
{
if（*pa<=*pb）
*pc++=*pa++;
else
*pc++=*pb++;
}
while（pa<=pa_last）
{
*pc++=*pa++;
}
while（pb<=pb_last）
{
*pc++=*pb++;
}
}
voidprintf（list&L）
{
inti;
for（i=0;i{
if（i==0）
printf（"%d",L.elem[i]）;
else
printf（"%d",L.elem[i]）;
}
}
typedefstruct
{
int*elem;
intlength;
intlistsize;
}list;
voidcreatelist（list&L,intn）
{
L.elem=newint[10000];
for（inti=0;iscanf（"%d",&L.elem[i]）;
L.length=n;
}
listmergelist（list&L1,list&L2）
{
listL3;
int*pa,*pa_last,*pb_last,*pc,*pb;
pa=L1.elem;
pb=L2.elem;
L3.listsize=L3.length=L1.length+L2.length;
pc=L3.elem=newint[20000];
pa_last=L1.elem+L1.length-1;//
pb_last=L2.elem+L2.length-1;//
while（pa<=pa_last&&pb<=pb_last）
{
if（*pa<=*pb）
*pc++=*pa++;
else
*pc++=*pb++;
}
while（pa<=pa_last）
{
*pc++=*pa++;
}
while（pb<=pb_last）
{
*pc++=*pb++;
}
returnL3;
}
intmain（）
{
listL1,L2,L3;
intn,m;
scanf（"%d%d",&n,&m）;
createlist（L1,n）;
createlist（L2,m）;
mergelist（L1,L2,L3）;
printf（L3）;
printf（"\n"）;
return0;
}
intmain（）
{
listL1,L2,L4;
intn,m,i;
scanf（"%d%d",&n,&m）;
createlist（L1,n）;
createlist（L2,m）;
L4=mergelist（L1,L2）;
for（i=0;i{
if（i==0）
printf（"%d",L4.elem[i]）;
else
printf（"%d",L4.elem[i]）;
}
printf（"\n"）;
return0;
}
顺序表应用6：
有序顺序表查询
TimeLimit:
5MSMemorylimit:
700K
题目描述
顺序表内按照由小到大的次序存放着n个互不相同的整数（1<=n<=20000），任意输入一个整数，判断该整数在顺序表中是否存在。
如果在顺序表中存在该整数，输出其在表中的序号；否则输出“NoFound!
"。
输入
第一行输入整数n，表示顺序表的元素个数；
第二行依次输入n个各不相同的有序整数，代表表里的元素；
第三行输入整数t，代表要查询的次数；
第四行依次输入t个整数，代表每次要查询的数值。
输出
输出t行，代表t次查询的结果，如果找到在本行输出该元素在表中的位置，否则本行输出NoFound!
示例输入
10
1223355637074798087
4
5510287
示例输出
4NoFound!
NoFound!
10
#include
#include
#include
usingnamespacestd;
typedefstruct
{
int*elem;
intlength;
intlistsize;
}list;
voidcreatelist（list&L,intn）
{
L.elem=newint[20000];
for（inti=0;iscanf（"%d",&L.elem[i]）;
L.length=n;
}
intseeklist（list&L,inta）
{
inthead,mid,lat;
head=0;
lat=L.length-1;
while（head<=lat）
{
mid=（head+lat）/2;
if（L.elem[mid]head=mid+1;
elseif（L.elem[mid]>a）
lat=mid-1;
else
returnmid;
}
return-1;
}
intmain（）
{
intn;
listL;
scanf（"%d",&n）;
createlist（L,n）;
intt,i,k,m;
scanf（"%d",&t）;
for（i=0;i{
scanf（"%d",&m）;
k=seeklist（L,m）;
if（k!
=-1）
printf（"%d\n",k+1）;
elseif（k==-1）
printf（"NoFound!
\n"）;
}
return0;
}
升级会员 