用线性表实现顺序表的操作并且合并两个顺序表

源码：

#include <stdio.h>
#include <stdlib.h>
#define InitSize 5     //默认的最大长度
typedef char DataType; //定义DataType的数据类型
typedef struct
{
    DataType *data; //指示动态分配数组的指针
    int MaxSize;    //顺序表的最大容量
    int length;     //顺序表当前长度
} SeqList;

void ListInitiate(SeqList *L);                       //初始化顺序表
int ListLength(SeqList L);                           //数组当前长度
void IncreaseSize(SeqList *L, int len);              //动态开辟内存空间
int ListInsert(SeqList *L, DataType x);              //插入数据元素
int ListDelete(SeqList *L, DataType *x, int i);      //删除数据元素
int ListGet(SeqList L, DataType *x, int i);          //取数据元素
void ListMerge(SeqList L1, SeqList L2, SeqList *L3); //合并有序函数

//主函数
int main()
{
    SeqList List;        //定义顺序表
    ListInitiate(&List); //调用初始化顺序表函数--ListInitiate(SeqList *L)
    DataType x;
    int i;
    printf("请输入要插入的数据(字符型):");
    char ch = getchar();
    while (ch != '\n')
    {
        ListInsert(&List, ch);
        ch = getchar();
    }
    printf("\n输入要删除的数据的下标:");
    scanf("%d", &i);
    ListDelete(&List, &x, i);
    printf("删除的数据为:%c\n\n", x);
    //遍历数组，获取数据元素
    for (i = 0; i < List.length; i++)
    {
        ListGet(List, &x, i);
        printf("%c ", x);
    }
    printf("\n\n");

    //创建有序列表L1
    SeqList L1;
    ListInitiate(&L1);
    printf("请输入有序列表L1的数据(字符型):");
    ch = getchar(); //吃掉回车字符
    ch = getchar();
    while (ch != '\n')
    {
        ListInsert(&L1, ch);
        ch = getchar();
    }
    //创建有序列表L2
    SeqList L2;
    ListInitiate(&L2);
    printf("请输入有序列表L2的数据(字符型):");
    ch = getchar();
    while (ch != '\n')
    {
        ListInsert(&L2, ch);
        ch = getchar();
    }
    ch = getchar();
    // L1与L2合并到L3中
    SeqList *L3;
    ListInitiate(L3); //初始化L3
    ListMerge(L1, L2, L3);
    printf("L1和L2合并:");
    for (i = 0; i < L3->length; i++)
    {
        ListGet(*L3, &x, i);
        printf("%c ", x);
    }
    printf("\n\n");
    return 0;
}

//初始化顺序表
void ListInitiate(SeqList *L)
{
    L->length = 0;                                             //将顺序表当前长度设为0
    L->data = (DataType *)malloc(sizeof(DataType) * InitSize); //动态分配 InitSize 个连续的存储空间
    L->MaxSize = InitSize;                                     //顺序表当前最大容量为 InitSize
}

//数据元素个数
int ListLength(SeqList L)
{
    return L.length;
}

//动态开辟内存空间
void IncreaseSize(SeqList *L, int len)
{
    DataType *p = L->data; //定义*p指向原来*data的内存空间
    L->data = (DataType *)malloc(sizeof(DataType) * (len + InitSize));
    for (int i = 0; i < L->length; i++)
        L->data[i] = p[i]; //将数据复制到新区域
    L->MaxSize += len;     //顺序表最大容量增加len
    free(p);               //释放原来的内存空间
}

//插入数据元素
int ListInsert(SeqList *L, DataType x)
{
    if (L->length == L->MaxSize)
    {
        IncreaseSize(L, InitSize);
    }
    L->data[L->length] = x;
    L->length++;
    return 1;
}

//删除数据元素
int ListDelete(SeqList *L, DataType *x, int i)
{
    if (i < 0 || i >= L->length)
    {
        printf("参数i不合法！！！\n");
        return 0;
    }
    *x = L->data[i];
    for (int j = i; j < L->length - 1; j++)
    {
        L->data[j] = L->data[j + 1];
    }
    L->length--;
    return 1;
}

//取数据元素
int ListGet(SeqList L, DataType *x, int i)
{
    if (i < 0 || i >= L.length)
    {
        printf("参数i不合法！！！\n");
        return 0;
    }
    *x = L.data[i];
    return 1;
}
//合并有序函数
void ListMerge(SeqList L1, SeqList L2, SeqList *L3)
{
    DataType x;
    int i = 0, j = 0;
    //遍历L1和L2的元素
    while (i < L1.length || j < L2.length)
    {
        //当L1和L2的数据都没遍历完
        if (i < L1.length && j < L2.length)
        {
            if (L1.data[i] == L2.data[j])
            {
                ListInsert(L3, L1.data[i]);
                i++;
                j++;
            }
            else if (L1.data[i] < L2.data[j])
            {
                ListInsert(L3, L1.data[i]);
                i++;
            }
            else if (L1.data[i] > L2.data[j])
            {
                ListInsert(L3, L2.data[j]);
                j++;
            }
        }
        //当L1遍历完了，L2还没遍历完
        else if (i == L1.length && j < L2.length)
        {
            ListInsert(L3, L2.data[j]);
            j++;
        }
        //当L2遍历完了，L1还没遍历完
        else if (i < L1.length && j == L2.length)
        {
            ListInsert(L3, L1.data[i]);
            i++;
        }
    }
}

结果：