算法与数据结构--实现线性表的合并操作（合并后按非递减排列）

/*
文件名称：实现线性表的合并操作（合并后按非递减排列）

*/

#include <bits/stdc++.h>  
  
using namespace std;  
  
#define LIST_INIT_SIZE    100   //线性表存储空间的初始分配量  
  
#define LISTINCREMENT   10  //线性表存储空间的分配增量  
  
typedef int ElemType;      //定义别名  
  
typedef int Status;      //定义别名  
  
typedef struct{  
    ElemType *elem;     //存储空间基址  
    int length;     //当前长度  
    int listsize;       //当前分配的存储容量（以sizeof(ElemType)为单位）  
}SqList;  
  
  
Status InitList_Sq(SqList &L){  
    //构造一个空的线性表L  
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));  
    if(!L.elem)  
        exit(1);        //存储分配失败,z正常退出  
    L.length = 0;       //空表长度为0  
    L.listsize = LIST_INIT_SIZE;        //初始存储容量  
    return true;  
}  
  
Status ListInsert_Sq(SqList &L,int i,ElemType e)  
{  
    //在顺序线性表L中第i个位置之前插入新的元素e  
    //i的合法值为1<=i<=ListLength_Sq(L)+1  
    if(i <1 || i> L.length + 1)  
        return false;   //i值不合法  
    if(L.length >= L.listsize)   //当前存储空间已满，增加分配  
    {  
        ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + LISTINCREMENT )* sizeof(ElemType));  
        if(!newbase)  
            exit(1);    //存储分配失败  
        L.elem = newbase;//新基址  
        L.listsize += LISTINCREMENT;    //增加存储容量  
    }  
      
    ElemType *q = &(L.elem[i-1]);//q为插入位置  
      
    for(ElemType *p = &(L.elem[L.length-1]);p>=q;--p)  
        *(p+1) = *p;    //插入位置及之后的元素右移  
      
    *q = e;     //插入e  
    ++L.length;     //表长增1  
    return true;  
}  
  
Status ListDelete_Sq(SqList &L,int i)  
{  
    //在顺序线性表L中删除第i个元素，并用e返回其值  
    //i的合法值为 1<= i<=ListLength_Sq(L)  
    if((i<1)||(i>L.length))  
        return false;   //i值不合法  
    ElemType *p = &(L.elem[i-1]);   //p为被删除元素的位置  
    ElemType e = *p;    //被删除元素的值赋值给e  
    ElemType *q = L.elem + L.length-1;  //表尾元素的位置  
    for(++p;p<=q;++p)      
        *(p-1) = *p;    //被删除元素之后的元素左移  
    --L.length; //表长减1  
    return e;  
}  
  
  
Status compare(ElemType e1,ElemType e2)  
{  
    if(e1==e2)  
        return true;  
    return false;  
  
}  
  
int LocateElem_sq(SqList L,ElemType e,Status (*compare)(ElemType,ElemType))  
{  
    //在顺序线性表L中查找第1个值与e满足compare()的元素的为序  
    //若找到，则返回其在L中的位序，否则返回0  
    int i = 1;//i的初值为第1个元素的位序  
    ElemType *p = L.elem;       //p的初值为为第1个元素的存储位置  
    while(i<=L.length &&!(*compare)(*p++,e))  
    {  
        ++i;  
    }  
    if(i<=L.length)  
    {  
        return i;  
    }  
    else   
    {  
        return 0;  
    }  
}  
  
void input(SqList L)  
{  
    int i = 1;//i的初值为第1个元素的位序  
    ElemType *p = L.elem;       //p的初值为为第1个元素的存储位置  
    while(i<=L.length)  
    {  
        cout<<*(p++)<<"    ";  
        ++i;  
    }  
    cout<<endl;  
}  
  
void MergeList_Sq(SqList La,SqList Lb,SqList &Lc)  
{  
    //已知顺序线性表La和Lb的元素按值非递减排列  
    //归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列  
    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)//插入La的剩余元素  
    {  
        *pc++=*pa++;  
    }  
    while(pb<=pb_last)//插入Lb的剩余元素  
    {  
        *pc++=*pb++;  
    }  
}  
  
int main()  
{  
    SqList La,Lb,Lc;  
    InitList_Sq(La);  
    InitList_Sq(Lb);  
    InitList_Sq(Lc);  
    ListInsert_Sq(La,1,2);//在顺序线性表L中第i个位置之前插入新的元素e  
    ListInsert_Sq(La,2,3);//在顺序线性表L中第i个位置之前插入新的元素e  
    ListInsert_Sq(La,3,4);//在顺序线性表L中第i个位置之前插入新的元素e  
    ListInsert_Sq(La,4,5);//在顺序线性表L中第i个位置之前插入新的元素e  
    ListInsert_Sq(Lb,1,6);//在顺序线性表L中第i个位置之前插入新的元素e  
    ListInsert_Sq(Lb,2,7);//在顺序线性表L中第i个位置之前插入新的元素e  
    ListInsert_Sq(Lb,3,8);//在顺序线性表L中第i个位置之前插入新的元素e  
    ListInsert_Sq(Lb,4,9);//在顺序线性表L中第i个位置之前插入新的元素e  
    //ListInsert_Sq(Lc,1,2);//在顺序线性表L中第i个位置之前插入新的元素e  
    //ListInsert_Sq(Lc,2,3);//在顺序线性表L中第i个位置之前插入新的元素e  
    //ListInsert_Sq(Lc,3,4);//在顺序线性表L中第i个位置之前插入新的元素e  
    //ListInsert_Sq(Lc,4,5);//在顺序线性表L中第i个位置之前插入新的元素e  
    //ElemType e = ListDelete_Sq(La,1);  
    cout<<"线性表中La的所有元素为：";  
    input(La);  
    cout<<"线性表中Lb的所有元素为：";  
    input(Lb);  
    //int e = LocateElem_sq(La,3,(*compare));//在顺序线性表L中查找第1个值与e满足compare()的元素的为序  
    //cout<<"线性表中与3相等的元素的位序为："<<e<<endl;  
    cout<<"La与Lb合并后，线性表中Lc的所有元素为："<<endl;  
    MergeList_Sq(La,Lb,Lc);  
    input(Lc);  
    system("PAUSE");  
    return 0;  
}