请问怎样实现值非递减排列的顺序线性表？

[ufo36916211]

第一次数据结构作业，写一个主函数，
其中一个要求是实现建立两个元素按值非递减排列的顺序线性表La和Lb，并将它们合并为一个有序顺序表Lc，显示La、Lb和Lc的内容（作业）
Lc的值非递减排列已经实现了，但是怎样才能判断La和Lb的值非递减排列呢？
这是我的代码，麻烦大家帮我看看怎样修改，这个问题该怎样理解？用C++实现。

//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -2
#define OVERFLOW -2
//Status是函数的类型，其值是函数结果状态代码
typedef int Status;

typedef int ElemType; //元素类型定义为整型

#include<iostream.h>
#define LIST_INIT_SIZE 5 //存储空间的初始分配量
#define LISTINCREMENT 3 //存储空间的分配增量

typedef struct Sq{
ElemType *elem; //指向存储空间的基地址
int length; //线性表的当前长度
int listsize; //当前分配的存储容量
}SqList;

Status InitList_Sq(SqList &L) { // 算法2.3
// 构造一个空的线性表L。
L.elem = new(ElemType[LIST_INIT_SIZE*sizeof(ElemType)]);
if (!L.elem) return OVERFLOW; // 存储分配失败
L.length = 0; // 空表长度为0
L.listsize = LIST_INIT_SIZE; // 初始存储容量
return OK;
} // InitList_Sq

Status DestroyList_Sq(SqList &L) {
if (L.elem) delete(L.elem); //释放线性表的存储空间
L.elem=NULL;
return OK;
}//DestroyList_Sq

ElemType *realloc(SqList L) { //再申请LISTINCREMENT个空间
ElemType *p,*q,*r;
p = new(ElemType[(L.listsize+LISTINCREMENT)*sizeof(ElemType)]);
if(!p) return NULL; q=p; r=L.elem;
for(int i=1;i<=L.length;i++) {*q=*r; q++; r++;}
delete L.elem;
return p;
}

Status ListInsert_Sq(SqList &L, int i, ElemType e) { // 算法2.4
// 在顺序线性表L的第i个元素之前插入新的元素e，
// i的合法值为1≤i≤ListLength_Sq(L)+1
ElemType *p;
if (i < 1 || i > L.length+1) return ERROR; // i值不合法
if (L.length >= L.listsize) { // 当前存储空间已满，增加容量
ElemType *newbase = realloc(L);
if (!newbase) return ERROR; // 存储分配失败
L.elem = newbase; // 新基址
L.listsize += LISTINCREMENT; // 增加存储容量
}
ElemType *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 OK;
} // ListInsert_Sq

Status ListDelete_Sq(SqList &L, int i, ElemType &e) { // 算法2.5
// 在顺序线性表L中删除第i个元素，并用e返回其值。
// i的合法值为1≤i≤ListLength_Sq(L)。
ElemType *p, *q;
if (i<1 || i>L.length) return ERROR; // i值不合法
p = &(L.elem[i-1]); // p为被删除元素的位置
e = *p; // 被删除元素的值赋给e
q = L.elem+L.length-1; // 表尾元素的位置
for (++p; p<=q; ++p) *(p-1) = *p; // 被删除元素之后的元素左移
--L.length; // 表长减1
return OK;
} // ListDelete_Sq

int LocateElem_Sq(SqList L, ElemType e) { // 改写算法2.6
// 在顺序线性表L中查找第1个值与e相等的元素的位序。
// 若找到，则返回其在L中的位序，否则返回0。
int i;
ElemType *p;
i = 1; // i的初值为第1个元素的位序
p = L.elem; // p的初值为第1个元素的存储位置
while (i <= L.length && *p++!=e)
++i;
if (i <= L.length) return i;
else return 0;
} // LocateElem_Sq

Status MergeList_Sq(SqList La, SqList Lb, SqList &Lc) { // 算法2.7
// 已知顺序线性表La和Lb的元素按值非递减排列。
// 归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列。
ElemType *pa,*pb,*pc,*pa_last,*pb_last;
//使pa、pb分别指向La和Lb的第一个元素
pa = La.elem; pb = Lb.elem;
//为Lc申请空间
Lc.listsize = Lc.length = La.length+Lb.length;
pc = Lc.elem = new(ElemType[Lc.listsize*sizeof(ElemType)]);
if (!Lc.elem)
return OVERFLOW; // 存储分配失败
//使pa_last、pb_last分别指向La和Lb的最后一个元素
pa_last = La.elem+La.length-1;
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++; // 插入La的剩余元素
while (pb <= pb_last) *pc++ = *pb++; // 插入Lb的剩余元素
return(OK);1;
} // MergeList

void ListTraverse_Sq(SqList L) {
int i;
for(i=1;i<=L.length;i++) cout<<L.elem[i-1]<<" ";
cout<<endl;
}

void main() {
int i; ElemType x;
SqList L;
InitList_Sq(L);
cout<<"读入6个元素并插入到顺序表L中"<<endl;
for(i=1;i<=6;i++) {
cin>>x; ListInsert_Sq(L,i,x);
}
cout<<"顺序表L中所有元素如下:"<<endl;
ListTraverse_Sq(L);
cout<<"L.length="<<L.length<<" L.listsize="<<L.listsize<<endl;
//55插入在位置5
ListInsert_Sq(L,5,55);
cout<<"55插入在位置5之后，顺序表L中所有元素如下："<<endl;
ListTraverse_Sq(L);
cout<<"L.length="<<L.length<<" L.listsize="<<L.listsize<<endl;
//删除第6个元素
ListDelete_Sq(L,6,x);
cout<<"删除第6个元素之后，顺序表L中所有元素如下："<<endl;
ListTraverse_Sq(L);
cout<<"x="<<x<<" L.length="<<L.length<<" L.listsize="<<L.listsize<<endl;
//读入一个元素并在顺序表L中查找它，显示查找结果（作业）
ElemType y;
cout<<"读入一个元素:"<<endl;
cin>>y;
LocateElem_Sq(L,y);
cout<<"在顺序表L中查找它"<<endl;
cout<<"该元素位于顺序表中的位置为："<<endl;
cout<<LocateElem_Sq(L,y)<<endl;


//再建立两个元素按值非递减排列的顺序线性表La和Lb，并将它们合并为一个有序顺序表Lc（作业）
//显示La、Lb和Lc的内容（作业）
SqList La,Lb,Lc; ElemType z1,z2;

InitList_Sq(La);
cout<<"读入3个元素并插入到顺序表La中"<<endl;
for(i=1;i<=3;i++) {
cin>>z1;
ListInsert_Sq(La,i,z1);
}
cout<<"顺序表La中所有元素如下:"<<endl;
ListTraverse_Sq(La);
cout<<"La.length="<<La.length<<" La.listsize="<<La.listsize<<endl;

InitList_Sq(Lb);
cout<<"读入3个元素并插入到顺序表Lb中"<<endl;
for(i=1;i<=3;i++) {
cin>>z2; ListInsert_Sq(Lb,i,z2);
}
cout<<"顺序表Lb中所有元素如下:"<<endl;
ListTraverse_Sq(Lb);
cout<<"Lb.length="<<Lb.length<<" Lb.listsize="<<Lb.listsize<<endl;

MergeList_Sq(La, Lb, Lc);


cout<<"顺序表Lc中所有元素如下:"<<endl;
ListTraverse_Sq(Lc);
cout<<"Lc.length="<<Lc.length<<" Lc.listsize="<<Lc.listsize<<endl;





}

[tianjiao85]

不知道你怎么理解的，
这道题目明显的意思是：
先建立两个非递减的线性表，La，Lb，（就是要写一个实例化这两个表），再将这个两个表合到有序顺序表Lc中，
先用插入排序算法建立两个表，再合并到Lc中。
时间有限，代码就不给了。