C++顺序表实现

#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100

typedef int Status;
typedef int ElemType;

typedef struct
{
    
    ElemType* data;
    int length;

}SqList;
Status visit(ElemType e);
Status InitList(SqList& L);
Status EmptyList(SqList L);
int  ListLength(SqList L);
Status GetElem(SqList L, int i, ElemType& e);
int LocateElem(SqList L, ElemType e);
Status ListInsert(SqList& L, int i, ElemType e);
Status ListDelete(SqList& L, int i, ElemType& e);
Status ClearList(SqList& L);
Status ListTravers(SqList L);
void Connect(SqList& La, SqList Lb);
Status MerGeList(SqList La, SqList Lb, SqList& Lc);

Status visit(ElemType e)
{
    cout << e << " ";
    return OK;

}

//初始化顺序表
Status InitList(SqList &L)
{
    L.data = new ElemType[MAXSIZE];
    L.length = 0;
    return OK;
}

//判断顺序表是否为空，如果是空表，返回TRUE，否则返回FALSE
Status EmptyList(SqList L)
{
    if (L.length == 0)
        return TRUE;
    else
        return FALSE;

}

//返回顺序表的长度（元素个数）
int  ListLength(SqList L)
{
    return L.length;
}

//获取第i个元素的值(i不是下标)
Status GetElem(SqList L, int i, ElemType& e)
{
    int length = ListLength(L);
    if (i<1 || i>length)
        return ERROR;

    e = L.data[i - 1];
    return OK;

}

//返回顺序表中元素e的位置，如果顺便表为空，或者元素不存在，返回0
int LocateElem(SqList L, ElemType e)
{
    if (L.length == 0)
        return 0;
    int length = ListLength(L);
    for (int i=0;i<length;i++)
    {
        if (L.data[i] == e)
            return i + 1;
    }
    return 0;
}

//在第i个位置插入元素e，如果插入位置不合理或者顺序表已满，返回ERROR
Status ListInsert(SqList &L,int i,ElemType e)
{
    int length = ListLength(L);
    if (i<1 || i>L.length + 1 || length == MAXSIZE)
        return ERROR;
    for (int j = length - 1; j >= i - 1; j--)
        L.data[j + 1] = L.data[j];
    L.data[i - 1] = e;
    L.length++;
    return OK;

}

//删除第i个位置元素e，如果删除位置不合理或者顺序表为空，返回ERROR
Status ListDelete(SqList &L,int i,ElemType &e)
{
    int length = ListLength(L);
    if (i<1 || i>length || length == 0)
        return ERROR;
    
    e = L.data[i - 1];
    for (int j = i; j <= length - 1; j++)
    {
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    return OK;

}

//清空顺序表
Status ClearList(SqList &L)
{
    ElemType e;
    int length = ListLength(L);
    for (int i = 1; i <= length; i++)
        ListDelete(L, 1, e);

    L.length = 0;
    return OK;

}

//遍历顺序表
Status ListTravers(SqList L)
{
    ElemType e;
    int length = ListLength(L);
    for (int i = 1; i <= length; i++)
    {
        /*visit(L.data[i - 1]);*/
        GetElem(L, i, e);
        visit(e);
    }
    cout << endl;
    return OK;

}

//接下来就是顺序表玩具了

//对比La顺序表和Lb顺序表，在Lb顺序表中查找不是La顺序表的元素，插入到La顺序表的末尾
void Connect(SqList& La, SqList Lb)
{
    ElemType e;
    int La_len, Lb_len;
    La_len = ListLength(La);
    Lb_len = ListLength(Lb);

    for (int i = 1; i <= Lb_len; i++)
    {
        GetElem(Lb, i, e);
        if (!LocateElem(La, e))
        {
            ListInsert(La, ++La_len, e);
        }    
    }
    

}

//顺序表La，Lb都为升序排列，对比顺序表La和Lb，依次将最小的元素插入到新的顺序表Lc
Status MerGeList(SqList La, SqList Lb, SqList& Lc)
{
    ElemType* pa, * pb, * pc, * pa_last, * pb_last;
    Lc.length = La.length + Lb.length;
    Lc.data = new ElemType[Lc.length]; //堆区申请一个新数组，长度为Lc.length
    pa = La.data;  //指针pa指向顺序表pa首元素
    pb = Lb.data; //指针pb指向顺序表pb首元素
    pc = Lc.data; //指针pc指向顺序表pc首元素

    //指针pa_last指向顺序表La最后一个元素
    pa_last = La.data + La.length - 1;
    //指针pb_last指向顺序表Lb最后一个元素
    pb_last = Lb.data + Lb.length - 1;

    while (pa <= pa_last && pb <= pb_last)
    {
        if (*pa <= *pb)
            *pc++ = *pa++;
        else
            *pc++ = *pb++;
    }
    while (pa <= pa_last)
    {
        *pc++ = *pa++;
    }
    while(pb<=pb_last)
    {
        *pc++ = *pb++;
    }
    return OK;

}

int main()
{
    SqList L;
    SqList Lb;
    SqList Lc;
    ElemType e;
    Status i;
    int j, k;
    i = InitList(L);
    cout << "初始化L后：L.length=" << L.length << endl;
    for (j = 1; j <= 5; j++)
    {
        i = ListInsert(L, 1, j);
    }
    cout << "在L的表头依次插入1～5后：L.data=";
    ListTravers(L);
    cout << "L.length=" << L.length << endl;
    i = EmptyList(L);
    cout << "L是否空：(1:是 0:否)" << i << endl;
    i = ClearList(L);
    cout << "清空L后：L.length=" << L.length << endl;

    i = EmptyList(L);
    cout << "L是否空：(1:是 0:否)" << i << endl;

    for (j = 1; j <= 10; j++)
    {
        ListInsert(L, j, j);

    }
    cout << "在L的表尾依次插入1～10后：L.data=";
    ListTravers(L);

    cout << "L.length=" << L.length << endl;
    ListInsert(L, 1, 0);

    cout << "在L的表头插入0后:L.data=";
    ListTravers(L);

    cout << "L.length=" << L.length << endl;

    GetElem(L, 5, e);
    cout << "第5个元素的值为：" << e << endl;

    for (j = 3; j <= 4; j++)
    {
        k = LocateElem(L, j);
        if (k)
        {
            cout << "第" << k << "个元素的值为" << j << endl;
        }
        else
        {
            cout << "没有值为" << j << "的元素" << endl;
        }
    }
    k = ListLength(L);
    for (j = k + 1; j >= k; j--)
    {
        i = ListDelete(L, j, e);
        if (i == ERROR)
        {
            cout << "删除第" << j << "个元素失败" << endl;
        }
        else
        {
            cout << "删除第" << j << "个元素为" << e << endl;
        }

    }
    cout << "依次输出L的元素：";
    ListTravers(L);

    j = 5;
    ListDelete(L, j, e);
    cout << "删除第" << j << "个元素为" << e << endl;

    cout << "依次输出L的元素：";
    ListTravers(L);

    i = InitList(Lb);
    for (j = 6; j <= 15; j++)
    {
        i = ListInsert(Lb, 1, j);
    }
    Connect(L, Lb);
    cout << "依次输出合并了Lb的L的元素：";
    ListTravers(L);

    ClearList(L);
    ClearList(Lb);

    ListInsert(L, 1, 1);
    ListInsert(L, 2, 3);
    ListInsert(L, 3, 5);
    cout << "L=";
    ListTravers(L);

    ListInsert(Lb, 1, 2);
    ListInsert(Lb, 2, 4);
    ListInsert(Lb, 3, 6);
    ListInsert(Lb, 4, 8);
    ListInsert(Lb, 5, 10);
    cout << "Lb=";
    ListTravers(Lb);

    InitList(Lc);
    MerGeList(L, Lb, Lc);
    cout << "依次输出有序合并L,Lb后的Lc的元素：";
    ListTravers(Lc);

    return 0;
}