关于顺序表-SDUT OJ 3329 +α

本作品采用知识共享署名-相同方式共享 4.0 国际许可协议进行许可。

问题地址：
http://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Index/problemdetail/pid/3329.html

Problem Description

已知顺序表 A 与 B 是两个有序的顺序表，其中存放的数据元素皆为普通整型，将 A 与 B 表归并为 C 表，要求 C 表包含了 A、B 表里所有元素，并且 C 表仍然保持有序。

Input

输入分为三行：
第一行输入 m、n（1<=m,n<=10000）的值，即为表 A、B 的元素个数；
第二行输入 m 个有序的整数，即为表 A 的每一个元素；
第三行输入 n 个有序的整数，即为表 B 的每一个元素；

Output

输出为一行，即将表 A、B 合并为表 C 后，依次输出表 C 所存放的元素。

简单分析

本题涉及对顺序表的应用，就顺便写一下个人对顺序表的理解。
“顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。”——维基百科 “顺序表” 条目
一个动态的顺序表的存储结构分为三部分：存储空间基址、当前长度、当前分配的存储容量。可以通过指针或下标的方式来访问存储空间中的数据。存储空间中的数据、在物理层面和逻辑层面具有相同的关系。

Show me the code

#include <bits/stdc++.h>
#define ElemType int
#define INIT_SIZE 10001
#define INCR_SIZE 40

using namespace std;



struct node //Struct of list
{
    ElemType *elem;
    int listsize;
    int length;
};

void InitList(node &L);     //Create List
int LocateElem(node &L, ElemType e);    //Find data in list and return position
void ListInsert(node &L, int i, ElemType e);    //insert int e in front of i position in list L
void ListDelete(node &L, int i);     //delete the i-th data of list L
void ListMerge(node &L1, node &L2, node &L3);   //merge list L1 & L2 into L3


int main()
{
    ios_base::sync_with_stdio(false);   //make it faster
    cin.tie(0);
    int m, n;
    node L1, L2, L3;
    InitList(L1);
    InitList(L2);
    InitList(L3);

    while(cin >> m >> n)
    {
        L1.length = 0;       //clear list L1
        L2.length = 0;       //clear list L2
        L3.length = 0;       //clear list L3
        for(int i = 0; i < m; i++)      //store data in list L1
        {
            cin >> L1.elem[i];
            L1.length++;
        }
        for(int i = 0; i < n; i++)      //store data in list L2
        {
            cin >> L2.elem[i];
            L2.length++;
        }
        ListMerge(L1, L2, L3);
        for(int i = 0; i < L3.length - 1; i++)   //the output part
        {
            cout << L3.elem[i] << " ";
        }
        cout << L3.elem[L3.length - 1] << endl;

    }
}

void InitList(node &L)
{

    L.elem = (ElemType*)malloc(INIT_SIZE * sizeof(ElemType));   //allocate memory
    if(!L.elem)     //the case of fail
    {
        cout << "Init Failed" << endl;
        return;
    }


    L.length = 0;               //set length and size
    L.listsize = INIT_SIZE;
    return;

}


int LocateElem(node &L, ElemType e)         //fine the first number bigger than int e
{
    int i = 1;
    ElemType *p;
    p = L.elem;
    while(i <= L.length && !(*(p++) >= e))  //compare
    {
        i++;
    }
    return i;
}

void ListInsert(node &L, int i, ElemType e) //insert int e in front of i-th data of list L
{
    ElemType *newbase, *q, *p;
    if(i < 1 || i > L.length + 1)      //the value of i is illegal
        return;
    if(L.length >= L.listsize) //increase memory
    {
        newbase = (ElemType*)realloc(L.elem , (L.listsize+ INCR_SIZE) * sizeof(ElemType));
        if(!newbase)
            return; //case of failed
        L.elem = newbase; //new address
        L.listsize += INCR_SIZE; //increase max size
    }
    q = L.elem + i - 1;
    for(p = L.elem + L.length - 1; p >= q; p--) //move data after thr position
        *(p+1) = *p;
    *q = e;
    L.length++;
    return;
}

void ListDelete(node &L, int i)     //delete the i-th data of list L
{
    ElemType *p;
    if(i > L.length)    //case of wrong position
    {
        cout<< "WTF" << endl;
        return;
    }
    p = L.elem + i;
    while(i < L.length - 1)      //normal case
    {
        L.elem[i] = L.elem[i + 1];
        i++;
    }
    L.length--;
    return;
}

void ListMerge(node &L1, node &L2, node &L3)
{
    int m = 0, n = 0;
    for(; m < L1.length; m++)
    {
        for(; n < L2.length; n++)
        {
            if(L1.elem[m] < L2.elem[n])
            {
                L3.elem[L3.length++] = L1.elem[m];
                break;
            }
            else
            {
                L3.elem[L3.length++] = L2.elem[n];
            }
        }
        if(n >= L2.length)
        {
            for(; m < L1.length; m++)
            {
                L3.elem[L3.length++] = L1.elem[m];
            }
        }
    }
    for(; n < L2.length; n++)
    {
        L3.elem[L3.length++] = L2.elem[n];
    }
    return;
}