[数据结构]线性表合并

一、问题描述

线性表合并是程序设计语言编译中的一个最基本的问题，现在有两个线性表LA和LB，其中的元素都是按照非递减有序排列的，要将两个LA和LB归并为一个新的线性表LC，使得LC中的元素仍然是非递减有序的。

本实验的合并方式有两种。第一种是分别取LA和LB的第一个元素，即各自的最小的元素进行比较，选择较小的元素加入LC尾部，然后重复以上步骤；当LA表空了或者LB表空了的时候，将另一个表剩下的元素按照顺序加入LC的尾部，从而保证LC中元素有序。第二种方式是以LA为母表，将LB中的元素向LA中插入，直到LB表空，得到的新的LA表就是最终需要的LC表。

本实验采用线性表实现，采用了链式表示和顺序表示两种实现方式。根据各自的特点，链式表示对应了第二种合并方式，而顺序表示对应了第一种合并方式。

二、数据结构——线性表

1、链式表示：

链式表示的特点是用一组任意的存储单元存储线性表的数据元素，每个元素包括两个域——数据域和指针域。其中数据域是存储数据信息的域，本实验中默认所处理的数据元素都是在整型（int）范围内的数据；指针域中存储一个指针，指向当前元素的下一个元素的地址。n个结点按照如上关系连接起来，形成一个链表，就是线性表的链式表示。

由于链式表示对于数据的插入、删除操作比较方便，而查找一个元素的效率比较低下，于是选择用第二种合并方式，即以LA为母表，将LB中的元素一个一个插入LA中。

首先，每个结点的是一个node型的变量，包含一个int型变量Num和一个node*型的指针变量next。正如上文所描述，Num保存该结点的数值，next保存逻辑上下一个结点的地址。然后定义了一个名叫MyList的类，其中有private型的变量包含线性表自身的基本变量，比如元素个数、首地址等等；还包括public型的线性表的基本操作函数，比如初始化（InitList）、清除（ClearList）、打印(PrintList)等等。

2、顺序表示：

顺序表示是指的用一段地址连续的区域存储一个线性表，用物理存储位置的连续表示线性表的顺序关系。这就要求元素之间维持严格的物理位置关系，在访问变得简单的同时，对线性表的修改操作给线性表的维护带来了很大的麻烦。

由于顺序表示对于数据的操作比较方便，而对线性表的数据进行操作比较麻烦且效率低下，故选择第一种合并方式，即将LA和LB合并到一个新的线性表LC中。

首先，申请一段连续的空间，当空间不够时申请一个更大的空间，再把之前的数据搬过去。基本功能与链式表示基本相同，实现上略有差别。

三、算法的设计和实现

1、第一种合并方式

（1）建立线性表LA和LB，并读入数据。

（2）建立空线性表LC。

（3）分别选取LA中未读过的最小的元素和LB中未读过的最小的元素，进行比较，将较小的元素加入新的线性表LC中，较大元素视作未读过的元素。

（4）重复步骤（2）直到LA或者LB的元素都被读过了。若LA中的元素都被度过了，则将LB中剩下未读的元素按顺序依次添加到LC的尾部；否则，将LA中的剩下未读的元素按顺序依次添加到LC的尾部。

（5）得到的LC就是最终结果。

2、第二种合并方式

（1）建立线性表LA和LB，并读入数据。

（2）用aIndex标记LA中读到元素的位置，将其位置的元素与LB中第一个元素进行比较。

（3）若LA中当前元素较小，则aIndex向后移，重复（2）直到LB为空或者LA到末端；否则将LB中的第一个元素插入LA的当前位置，aIndex向后移，删除LB中的第一个元素，重复（2）直到LB为空或者LA到末端。

（4）若LB为空，则LA已经是最终结果；否则，将LB剩下的元素按顺序依次加入LA的末端，得到最终结果。

四、预期结果和实验中的问题

1、预期结果是程序可以正确地合成两个线性表LA和LB，如LA={1,1,2}，LB={1,2,2,3}，则得到的结果应该是{1,1,1,2,2,2,3}。

2、实际运行中曾遇到的问题：

（1）使用顺序结构表示线性表的时候，可能会出现初始申请的空间不够的情况，需要额外申请一个更大的空间，把之前的元素全部复制过去，然后把之前的空间释放掉。

（2）由于链式表示和顺序表示各有特点，在MyList类中的函数有些细节不一样，比如有两个函数，分别是PriorElem(e,&Pre_e)：若e是L中的元素，则返回e的前躯，以及NextElem(e,&Next_e)：若e是L中的元素，则返回e的后继。由于顺序表示的访问上的便利，我多写了一个函数ElemPos(e,&Pos)：若e是L中的元素，则返回e的位置。借助这个函数，之前两个函数的实现简单了许多。而这对于链式表示是没有太大的必要的。

（3）我第一次写顺序表示的链表时，我的合并函数是每合并一个元素，则将其从原表中删去。而顺序表示在删除数据上的笨拙之处立刻显现出来，时间复杂度变到了O(n^2)，这是非常不明智的。修改之后的实现时间复杂度为O(n)。下面是修改前的合并函数：

void MergeList(MyList La, MyList Lb, MyList &Lc)
{
    int aElem, bElem, cLen = 0;
    Lc.InitList();
    while((!La.ListEmpty()) && (!Lb.ListEmpty()))
    {
        La.GetElem(1, aElem);
        Lb.GetElem(1, bElem);
        if(aElem <= bElem)
        {
            Lc.ListInsert(++cLen, aElem);
            La.ListDelete(1, aElem);
        }
        else
        {
            Lc.ListInsert(++cLen, bElem);
            Lb.ListDelete(1, bElem);
        }
    }
    while(!La.ListEmpty())
    {
        La.ListDelete(1, aElem);
        Lc.ListInsert(++cLen, aElem);
    }
    while(!Lb.ListEmpty())
    {
        Lb.ListDelete(1, bElem);
        Lc.ListInsert(++cLen, bElem);
    }
}

附：c++源代码：

1、第一种合并方式，顺序表示

#include <iostream>
#include <cstdio>
#include <new>

using namespace std;

#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
#define LISTINCREMENT 10 //线性表存储空间的分配增量

class MyList
{
private:
    int *Elem; //存储空间基址
    int Len; //当前元素个数
    int ListSize; //当前分配的储存容量

public:
    void InitList() //构造一个空的线性表
    {
        Elem = new int(LIST_INIT_SIZE);
        Len = 0;
        ListSize = LIST_INIT_SIZE;
    }
    void ClearList() //重置为空表
    {
        delete Elem;
        Len = 0;
    }
    bool ListEmpty() //判断L是否为空表
    {
        return Len == 0;
    }
    int ListLength() //返回L中数据元素个数
    {
        return Len;
    }
    bool GetElem(int Pos, int &RetElem) //返回第Pos个元素，出错返回true
    {
        if(Pos < 1 || Pos > Len)
        {
            printf("Wrong position!
");
            return true;
        }
        RetElem = Elem[Pos - 1];
        return false;
    }
    //LocateElem(L, e, compare()) //返回L中第一个与e满足关系compare()的元素的位序，不存在返回0
    bool ElemPos(int El, int &Pos) //若El是L中的元素，返回e的位置，失败时返回true
    {
        int i;
        for(i = 0; i < Len; i++)
            if(El == Elem[i])
                break;
        if(i < Len)
        {
            Pos = i + 1;
            return false;
        }
        printf("Cannot find the element!
");
        return true;
    }
    bool PriorElem(int El, int &Pre_e) //若El是L中的元素，返回e的前躯，失败时返回true
    {
        int Pos;
        bool flag = ElemPos(El, Pos);
        if(flag)
        {
            printf("Cannot find the element!
");
            return true;
        }
        else
        {
            if(Pos == 1)
            {
                printf("Cannot find the precursor!
");
                return true;
            }
            else
                Pre_e = Elem[Pos - 2];
        }
        return false;
    }
    bool NextElem(int El, int &Next_e) //若El是L中的元素，返回e的后继，错误时返回true
    {
        int Pos;
        bool flag = ElemPos(El, Pos);
        if(flag)
        {
            printf("Cannot find the element!
");
            return true;
        }
        else
        {
            if(Pos == Len)
            {
                printf("Cannot find the successor!
");
                return true;
            }
            Next_e = Elem[Pos];
        }
        return false;
    }
    bool ListInsert(int Pos, int El) //在Pos位置插入元素El，失败时返回true
    {
        if(Pos < 1 || Pos > Len + 1)
        {
            printf("Wrong position!
");
            return true;
        }
        if(Len + 1 > ListSize) //当前存储空间不够，需要增加分配
        {
            int *NewElem = new int(ListSize + LISTINCREMENT);
            int i;
            for(i = 0; i < Len; i++)
                NewElem[i] = Elem[i];
            delete Elem;
            Elem = NewElem;
            ListSize += LISTINCREMENT;
        }
        if(Pos == Len + 1)
            Elem[Pos - 1] = El;
        else
        {
            int i;
            for(i = Len; i > Pos - 1; i--)
                Elem[i] = Elem[i - 1];
            Elem[Pos - 1] = El;
        }
        Len++;
        return false;
    }
    bool ListDelete(int Pos, int &El) //删除Pos位置的元素，用El返回，错误时返回true
    {
        if(Pos < 1 || Pos > Len)
        {
            printf("Wrong position!
");
            return true;
        }
        El = Elem[Pos - 1];
        int i;
        for(i = Pos - 1; i < Len - 1; i++)
            Elem[i] = Elem[i + 1];
        Len--;
        return false;
    }
    void PrintList()
    {
        if(ListEmpty())
        {
            printf("The list is empty!
");
            return ;
        }
        int i;
        for(i = 0; i < Len - 1; i++)
            printf("%d ", Elem[i]);
        printf("%d
", Elem[i]);
    }
};

void Read(MyList &L)
{
    int n, i, Elem;
    L.InitList();
    printf("Please input a number n.
");
    scanf("%d", &n);
    printf("Please input n non-decreasing numbers.
");
    for(i = 1; i <= n; i++)
    {
        scanf("%d", &Elem);
        L.ListInsert(i, Elem);
    }
}

void MergeList(MyList La, MyList Lb, MyList &Lc)
{
    int aElem, bElem, cLen = 0;
    Lc.InitList();
    while((!La.ListEmpty()) && (!Lb.ListEmpty()))
    {
        La.GetElem(1, aElem);
        Lb.GetElem(1, bElem);
        if(aElem <= bElem)
        {
            Lc.ListInsert(++cLen, aElem);
            La.ListDelete(1, aElem);
        }
        else
        {
            Lc.ListInsert(++cLen, bElem);
            Lb.ListDelete(1, bElem);
        }
    }
    while(!La.ListEmpty())
    {
        La.ListDelete(1, aElem);
        Lc.ListInsert(++cLen, aElem);
    }
    while(!Lb.ListEmpty())
    {
        Lb.ListDelete(1, bElem);
        Lc.ListInsert(++cLen, bElem);
    }
}

int main()
{
    MyList La, Lb, Lc;
    Read(La);
    Read(Lb);
    MergeList(La, Lb, Lc);
    Lc.PrintList();
    return 0;
}

1、第二种合并方式，链式表示

#include <iostream>
#include <cstdio>

using namespace std;

struct node
{
    int Num;
    node *next;
};

class MyList
{
private:
    int Len;
    node *pHead;

public:
    void InitList()//构造一个空的线性表
    {
        Len = 0;
        pHead = NULL;
    }
    void ClearList()//重置为空表
    {
        node *Tmp;
        while(pHead)
        {
            Tmp = pHead;
            pHead = pHead -> next;
            delete Tmp;
        }
        Len = 0;
    }
    bool ListEmpty()//判断L是否为空表
    {
        return pHead == NULL;
    }
    int ListLength()//返回L中数据元素个数
    {
        return Len;
    }
    bool GetElem(int Pos, int &e)//返回第Pos个元素，出错返回true
    {
        if(Pos < 1 || Pos > Len)
        {
            printf("Wrong position!
");
            return true;
        }
        node *Cur = pHead;
        int Index = 0;
        while(++Index < Pos && Cur)
            Cur = Cur -> next;
        e = Cur -> Num;
        return false;
    }
    //LocateElem(L, e, compare())//返回L中第一个与e满足关系compare()的元素的位序，不存在返回0
    bool PriorElem(int e, int &Pre_e)//若e是L中的元素，返回e的前躯，失败时返回true
    {
        if(pHead -> Num == e)
        {
            printf("Cannot find the precursor!
");
            return true;
        }
        node *Cur = pHead, *Prev;
        while(Cur)
        {
            if(Cur -> Num == e)
                break;
            Prev = Cur;
            Cur = Cur -> next;
        }
        if(!Cur)
        {
            printf("Cannot find the element!
");
            return true;
        }
        Pre_e = Prev -> Num;
        return false;
    }
    bool NextElem(int e, int &Next_e)//若e是L中的元素，返回e的后继，错误时返回true
    {
        node *Cur = pHead;
        while(Cur)
        {
            if(Cur -> Num == e)
                break;
            Cur = Cur -> next;
        }
        if(!Cur)
        {
            printf("Cannot find the element!
");
            return true;
        }
        Cur = Cur -> next;
        if(!Cur)
        {
            printf("Cannot find the successor!
");
            return true;
        }
        Next_e = Cur -> Num;
        return false;
    }
    bool ListInsert(int Pos, int e)//在Pos位置插入元素e，失败时返回true
    {
        if(Pos < 1 || Pos > Len + 1)
        {
            printf("Wrong position!
");
            return true;
        }
        node *InsElem = new node;
        if(Pos == 1)
        {
            InsElem -> next = pHead;
            pHead = InsElem;
            InsElem -> Num = e;
        }
        else
        {
            node *Cur = pHead;
            int Index = 0;
            while(++Index + 1 < Pos && Cur)
                Cur = Cur -> next;
            InsElem -> next = Cur -> next;
            Cur -> next = InsElem;
            InsElem -> Num = e;
        }
        Len++;
        return false;
    }
    bool ListDelete(int Pos, int &e)//删除Pos位置的元素，用e返回，错误时返回true
    {
        if(Pos < 1 || Pos > Len)
        {
            printf("Wrong position!
");
            return true;
        }
        node *DelElem = pHead;
        if(Pos == 1)
        {
            pHead = DelElem -> next;
            e = DelElem -> Num;
            delete DelElem;
        }
        else
        {
            node *Prev;
            int Index = 0;
            while(++Index < Pos && DelElem)
            {
                Prev = DelElem;
                DelElem = DelElem -> next;
            }
            Prev -> next = DelElem -> next;
            e = DelElem -> Num;
            delete DelElem;
        }
        Len--;
        return false;
    }
    //ListTraverse(L, visit())//依次对L中的每个数据元素调用函数visit()，一旦visit()失败，则操作失败
    void PrintList()
    {
        if(ListEmpty())
        {
            printf("The List is empty!
");
            return ;
        }
        node *Cur = pHead;
        int Index = 0;
        while(++Index < Len && Cur)
        {
            printf("%d ",Cur -> Num);
            Cur = Cur -> next;
        }
        printf("%d
",Cur -> Num);
    }
    bool ElemPrio(node a, node b)
    {
        return a.Num < b.Num;
    }
    void MergeList(MyList Lb) //把Lb插入L中
    {
        int aElem, bElem, aIndex = 0;
        while(aIndex < Len && (!Lb.ListEmpty()))
        {
            GetElem(++aIndex, aElem);
            Lb.GetElem(1, bElem);
            if(aElem > bElem)
            {
                Lb.ListDelete(1, bElem);
                ListInsert(aIndex, bElem);
            }
        }
        while(!Lb.ListEmpty())
        {
            Lb.ListDelete(1, bElem);
            ListInsert(Len + 1, bElem);
        }
    }
};

void Read(MyList &L)
{
    int n, i, Elem;
    L.InitList();
    printf("Please input a number n.
");
    scanf("%d", &n);
    printf("Please input n non-decreasing numbers.
");
    for(i = 1; i <= n; i++)
    {
        scanf("%d", &Elem);
        L.ListInsert(i, Elem);
    }
}

int main()
{
    MyList La, Lb;
    Read(La);
    Read(Lb);
    La.MergeList(Lb);
    La.PrintList();
    return 0;
}