顺序表的基本操作
数据结构--顺序表的基本操作
·
第1关：顺序表的插入操作
任务描述
本关任务：编写顺序表的初始化、插入、遍历三个基本操作函数。
测试说明
平台会对你编写的代码进行测试：
输入说明
第一行输入顺序表的长度M；
第二行输入顺序表的M个整数；
第三行输入要插入元素的位置；
第四行输入要插入的数据元素的值。
输出说明
第一行输出插入是否成功的提示信息；
如果插入成功，第二行输出插入元素后的顺序表所有元素；如果插入失败，则不输出第二行。
测试输入：
5
12 47 5 8 69
1
99
预期输出：
插入成功，插入后顺序表如下：
99 12 47 5 8 69
测试输入：
5
12 47 5 8 69
7
99
预期输出：
插入位置不合法，插入失败！
代码如下
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#define INIT_SIZE 5
#define INCREMENT 10
# define OK 1
# define ERROR 0
/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
/* 顺序表类型定义 */
typedef struct
{
ElemType *elem; //存储空间基地址
int length; //当前长度
int listsize; //当前分配的存储容量
}SqList;
void InitList(SqList&L);
int ListInsert(SqList &L,int i,ElemType e);
void ListTraverse(SqList L,void(*vi)(ElemType ) );
int main() //main() function
{
SqList A;
ElemType e;
InitList(A);
int n,i;
// cout<<"Please input the list number ";
cin>>n;
for(i=1;i<=n;i++)
{
cin>>e;
ListInsert(A, i, e);
}
//cout<<"请输入插入的位置："<<endl;
cin>>i;
//cout<<"请输入插入的值："<<endl;
input(e);
if( ListInsert(A,i,e) )
{
cout<<"插入成功，插入后顺序表如下："<<endl;
ListTraverse(A,output) ;
}
else
cout<<"插入位置不合法，插入失败！"<<endl;
return 0;
}
/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
cin>>s;
}
void output(ElemType s)
{
cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
if(a==b)
return 1;
else
return 0;
}
/*****顺序表的基本操作*****/
void InitList(SqList &L)
{ // 操作结果：构造一个空的顺序线性表L
/********** Begin **********/
L.elem=(ElemType *)malloc(INIT_SIZE*sizeof(ElemType));
if(!L.elem)
exit(-1);
L.length=0;
L.listsize=INIT_SIZE;
/********** End **********/
}
int ListInsert(SqList &L,int i,ElemType e)
{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1
// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
/********** Begin **********/
ElemType *newbase,*q,*p;
if(i<1 || i>L.length+1)
return 0;
if(L.length>=L.listsize){
if(!(newbase=(ElemType *)realloc(L.elem,(L.listsize+INCREMENT)*sizeof(ElemType))))
exit(-1);
L.elem=newbase;
L.listsize+=INCREMENT;
}
q=L.elem+i-1;
for(p=L.elem+L.length-1;p>=q;--p)
*(p+1)=*p;
*q=e;
++L.length;
return 1;
/********** End **********/
}
void ListTraverse(SqList L,void(*vi)(ElemType ) )
{ // 初始条件：顺序线性表L已存在
// 操作结果：依次对L的每个数据元素调用函数vi()输出
/********** Begin **********/
ElemType *p;
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(*p++);
printf("\n");
/********** End **********/
}
第2关：顺序表的删除操作
任务描述
本关任务：编写顺序表的删除操作函数。
测试说明
平台会对你编写的代码进行测试：
测试输入：
5
12 47 5 8 69
1
预期输出：
删除成功，删除后顺序表如下：
47 5 8 69
删除元素的值：12
测试输入：
5
12 47 5 8 69
6
预期输出：
删除位置不合法，删除失败！
输入说明
第一行输入顺序表的长度M；
第二行输入顺序表的M个整数；
第三行输入要删除元素的位置；
输出说明
第一行输出删除是否成功的提示信息；
如果删除成功，第二行输出删除元素后的顺序表；第三行输出删除的数据元素；如果删除位置不合法，不输出第二行和第三行。
代码如下
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#define INIT_SIZE 5
#define INCREMENT 10
/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
/* 顺序表类型定义 */
typedef struct
{
ElemType *elem; //存储空间基地址
int length; //当前长度
int listsize; //当前分配的存储容量
}SqList;
void InitList(SqList&L);
int ListInsert(SqList &L,int i,ElemType e);
int ListDelete(SqList &L,int i,ElemType&e) ;
void ListTraverse(SqList L,void(*vi)(ElemType ) );
int main() //main() function
{
SqList A;
ElemType e;
InitList(A);
int n,i;
// cout<<"Please input the list number ";
cin>>n;
for(i=1;i<=n;i++)
{
cin>>e;
ListInsert(A, i, e);
}
//cout<<"请输入删除的位置："<<endl;
cin>>i;
if( ListDelete(A,i,e) )
{
cout<<"删除成功，删除后顺序表如下："<<endl;
ListTraverse(A,output) ;
cout<<"删除元素的值：";
output(e);
cout<<endl;
}
else
cout<<"删除位置不合法，删除失败！"<<endl;
}
/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
cin>>s;
}
void output(ElemType s)
{
cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
if(a==b)
return 1;
else
return 0;
}
/*****顺序表的基本操作*****/
void InitList(SqList&L)
{ // 操作结果：构造一个空的顺序线性表L
/********** Begin **********/
L.elem=(ElemType*)malloc( INIT_SIZE*sizeof(ElemType));
if(!L.elem)
return; // 存储分配失败
L.length=0; // 空表长度为0
L.listsize=INIT_SIZE; // 初始存储容量
/********** End **********/
}
int ListInsert(SqList &L,int i,ElemType e)
{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1
// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
/********** Begin **********/
ElemType *newbase,*q,*p;
if(i<1||i>L.length+1) // i值不合法
return 0;
if(L.length>=L.listsize)
{ // 当前存储空间已满，增加分配
if(!(newbase=(ElemType*)realloc(L.elem,(L.listsize+INCREMENT)*sizeof(ElemType))))
return(0); ; // 存储分配失败
L.elem=newbase; // 新基址
L.listsize+= INCREMENT; // 增加存储容量
}
q=L.elem+i-1; // q为插入位置
for(p=L.elem+L.length-1;p>=q;--p) // 插入位置及之后的元素右移
*(p+1)=*p;
*q=e; // 插入e
++L.length; // 表长增1
return 1;
/********** End **********/
}
void ListTraverse(SqList L,void(*vi)(ElemType ) )
{
// 初始条件：顺序线性表L已存在
// 操作结果：依次对L的每个数据元素调用函数vi()输出
/********** Begin **********/
ElemType *p;
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(*p++);
printf("\n");
/********** End **********/
}
int ListDelete(SqList &L,int i,ElemType&e)
{
// 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
/********** Begin **********/
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;
/********** End **********/
}
第3关：顺序表的按照序号查找值操作
任务描述
本关任务：编写顺序表的按照序号i查找数据元素值的操作函数。
测试说明
平台会对你编写的代码进行测试：
测试输入：
10
12 47 5 8 6 92 45 63 75 38
8
预期输出：
查找成功！
第8个元素的值：
63
测试输入：
10
12 47 5 8 6 92 45 63 75 38
11
预期输出：
查找失败！
输入说明
第一行输入顺序表的长度M；
第二行输入顺序表的M个整数；
第三行输入要查找的序号；
输出说明
第一行输出按照序号查找是否成功的提示信息；
如果查找成功，输出查找的元素的值；如果查找失败，则不输出。
代码如下
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#define INIT_SIZE 5
#define INCREMENT 10
# define OK 1
# define ERROR 0
/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
/* 顺序表类型定义 */
typedef struct
{
ElemType *elem; //存储空间基地址
int length; //当前长度
int listsize; //当前分配的存储容量
}SqList;
void InitList(SqList&L);
int ListInsert(SqList &L,int i,ElemType e);
void ListTraverse(SqList L,void(*vi)(ElemType ) );
int GetElem(SqList L,int i,ElemType&e);
int main() //main() function
{
SqList A;
ElemType e;
InitList(A);
int n,i;
// cout<<"Please input the list number ";
cin>>n;
for(i=1;i<=n;i++)
{
cin>>e;
ListInsert(A, i, e);
}
//cout<<"请输入查找的序号："<<endl;
cin>>i;
if( GetElem(A,i,e) )
{
cout<<"查找成功！"<<endl;
cout<<"第"<<i<<"个元素的值："<<endl;
output(e);
cout<<endl;
}
else
cout<<"查找失败！"<<endl;
}
/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
cin>>s;
}
void output(ElemType s)
{
cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
if(a==b)
return 1;
else
return 0;
}
/*****顺序表的基本操作*****/
void InitList(SqList&L)
{ // 操作结果：构造一个空的顺序线性表L
/********** Begin **********/
L.elem=(ElemType*)malloc( INIT_SIZE*sizeof(ElemType));
if(!L.elem)
return; // 存储分配失败
L.length=0; // 空表长度为0
L.listsize=INIT_SIZE; // 初始存储容量
/********** End **********/
}
int ListInsert(SqList &L,int i,ElemType e)
{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1
// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
/********** Begin **********/
ElemType *newbase,*q,*p;
if(i<1||i>L.length+1) // i值不合法
return 0;
if(L.length>=L.listsize)
{ // 当前存储空间已满，增加分配
if(!(newbase=(ElemType*)realloc(L.elem,(L.listsize+INCREMENT)*sizeof(ElemType))))
return(0); ; // 存储分配失败
L.elem=newbase; // 新基址
L.listsize+= INCREMENT; // 增加存储容量
}
q=L.elem+i-1; // q为插入位置
for(p=L.elem+L.length-1;p>=q;--p) // 插入位置及之后的元素右移
*(p+1)=*p;
*q=e; // 插入e
++L.length; // 表长增1
return 1;
/********** End **********/
}
void ListTraverse(SqList L,void(*vi)(ElemType ) )
{
// 初始条件：顺序线性表L已存在
// 操作结果：依次对L的每个数据元素调用函数vi()输出
/********** Begin **********/
ElemType *p;
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(*p++);
printf("\n");
/********** End **********/
}
int GetElem(SqList L,int i,ElemType &e)
{
//初始条件：顺序线性表L已存在，1≤i≤ListLength(L)。
//操作结果：用e返回L中第i个数据元素的值
/********** Begin **********/
if(i<1 || i>L.length)
return 0;
e=*(L.elem+i-1);
return 1;
/********** End **********/
}
第4关：顺序表的按照值查找序号操作
任务描述
本关任务：编写顺序表按照值查找序号操作的函数。
测试说明
平台会对你编写的代码进行测试：
测试输入：
10
12 47 5 8 6 92 45 63 75 38
92
预期输出：
查找成功！
92 是顺序表第6个元素
测试输入：
10
12 47 5 8 6 92 45 63 75 38
93
预期输出：
查找失败！
输入说明
第一行输入顺序表的长度M；
第二行输入顺序表的M个整数；
第三行输入要查找的数据元素的值。
输出说明
第一行输出按照值查找是否成功的提示信息；
如果查找成功，第二行输出查找元素的逻辑序号；如果查找失败，则不输出。
代码如下
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#define INIT_SIZE 5
#define INCREMENT 10
# define OK 1
# define ERROR 0
/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
/* 顺序表类型定义 */
typedef struct
{
ElemType *elem; //存储空间基地址
int length; //当前长度
int listsize; //当前分配的存储容量
}SqList;
void InitList(SqList&L);
int ListInsert(SqList &L,int i,ElemType e);
void ListTraverse(SqList L,void(*vi)(ElemType ) );
int LocateElem(SqList L,ElemType e,int (*compare) (ElemType , ElemType));
int main() //main() function
{
SqList A;
ElemType e;
InitList(A);
int n,i;
// cout<<"Please input the list number ";
cin>>n;
for(i=1;i<=n;i++)
{
cin>>e;
ListInsert(A, i, e);
}
//cout<<"请输入查找的元素："<<endl;
cin>>e;
i=LocateElem(A,e,equals);
if( i )
{
cout<<"查找成功！"<<endl;
output(e);
// cout<<endl;
cout<<"是顺序表第"<<i<<"个元素"<<endl;
}
else
cout<<"查找失败！"<<endl;
}
/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
cin>>s;
}
void output(ElemType s)
{
cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
if(a==b)
return 1;
else
return 0;
}
/*****顺序表的基本操作*****/
void InitList(SqList&L)
{ // 操作结果：构造一个空的顺序线性表L
/********** Begin **********/
L.elem=(ElemType*)malloc( INIT_SIZE*sizeof(ElemType));
if(!L.elem)
return; // 存储分配失败
L.length=0; // 空表长度为0
L.listsize=INIT_SIZE; // 初始存储容量
/********** End **********/
}
int ListInsert(SqList &L,int i,ElemType e)
{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1
// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
/********** Begin **********/
ElemType *newbase,*q,*p;
if(i<1||i>L.length+1) // i值不合法
return 0;
if(L.length>=L.listsize)
{ // 当前存储空间已满，增加分配
if(!(newbase=(ElemType*)realloc(L.elem,(L.listsize+INCREMENT)*sizeof(ElemType))))
return(0); ; // 存储分配失败
L.elem=newbase; // 新基址
L.listsize+= INCREMENT; // 增加存储容量
}
q=L.elem+i-1; // q为插入位置
for(p=L.elem+L.length-1;p>=q;--p) // 插入位置及之后的元素右移
*(p+1)=*p;
*q=e; // 插入e
++L.length; // 表长增1
return 1;
/********** End **********/
}
void ListTraverse(SqList L,void(*vi)(ElemType ) )
{
// 初始条件：顺序线性表L已存在
// 操作结果：依次对L的每个数据元素调用函数vi()输出
/********** Begin **********/
ElemType *p;
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(*p++);
printf("\n");
/********** End **********/
}
int LocateElem(SqList L,ElemType e,int (*equals) (ElemType,ElemType))
{
// 初始条件：顺序表L已存在，compare()是数据元素判定函数(满足为1，否则为0)
// 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
// 若这样的数据元素不存在，则返回值为0。
/********** Begin **********/
int i=1;
ElemType *p=L.elem;
while(i<=L.length){
if(!(*equals)(*p++,e))
++i;
else break;
}
return (i<=L.length) ? i : 0;
/********** End **********/
}
第5关：顺序表的逆置操作
任务描述
本关任务：编写顺序表的逆置操作函数。
测试说明
平台会对你编写的代码进行测试：
测试输入：
10
12 47 5 8 6 92 45 63 75 38
预期输出：
逆置顺序表：
38 75 63 45 92 6 8 5 47 12
输入说明
第一行输入顺序表的长度M；
第二行输入顺序表的M个整数；
输出说明
第一行输出提示信息；
第二行输出逆置后的顺序表。
代码如下
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#define INIT_SIZE 5
#define INCREMENT 10
# define OK 1
# define ERROR 0
/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
/* 顺序表类型定义 */
typedef struct
{
ElemType *elem; //存储空间基地址
int length; //当前长度
int listsize; //当前分配的存储容量
}SqList;
void InitList(SqList&L);
int ListInsert(SqList &L,int i,ElemType e);
void ListTraverse(SqList L,void(*vi)(ElemType ) );
void reverse(SqList &A);
int main() //main() function
{
SqList A;
ElemType e;
InitList(A);
int n,i;
// cout<<"Please input the list number ";
cin>>n;
for(i=1;i<=n;i++)
{
cin>>e;
ListInsert(A, i, e);
}
// ListTraverse(A,output) ;
cout<<"逆置顺序表："<<endl;
reverse(A);
ListTraverse(A,output) ;
}
/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
cin>>s;
}
void output(ElemType s)
{
cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
if(a==b)
return 1;
else
return 0;
}
/*****顺序表的基本操作*****/
void InitList(SqList&L)
{ // 操作结果：构造一个空的顺序线性表L
/********** Begin **********/
L.elem=(ElemType*)malloc( INIT_SIZE*sizeof(ElemType));
if(!L.elem)
return; // 存储分配失败
L.length=0; // 空表长度为0
L.listsize=INIT_SIZE; // 初始存储容量
/********** End **********/
}
int ListInsert(SqList &L,int i,ElemType e)
{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1
// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
/********** Begin **********/
ElemType *newbase,*q,*p;
if(i<1||i>L.length+1) // i值不合法
return 0;
if(L.length>=L.listsize)
{ // 当前存储空间已满，增加分配
if(!(newbase=(ElemType*)realloc(L.elem,(L.listsize+INCREMENT)*sizeof(ElemType))))
return(0); ; // 存储分配失败
L.elem=newbase; // 新基址
L.listsize+= INCREMENT; // 增加存储容量
}
q=L.elem+i-1; // q为插入位置
for(p=L.elem+L.length-1;p>=q;--p) // 插入位置及之后的元素右移
*(p+1)=*p;
*q=e; // 插入e
++L.length; // 表长增1
return 1;
/********** End **********/
}
void ListTraverse(SqList L,void(*vi)(ElemType ) )
{
// 初始条件：顺序线性表L已存在
// 操作结果：依次对L的每个数据元素调用函数vi()输出
/********** Begin **********/
ElemType *p;
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(*p++);
printf("\n");
/********** End **********/
}
/********** 定义 void reverse(SqList &A)函数**********/
void reverse(SqList &A)
{
/********** Begin **********/
ElemType p;
int i,j;
for(i=0;i<A.length/2;i++){
p=A.elem[i];
A.elem[i]=A.elem[A.length-i-1];
A.elem[A.length-i-1]=p;
}
/********** End **********/
}
第6关：两个有序顺序表的合并操作
任务描述
本关任务：分别输入两个有序的整数序列（分别包含M和N个数据），建立两个有序顺序表，编写将这两个有序顺序表合并成为一个大的有序顺序表的合并操作函数。
测试说明
平台会对你编写的代码进行测试：
测试输入：
5
10 15 20 25 30
6
12 22 32 42 52 62
输入说明
第一行输入有序表A的长度M；
第二行依次输入有序表A的M个有序的整数；
第三行输入有序表B的长度N；
第四行依次输入有序表B的N个有序的整数。
预期输出：
合并两个有序顺序表：
10 12 15 20 22 25 30 32 42 52 62
输出说明
第一行输出提示信息；
第二行输出合并后的有序顺序表所包含的M+N个有序的整数。
代码如下
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#define INIT_SIZE 5
#define INCREMENT 10
/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
/* 顺序表类型定义 */
typedef struct
{
ElemType *elem; //存储空间基地址
int length; //当前长度
int listsize; //当前分配的存储容量
}SqList;
void InitList(SqList&L);
int ListInsert(SqList &L,int i,ElemType e);
void ListTraverse(SqList L,void(*vi)(ElemType ) );
int MergeList(SqList La, SqList Lb, SqList &Lc) ;
int main() //main() function
{
SqList A,B,C;
ElemType e;
InitList(A);
InitList(B);
int n,i;
// cout<<"Please input the list number ";
cin>>n;
for(i=1;i<=n;i++)
{
cin>>e;
ListInsert(A, i, e);
}
cin>>n;
for(i=1;i<=n;i++)
{
cin>>e;
ListInsert(B, i, e);
}
cout<<"合并两个有序顺序表："<<endl;
MergeList(A,B,C);
ListTraverse(C,output) ;
}
/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
cin>>s;
}
void output(ElemType s)
{
cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
if(a==b)
return 1;
else
return 0;
}
/*****顺序表的基本操作*****/
void InitList(SqList&L)
{ // 操作结果：构造一个空的顺序线性表L
/********** Begin **********/
L.elem=(ElemType*)malloc( INIT_SIZE*sizeof(ElemType));
if(!L.elem)
return; // 存储分配失败
L.length=0; // 空表长度为0
L.listsize=INIT_SIZE; // 初始存储容量
/********** End **********/
}
int ListInsert(SqList &L,int i,ElemType e)
{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1
// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
/********** Begin **********/
ElemType *newbase,*q,*p;
if(i<1||i>L.length+1) // i值不合法
return 0;
if(L.length>=L.listsize)
{ // 当前存储空间已满，增加分配
if(!(newbase=(ElemType*)realloc(L.elem,(L.listsize+INCREMENT)*sizeof(ElemType))))
return(0); ; // 存储分配失败
L.elem=newbase; // 新基址
L.listsize+= INCREMENT; // 增加存储容量
}
q=L.elem+i-1; // q为插入位置
for(p=L.elem+L.length-1;p>=q;--p) // 插入位置及之后的元素右移
*(p+1)=*p;
*q=e; // 插入e
++L.length; // 表长增1
return 1;
/********** End **********/
}
void ListTraverse(SqList L,void(*vi)(ElemType ) )
{
// 初始条件：顺序线性表L已存在
// 操作结果：依次对L的每个数据元素调用函数vi()输出
/********** Begin **********/
ElemType *p;
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(*p++);
printf("\n");
/********** End **********/
}
int MergeList(SqList La, SqList Lb, SqList &Lc)
{
// 已知顺序线性表La和Lb的元素按值非递减排列。
// 归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列。
/********** Begin **********/
ElemType *pa=La.elem;
ElemType *pb=Lb.elem;
Lc.listsize=Lc.length=La.length+Lb.length;
ElemType *pc=Lc.elem=(ElemType *)malloc(Lc.listsize * sizeof(ElemType));
if(!Lc.elem) exit(-1);
ElemType *pa_last=La.elem+La.length-1;
ElemType *pb_last=Lb.elem+Lb.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++;
/********** End **********/
}
开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！
更多推荐
7
0- 0
已为社区贡献6条内容
所有评论(0)