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

最新推荐文章于 2022-06-28 17:27:00 发布
最新推荐文章于 2022-06-28 17:27:00 发布
阅读量1.7k 收藏 7
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 线性表 算法 C++ 实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuyuntan/article/details/50868386
版权

算法2.1

假设利用两个线性表 LA 和 LB 分别表示两个集合 A 和B（即线性表中的数据元素即为集合中的成员，现要求一个新的计划 A=A⋃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 中的数据元素仍按值非递减有序排列。
例如，设

LA=(3,5,8,11)

LB=(2,6,8,9,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≤b时)b当(a>b时)

显然，指针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;
}

运行结果

这里写图片描述

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

YuYunTan
关注
专栏目录
数据结构（C++版）——线性表顺序存储结构的实现
qq_36248929的博客
04-05 592
线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据结构，可以用一维数组来实现顺序存储结构。 描述这样一个数组需要三个属性，一个是数组本身，data[]；一个是线性表的最大存储容量，即在内存中给这块内容安排多大的空间；还有一个是线性表的当前长度。 顺序表的存取很简单，只需要读取位置对应的数组值即可，需要注意的是线性表是从1开始的，数组是从0开始的，读取第i个位置的值实际读取的是...
[数据结构1]线性表的顺序表C++实现
Raften的博客
11-17 831
本顺序表一开始没有存放数据，需要使用insert函数自行插入 以下代码 // 线性表的顺序表实现 // @data:2021/11/17 // @author:Raften #include <bits/stdc++.h> #include <iterator> using namespace std; #define MAXSIZE 500 // X作为int类型 struct ElemType { int x; }; // 线性表结构体 struct List {
数据结构C++实现线性表之顺序表
qq_58240448的博客
06-28 311
使用C++来实现的顺序表。
数据结构学习：C++实现线性表的顺序存储结构
每天进步一点点
09-24 976
提要：这是我新开的一个专栏（数据结构学习） 很多的数据结构的书籍都是以C为基础实现的，主要是由于C强大的指针功能，我本人看的也是C语言版本，但是我是用C++实现的。建议以后想要学习C++的小伙伴最好也能把数据结构的内容从头至尾自己都实现一遍，不管用什么语言，因为数据结构在以后找工作的时候是必问知识 这是本专栏的第一篇内容 介绍的是线性表的顺序存储结构以及C++实现方法，话不多说，下面就开始的线性表...
c++数据结构：线性表的存储结构——顺序表
chiling_1024的博客
09-17 745
数据结构之线性表--顺序表（顺序存储结构）
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
在《数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx》文档中，作者详细介绍了如何在C++中实现顺序表和单链表的基本操作，并提供了相应的代码示例。本文档适用于C++初学者以及准备期末考试的学生...
数据结构线性表-顺序表（c++、java）.pdf
最新发布
11-12
在线性表中，元素之间存在一对一的逻辑关系，而顺序表则是将这些逻辑上相邻的元素在内存中也保持相邻，通常通过数组实现。顺序表有静态分配和动态分配两种实现方式。 静态分配的顺序表使用一个预先分配好的定长数组...
数据结构之线性表的顺序表示和实现
05-28
以上就是关于“数据结构之线性表的顺序表示和实现”的主要知识点，以及可能的代码实现结构。通过这三个文件，我们可以学习如何在C++中实现一个基本的顺序表，并对其进行操作。这不仅有助于理解数据结构的基础，也为...
c/c++数据结构-线性表-顺序表
04-26
数据结构实验中线性表的顺序表代码，带有详细注释，小白也能看得懂
C/C++编程笔记：数据结构系列——顺序表的实现，内含源码
致力于C语言C++知识分享！
04-07 403
一、原理 1.定义 顺序表是在计算机中以数组形式保存的。 2.特点 在计算机中占用连续的一段内存 一旦声明，空间大小一般不变 二、初始化相关操作 包括： （1）结构体的定义 （2）顺序表的创建 （3）顺序表清空 （4）判断顺序表是否为空 1.结构体定义 即定一个满足顺序表定义的结构体，其中包含 数组、存储长度、总长度。 2.初始化 对顺序表进行初始化，包括分配自定...
C++中如何建立一个顺序表
weixin_34326429的博客
09-25 3168
准备数据 #define MAXLEN 100 //定义顺序表的最大长度 struct DATA { char key[10]; //结点的关键字 char name[20]; int age; }; struct SLType //定义顺序表结构 { DATA ListData[MAXLEN+1];//保存顺序表的结构数组 int ListLen; //顺序表已存...
顺序线性表基本操作（初始化，插入，删除，销毁，清空等等）+简单小例题
qq_42319367的博客
11-08 7565
转专业后，感觉这个数据结构是最吃老本的。。。 写点简单的代码，求各位大神放过，都是小萌新的艰辛泪啊 感觉比较适合像我这样基础差的小萌新 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int #define OK 1 #define ERROR 0 #define Status int #define ...
线性表顺序存储结构C++实现
weixin_43246440的博客
11-03 606
/* * @Description: * @版本: 2.0 * @作者: jianwen * @Date: 2019-10-25 14:44:55 * @LastEditors: jianwen * @LastEditTime: 2019-10-26 15:57:44 */ #include <iostream> using namespace std; #ifndef...
数据结构线性表——顺序表（C/C++(类模板））含代码
蛟~
09-12 1856
总结 就是我个人的学习总结。 线性结构分为线性表（一般），栈、队列、串（特殊），数组（推广） 同一线性表中的数据元素必定是具有相同的特性的，即属于同一数据对象，相邻元素间存在序偶关系。 数据表其实就是一个数据对象，由n(n>=0)个数据元素构成的有限序列 线性表可以分为顺序表和链表 顺序表的特点：可随机存取（类似于数组） //动态分配一维数组表示线性表 #define maxsize 100 //顺序表可以达到的最大长度 struct SqList{ int *elem; //
C++ 线性表之顺序表的构建
qq_29762941的博客
07-22 2124
(一)该顺序表下标从一开始，具有增删查等操作 实现如下: #include&lt;iostream&gt; using namespace std; const int maxSize = 100; class sqlist{ public: sqlist():length(0){} int LocateElem(int x);//查找元素位置 int insert(int ...
数据结构顺序表基本流程
采菊东篱下，Python满乾坤！
11-13 4298
生活中很多事物是有顺序关系的，如班级座位从前到后是按排的顺序，从左到右是按列的顺序，可以很方便的定位到某一个位置，但如果座位是散乱的，就很难定位。 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序
C++实现线性表之顺序表
Vimer.Bai的博客
02-06 644
C++实现数据结构之线性表List.h#ifndef LIST_H #define LIST_H #include <iostream> using namespace std;class List { public: List(int size); //创建线性表 ~List();
C++实现数据结构线性表：顺序表与单链表操作
"该资源是一个关于C++实现数据结构中线性表的教程，主要涵盖了顺序表和单链表的基本操作，包括增删改查，以及如何合并两个有序线性表。提供了完整的C++代码实现，并附有注释。代码已在Dev-C++5.4.0环境下测试通过，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YuYunTan

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值