数据结构（3）线性表之顺序表C++实现

算法21
- 动态演示
  - 运行结果
算法22
- - 算法实现
  - 运行结果
算法27
- - 算法实现
  - 运行结果

算法2.1

假设利用两个线性表 $LA$ 和 $LB$ 分别表示两个集合 $A$ 和 $B$ （即线性表中的数据元素即为集合中的成员，现要求一个新的计划 $A=A\bigcup B$ ）。这就要求对线性表做如下操作：扩大线性表的LA，将存在于线性表 $LB$ 中而不存在在线性表 $LA$ 中的数据元素插入到线性表 $LA$ 中去。只要从线性表 $LB$ 中依次取得每个数据元素，并依值在线性表 $LA$ 中进行查访，若不存在，则插入之。

动态演示

这里写图片描述
算法如下

void Union(List &La, List Lb) {  // 算法2.1
  // 将所有在线性表Lb中但不在La中的数据元素插入到La中
  int La_len,Lb_len,i;
  ElemType e;
  La_len = ListLength(La);          // 求线性表的长度  
  Lb_len = ListLength(Lb);
  for (i=1; i<=Lb_len; i++) {
    GetElem(Lb, i, e);              // 取Lb中第i个数据元素赋给e
    if (!LocateElem(La, e, equal))  // La中不存在和e相同的数据元素
      ListInsert(La, ++La_len, e);  // 插入
  }
} // union

实现（C++版本非数组版//数组实现较为简单）

//所有定义
#define   LIST_INIT_SIZE        100
#define   LISTINCREMENT         10
#define   OK                    1
#define   ERROR                 0
#define   OVERFLOW             -2
#define   TRUE                  1
#define   FALSE                 0

typedef   int   Status ;//为了方便算法可用性，算法的Status可以通过这里可改
typedef   char   ElemType;//为了输出的可用性，数据的ElemType可以通过这里更改
//数据结构的定义
typedef struct{
    ElemType  *elem;//分配空间基址
    int       length;//当前长度
    int       listsize;//当前分配的存储容量(以sizeof(ElemType)为单位)
}List;
//包含的头文件
#include <iostream>
using namespace std;
void print(ElemType *c)
{
    cout << *c;
}
Status InitList(List *L) /* 算法2.3 */
{ /* 操作结果：构造一个空的顺序线性表 */
    (*L).elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if (!(*L).elem)
        exit(OVERFLOW); /* 存储分配失败 */
    (*L).length = 0; /* 空表长度为0 */
    (*L).listsize = LIST_INIT_SIZE; /* 初始存储容量 */
    return OK;
}
Status ClearList(List *L)
{ /* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
    (*L).length = 0;
    return OK;
}
int ListLength(List L)
{ /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
    return L.length;
}
Status GetElem(List L, int i, ElemType *e)
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
    /* 操作结果：用e返回L中第i个数据元素的值 */
    if (i<1 || i>L.length)
        exit(ERROR);
    *e = *(L.elem + i - 1);
    return OK;
}
int LocateElem(List L, ElemType e, Status(*compare)(ElemType, ElemType))
{ /* 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1,否则为0) */
    /* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */
    /*           若这样的数据元素不存在，则返回值为0。算法2.6 */
    ElemType *p;
    int i = 1; /* i的初值为第1个元素的位序 */
    p = L.elem; /* p的初值为第1个元素的存储位置 */
    while (i <= L.length&&!compare(*p++, e))
        ++i;
    if (i <= L.length)
        return i;
    else
        return 0;
}
Status ListInsert(List *L, int i, ElemType e) /* 算法2.4 */
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
    /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
    ElemType *newbase, *q, *p;
    if (i<1 || i>(*L).length + 1) /* i值不合法 */
        return ERROR;
    if ((*L).length >= (*L).listsize) /* 当前存储空间已满,增加分配 */
    {
        newbase = (ElemType *)realloc((*L).elem,((*L).listsize + LISTINCREMENT)*sizeof(ElemType));

        if (!newbase)
            exit(OVERFLOW); /* 存储分配失败 */
        (*L).elem = newbase; /* 新基址 */
        (*L).listsize += LISTINCREMENT; /* 增加存储容量 */
    }
    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;
}
Status equal(ElemType c1, ElemType c2)
{ /* 判断是否相等的函数，Union()用到 */
    if (c1 == c2)
        return TRUE;
    else
        return FALSE;
}
Status ListTraverse(List L, void(*vi)(ElemType*))
{ /* 初始条件：顺序线性表L已存在 */
    /* 操作结果：依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败 */
    /*           vi()的形参加'&'，表明可通过调用vi()改变元素的值 */
    ElemType *p;
    int i;
    p = L.elem;
    for (i = 1; i <= L.length; i++)
        vi(p++);
    return OK;
}


void Union(List *La, List Lb) /* 算法2.1 */
{ /* 将所有在线性表Lb中但不在La中的数据元素插入到La中 */
    ElemType e;
    int La_len, Lb_len;
    int i;
    La_len = ListLength(*La); /* 求线性表的长度 */
    Lb_len = ListLength(Lb);
    for (i = 1; i <= Lb_len; i++)
    {
        GetElem(Lb, i, &e); /* 取Lb中第i个数据元素赋给e */
        if (!LocateElem(*La, e, equal)) /* La中不存在和e相同的元素,则插入之 */
            ListInsert(La, ++La_len, e);
    }
}

//主函数
int main()
{
    //本程序说明，是在VS2013中运行的，若是其他地方无法运行，建议修改代码
    //程序声明
    cout << "***************************************************************************"<<endl;
    cout << "                   《数据结构》<C语言版本>严蔚敏 吴伟名 编著              "<<endl;
    cout << "                                编写年月2016年3月                         "<<endl;
    cout << "                                 编写者:YuYunTan                          " << endl;
    cout << "                                      算法2.1                             "<<endl;
    cout << "***************************************************************************" << endl;

    //test1
    cout << "Test 1：" << endl;

    //定义A
    List A,B;
    Status return_function_status;
    return_function_status = InitList(&A);
    //判断A空表是否建立成功
    if (return_function_status == OK){
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;
        return_function_status = ERROR;
        //判断B空表是否建立成功
        return_function_status = InitList(&B);
        if (return_function_status == OK)
        {
            cout << "   List B = <";
            ListTraverse(B,print);
            cout << ">"<<endl;
        }


    }
    if (return_function_status == OK){
        //都建立表成功了
        //做测试1
        cout << "   Union(A,B),A=<";
        Union(&A,B);
        ListTraverse(A,print);
        cout << ">"<<endl;
        //做测试2
        cout << "Test 2：" << endl;
        ListInsert(&A, 1,'I');
        ListInsert(&A, 2, 'J');
        ListInsert(&A, 3, 'L');
        ListInsert(&A, 4, 'O');
        ListInsert(&A, 5, 'P');
        ListInsert(&A, 6, 'Q');
        ListInsert(&A, 7, 'R');
        ListInsert(&A, 8, 'S');
        ListInsert(&A, 9, 'U');
        ListInsert(&A, 10, 'V');
        ListInsert(&A, 11, 'X');
        ListInsert(&A, 12, 'Y');
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 'B');
        ListInsert(&B, 2, 'D');
        ListInsert(&B, 3, 'F');
        ListInsert(&B, 4, 'I');
        ListInsert(&B, 5, 'L');
        ListInsert(&B, 6, 'N');
        ListInsert(&B, 7, 'P');
        ListInsert(&B, 8, 'S');
        ListInsert(&B, 9, 'T');
        ListInsert(&B, 10, 'V');
        ListInsert(&B, 11, 'Y');
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Union(A,B),A=<";
        Union(&A, B);
        ListTraverse(A, print);
        cout << ">" << endl;

        //测试3
        ClearList(&A);
        ClearList(&B);
        cout << "Test 3：" << endl;
        ListInsert(&A, 1, 'H');
        ListInsert(&A, 2, 'I');
        ListInsert(&A, 3, 'K');
        ListInsert(&A, 4, 'M');
        ListInsert(&A, 5, 'P');
        ListInsert(&A, 6, 'S');
        ListInsert(&A, 7, 'T');
        ListInsert(&A, 8, 'W');
        ListInsert(&A, 9, 'X');
        ListInsert(&A, 10, 'Y');
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 'A');
        ListInsert(&B, 2, 'D');
        ListInsert(&B, 3, 'F');
        ListInsert(&B, 4, 'I');
        ListInsert(&B, 5, 'J');
        ListInsert(&B, 6, 'L');
        ListInsert(&B, 7, 'N');
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Union(A,B),A=<";
        Union(&A, B);
        ListTraverse(A, print);
        cout << ">" << endl;

        //测试4
        ClearList(&A);
        ClearList(&B);
        cout << "Test 4：" << endl;
        ListInsert(&A, 1, 'F');
        ListInsert(&A, 2, 'H');
        ListInsert(&A, 3, 'K');
        ListInsert(&A, 4, 'N');
        ListInsert(&A, 5, 'O');
        ListInsert(&A, 6, 'P');
        ListInsert(&A, 7, 'R');
        ListInsert(&A, 8, 'S');
        ListInsert(&A, 9, 'U');
        ListInsert(&A, 10, 'V');
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 'H');
        ListInsert(&B, 2, 'I');
        ListInsert(&B, 3, 'J');
        ListInsert(&B, 4, 'M');
        ListInsert(&B, 5, 'P');
        ListInsert(&B, 6, 'R');
        ListInsert(&B, 7, 'T');
        ListInsert(&B, 8, 'U');
        ListInsert(&B, 9, 'W');
        ListInsert(&B, 10, 'Z');
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Union(A,B),A=<";
        Union(&A, B);
        ListTraverse(A, print);
        cout << ">" << endl;


        //测试5
        ClearList(&A);
        ClearList(&B);
        cout << "Test 5：" << endl;
        ListInsert(&A, 1, 'D');
        ListInsert(&A, 2, 'E');
        ListInsert(&A, 3, 'H');
        ListInsert(&A, 4, 'K');
        ListInsert(&A, 5, 'L');
        ListInsert(&A, 6, 'O');
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 'A');
        ListInsert(&B, 2, 'B');
        ListInsert(&B, 3, 'C');
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Union(A,B),A=<";
        Union(&A, B);
        ListTraverse(A, print);
        cout << ">" << endl;
    }
    else{
        cout << "error:don't create List,malloc is fall!";
    }


    system("pause");
    return 0;
}

运行结果:

这里写图片描述

算法2.2

已知线性表 $LA$ 和 $LB$ 中的数据元素按值非递减有序排列，先要求将 $LA$ 和 $LB$ 归并为一个新的线性表 $LC$ ,且 $LC$ 中的数据元素仍按值非递减有序排列。
例如，设

L A = (3, 5, 8, 11)

$LA=(3,5,8,11)$

L B = (2, 6, 8, 9, 11, 15, 20)

$LB=(2,6,8,9,11,15,20)$
则

LC=(2,3,5,6,8,8,9,11,11,15,20) $LC=(2,3,5,6,8,8,9,11,11,15,20)$

思路点拨

LC中的元素或是LA中的数据元素，或是LB中的数据元素，则只要先设LC为空表，然后将LA或LB中的元素逐个插入到LC中即可。为了使得LC中的元素也是按值顺序非递减有序排列，那么我们可以设置两个指针i和j分别指向LA和LB中的某个元素，若设i当前所指的元素为a，j当前所指的元素为b，则当当前应插入到LC中的元素c为

$c = {a 当 (a \leq b 时) b 当 (a > b 时)$ $c=\left \{ ^{a \hspace{1cm}当(a \leq b 时)}_{b\hspace{1cm}当(a > b 时)} \right.$
显然，指针i和j的初值均为1，在所指元素插入LC之后，在LA或LB中顺序后移。上述归并算法如下:

void MergeList(List La, List Lb, List &Lc) {  // 算法2.2
  // 已知线性表La和Lb中的元素按值非递减排列。
  // 归并La和Lb得到新的线性表Lc，Lc的元素也按值非递减排列。
  int La_len, Lb_len;
  ElemType ai, bj;    
  int i=1, j=1, k=0;
  InitList(Lc);
  La_len = ListLength(La);    
  Lb_len = ListLength(Lb);
  while ((i <= La_len) && (j <= Lb_len)) {  // La和Lb均非空
    GetElem(La, i, ai);
    GetElem(Lb, j, bj);
    if (ai <= bj) {
      ListInsert(Lc, ++k, ai);
      ++i;
    } else { 
      ListInsert(Lc, ++k, bj);
      ++j;
    }
  }
  while (i <= La_len) {
    GetElem(La, i++, ai);  ListInsert(Lc, ++k, ai);
  }
  while (j <= Lb_len) {
    GetElem(Lb, j++, bj);  ListInsert(Lc, ++k, bj);
  }
} // MergeList

算法实现

//所有定义
#define   LIST_INIT_SIZE        100
#define   LISTINCREMENT         10
#define   OK                    1
#define   ERROR                 0
#define   OVERFLOW             -2
#define   TRUE                  1
#define   FALSE                 0
typedef   int   Status;//为了方便算法可用性，算法的Status可以通过这里可改
typedef   int   ElemType;//为了输出的可用性，数据的ElemType可以通过这里更改
//数据结构的定义
typedef struct{
    ElemType  *elem;//分配空间基址
    int       length;//当前长度
    int       listsize;//当前分配的存储容量(以sizeof(ElemType)为单位)
}List;
//包含的头文件
#include <iostream>
using namespace std;
void print(ElemType *c)
{
    cout << *c <<" ";
}
Status InitList(List *L) /* 算法2.3 */
{ /* 操作结果：构造一个空的顺序线性表 */
    (*L).elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if (!(*L).elem)
        exit(OVERFLOW); /* 存储分配失败 */
    (*L).length = 0; /* 空表长度为0 */
    (*L).listsize = LIST_INIT_SIZE; /* 初始存储容量 */
    return OK;
}
Status ClearList(List *L)
{ /* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
    (*L).length = 0;
    return OK;
}
int ListLength(List L)
{ /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
    return L.length;
}
Status GetElem(List L, int i, ElemType *e)
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
    /* 操作结果：用e返回L中第i个数据元素的值 */
    if (i<1 || i>L.length)
        exit(ERROR);
    *e = *(L.elem + i - 1);
    return OK;
}
Status ListInsert(List *L, int i, ElemType e) /* 算法2.4 */
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
    /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
    ElemType *newbase, *q, *p;
    if (i<1 || i>(*L).length + 1) /* i值不合法 */
        return ERROR;
    if ((*L).length >= (*L).listsize) /* 当前存储空间已满,增加分配 */
    {
        newbase = (ElemType *)realloc((*L).elem, ((*L).listsize + LISTINCREMENT)*sizeof(ElemType));

        if (!newbase)
            exit(OVERFLOW); /* 存储分配失败 */
        (*L).elem = newbase; /* 新基址 */
        (*L).listsize += LISTINCREMENT; /* 增加存储容量 */
    }
    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;
}
Status ListTraverse(List L, void(*vi)(ElemType*))
{ /* 初始条件：顺序线性表L已存在 */
    /* 操作结果：依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败 */
    /*           vi()的形参加'&'，表明可通过调用vi()改变元素的值 */
    ElemType *p;
    int i;
    p = L.elem;
    cout << " ";
    for (i = 1; i <= L.length; i++)
        vi(p++);
    return OK;
}
void MergeList(List La, List Lb, List *Lc) /* 算法2.2 */
{ /* 已知线性表La和Lb中的数据元素按值非递减排列。 */
    /* 归并La和Lb得到新的线性表Lc,Lc的数据元素也按值非递减排列 */
    int i = 1, j = 1, k = 0;
    int La_len, Lb_len;
    ElemType ai, bj;
    InitList(Lc); /* 创建空表Lc */
    La_len = ListLength(La);
    Lb_len = ListLength(Lb);
    while (i <= La_len&&j <= Lb_len) /* 表La和表Lb均非空 */
    {
        GetElem(La, i, &ai);
        GetElem(Lb, j, &bj);
        if (ai <= bj)
        {
            ListInsert(Lc, ++k, ai);
            ++i;
        }
        else
        {
            ListInsert(Lc, ++k, bj);
            ++j;
        }
    }
    while (i <= La_len) /* 表La非空且表Lb空 */
    {
        GetElem(La, i++, &ai);
        ListInsert(Lc, ++k, ai);
    }
    while (j <= Lb_len) /* 表Lb非空且表La空 */
    {
        GetElem(Lb, j++, &bj);
        ListInsert(Lc, ++k, bj);
    }
}
//主函数
int main()
{
    //本程序说明，是在VS2013中运行的，若是其他地方无法运行，建议修改代码
    //程序声明
    cout << "***************************************************************************" << endl;
    cout << "                   《数据结构》<C语言版本>严蔚敏 吴伟名 编著              " << endl;
    cout << "                                编写年月2016年3月                         " << endl;
    cout << "                                 编写者:YuYunTan                          " << endl;
    cout << "                                      算法2.2                             " << endl;
    cout << "***************************************************************************" << endl;

    //test1
    cout << "Test 1：" << endl;

    //定义A
    List A, B, C;
    Status return_function_status;
    return_function_status = InitList(&A);
    //判断A空表是否建立成功
    if (return_function_status == OK){
        cout << "   List A = <";
        ListInsert(&A, 1, 72);
        ListInsert(&A, 2, 96);
        ListTraverse(A, print);
        cout << ">" << endl;
        return_function_status = ERROR;
        //判断B空表是否建立成功
        return_function_status = InitList(&B);
        if (return_function_status == OK)
        {
            cout << "   List B = <";
            ListInsert(&B, 1, 2);
            ListInsert(&B, 2, 42);
            ListInsert(&B, 3, 51);
            ListInsert(&B, 4, 52);
            ListInsert(&B, 5, 71);
            ListInsert(&B, 6, 72);
            ListInsert(&B, 7, 78);
            ListTraverse(B, print);
            cout << ">" << endl;
        }


    }
    if (return_function_status == OK){
        //都建立表成功了
        //做测试1
        cout << "   Merge(A,B)=<";
        MergeList(A,B,&C);
        ListTraverse(C, print);
        cout << ">" << endl;

        //做测试2
        ClearList(&A);
        ClearList(&B);
        ClearList(&C);
        cout << "Test 2：" << endl;
        ListInsert(&A, 1, 16);
        ListInsert(&A, 2, 24);
        ListInsert(&A, 3, 49);
        ListInsert(&A, 4, 50);
        ListInsert(&A, 5, 58);
        ListInsert(&A, 6, 76);
        ListInsert(&A, 7, 94);
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 94);
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Merge(A,B)=<";
        MergeList(A, B, &C);
        ListTraverse(C, print);
        cout << ">" << endl;

        //测试3
        ClearList(&A);
        ClearList(&B);
        ClearList(&C);
        cout << "Test 3：" << endl;
        ListInsert(&A, 1, 27);
        ListInsert(&A, 2, 44);
        ListInsert(&A, 3, 83);
        ListInsert(&A, 4, 86);
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 23);
        ListInsert(&B, 2, 24);
        ListInsert(&B, 3, 45);
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Merge(A,B)=<";
        MergeList(A, B, &C);
        ListTraverse(C, print);
        cout << ">" << endl;

        //测试4
        ClearList(&A);
        ClearList(&B);
        ClearList(&C);
        cout << "Test 4：" << endl;
        ListInsert(&A, 1, 27);
        ListInsert(&A, 2, 52);
        ListInsert(&A, 3, 54);
        ListInsert(&A, 4, 66);
        ListInsert(&A, 5, 69);
        ListInsert(&A, 6, 79);
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 15);
        ListInsert(&B, 2, 81);
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Merge(A,B)=<";
        MergeList(A, B, &C);
        ListTraverse(C, print);
        cout << ">" << endl;


        //测试5
        ClearList(&A);
        ClearList(&B);
        ClearList(&C);
        cout << "Test 5：" << endl;
        ListInsert(&A, 1, 22);
        ListInsert(&A, 2, 72);
        ListInsert(&A, 3, 75);
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 2);
        ListInsert(&B, 2, 7);
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Merge(A,B)=<";
        MergeList(A, B, &C);
        ListTraverse(C, print);
        cout << ">" << endl;
    }
    else{
        cout << "error:don't create List,malloc is fall!";
    }


    system("pause");
    return 0;
}

运行结果

这里写图片描述

算法2.7

对上述的合并处于复杂度 $O(La.length+Lb.length)$

void 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 = La.elem;  pb = Lb.elem;
  Lc.listsize = Lc.length = La.length+Lb.length;
  pc = Lc.elem = (ElemType *)malloc(Lc.listsize*sizeof(ElemType));
  if (!Lc.elem)
    exit(OVERFLOW);   // 存储分配失败
  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的剩余元素
} // MergeList

算法实现

//所有定义
#define   LIST_INIT_SIZE        100
#define   LISTINCREMENT         10
#define   OK                    1
#define   ERROR                 0
#define   OVERFLOW             -2
#define   TRUE                  1
#define   FALSE                 0
typedef   int   Status;//为了方便算法可用性，算法的Status可以通过这里可改
typedef   int   ElemType;//为了输出的可用性，数据的ElemType可以通过这里更改
//数据结构的定义
typedef struct{
    ElemType  *elem;//分配空间基址
    int       length;//当前长度
    int       listsize;//当前分配的存储容量(以sizeof(ElemType)为单位)
}List;
//包含的头文件
#include <iostream>
using namespace std;
void print(ElemType *c)
{
    cout << *c << " ";
}
Status InitList(List *L) /* 算法2.3 */
{ /* 操作结果：构造一个空的顺序线性表 */
    (*L).elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if (!(*L).elem)
        exit(OVERFLOW); /* 存储分配失败 */
    (*L).length = 0; /* 空表长度为0 */
    (*L).listsize = LIST_INIT_SIZE; /* 初始存储容量 */
    return OK;
}
Status ClearList(List *L)
{ /* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
    (*L).length = 0;
    return OK;
}
int ListLength(List L)
{ /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
    return L.length;
}
Status GetElem(List L, int i, ElemType *e)
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
    /* 操作结果：用e返回L中第i个数据元素的值 */
    if (i<1 || i>L.length)
        exit(ERROR);
    *e = *(L.elem + i - 1);
    return OK;
}
Status ListInsert(List *L, int i, ElemType e) /* 算法2.4 */
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
    /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
    ElemType *newbase, *q, *p;
    if (i<1 || i>(*L).length + 1) /* i值不合法 */
        return ERROR;
    if ((*L).length >= (*L).listsize) /* 当前存储空间已满,增加分配 */
    {
        newbase = (ElemType *)realloc((*L).elem, ((*L).listsize + LISTINCREMENT)*sizeof(ElemType));

        if (!newbase)
            exit(OVERFLOW); /* 存储分配失败 */
        (*L).elem = newbase; /* 新基址 */
        (*L).listsize += LISTINCREMENT; /* 增加存储容量 */
    }
    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;
}
Status ListTraverse(List L, void(*vi)(ElemType*))
{ /* 初始条件：顺序线性表L已存在 */
    /* 操作结果：依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败 */
    /*           vi()的形参加'&'，表明可通过调用vi()改变元素的值 */
    ElemType *p;
    int i;
    p = L.elem;
    cout << " ";
    for (i = 1; i <= L.length; i++)
        vi(p++);
    return OK;
}
void MergeList(List La, List Lb, List *Lc) /* 算法2.7 */
{ /* 已知顺序线性表La和Lb的元素按值非递减排列。 */
    /* 归并La和Lb得到新的顺序线性表Lc,Lc的元素也按值非递减排列 */
    ElemType *pa, *pa_last, *pb, *pb_last, *pc;
    pa = La.elem;
    pb = Lb.elem;
    (*Lc).listsize = (*Lc).length = La.length + Lb.length;/*不用InitList()创建空表Lc */
    pc = (*Lc).elem = (ElemType *)malloc((*Lc).listsize*sizeof(ElemType));
    if (!(*Lc).elem) /* 存储分配失败 */
        exit(OVERFLOW);
    pa_last = La.elem + La.length - 1;
    pb_last = Lb.elem + Lb.length - 1;
    while (pa <= pa_last&&pb <= pb_last) /* 表La和表Lb均非空 */
    { /* 归并 */
        if (*pa <= *pb)
            *pc++ = *pa++;
        else
            *pc++ = *pb++;
    }
    while (pa <= pa_last) /* 表La非空且表Lb空 */
        *pc++ = *pa++; /* 插入La的剩余元素 */
    while (pb <= pb_last) /* 表Lb非空且表La空 */
        *pc++ = *pb++; /* 插入Lb的剩余元素 */
}

//主函数
int main()
{
    //本程序说明，是在VS2013中运行的，若是其他地方无法运行，建议修改代码
    //程序声明
    cout << "***************************************************************************" << endl;
    cout << "                   《数据结构》<C语言版本>严蔚敏 吴伟名 编著              " << endl;
    cout << "                                编写年月2016年3月                         " << endl;
    cout << "                                 编写者:YuYunTan                          " << endl;
    cout << "                                      算法2.7                             " << endl;
    cout << "***************************************************************************" << endl;

    //test1
    cout << "Test 1：" << endl;

    //定义A
    List A, B, C;
    Status return_function_status;
    return_function_status = InitList(&A);
    //判断A空表是否建立成功
    if (return_function_status == OK){
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;
        return_function_status = ERROR;
        //判断B空表是否建立成功
        return_function_status = InitList(&B);
        if (return_function_status == OK)
        {
            cout << "   List B = <";
            ListInsert(&B, 1, 3);
            ListInsert(&B, 2, 33);
            ListTraverse(B, print);
            cout << ">" << endl;
        }


    }
    if (return_function_status == OK){
        //都建立表成功了
        //做测试1
        cout << "   Merge(A,B)=<";
        MergeList(A, B, &C);
        ListTraverse(C, print);
        cout << ">" << endl;

        //做测试2
        ClearList(&A);
        ClearList(&B);
        ClearList(&C);
        cout << "Test 2：" << endl;
        ListInsert(&A, 1, 11);
        ListInsert(&A, 2, 16);
        ListInsert(&A, 3, 17);
        ListInsert(&A, 4, 71);
        ListInsert(&A, 5, 78);
        ListInsert(&A, 6, 92);
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 33);
        ListInsert(&B, 2, 80);
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Merge(A,B)=<";
        MergeList(A, B, &C);
        ListTraverse(C, print);
        cout << ">" << endl;

        //测试3
        ClearList(&A);
        ClearList(&B);
        ClearList(&C);
        cout << "Test 3：" << endl;
        ListInsert(&A, 1, 3);
        ListInsert(&A, 2, 31);
        ListInsert(&A, 3, 41);
        ListInsert(&A, 4, 48);
        ListInsert(&A, 5, 65);
        ListInsert(&A, 6, 95);
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 30);
        ListInsert(&B, 2, 40);
        ListInsert(&B, 3, 46);
        ListInsert(&B, 4, 47);
        ListInsert(&B, 5, 61);
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Merge(A,B)=<";
        MergeList(A, B, &C);
        ListTraverse(C, print);
        cout << ">" << endl;

        //测试4
        ClearList(&A);
        ClearList(&B);
        ClearList(&C);
        cout << "Test 4：" << endl;
        ListInsert(&A, 1, 34);
        ListInsert(&A, 2, 44);
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 6);
        ListInsert(&B, 2, 46);
        ListInsert(&B, 3, 70);
        ListInsert(&B, 4, 78);
        ListInsert(&B, 5, 94);
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Merge(A,B)=<";
        MergeList(A, B, &C);
        ListTraverse(C, print);
        cout << ">" << endl;


        //测试5
        ClearList(&A);
        ClearList(&B);
        ClearList(&C);
        cout << "Test 5：" << endl;
        ListInsert(&A, 1, 25);
        ListInsert(&A, 2, 39);
        ListInsert(&A, 3, 82);
        cout << "   List A = <";
        ListTraverse(A, print);
        cout << ">" << endl;

        ListInsert(&B, 1, 38);
        ListInsert(&B, 2, 96);
        cout << "   List B = <";
        ListTraverse(B, print);
        cout << ">" << endl;

        cout << "   Merge(A,B)=<";
        MergeList(A, B, &C);
        ListTraverse(C, print);
        cout << ">" << endl;
    }
    else{
        cout << "error:don't create List,malloc is fall!";
    }


    system("pause");
    return 0;
}

运行结果

这里写图片描述

到目前为止，书本上三题目均以实现，后面的将是线性表的链式表示和实现~~