顺序线性表的实现

SqList.h

//函数结果状态代码
#define    TRUE    1
#define    FALSE    0
#define    OK        1
#define    ERROR    0
#define    INFEASIBLE    -1
#define    OVERFLOW    -2
//Status是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef int ElemType;


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

typedef struct{
    ElemType    *elem;            //存储空间基址
    int            length;            //当前长度
    int            listsize;        //当前分配的存储容量（以sizeof(ElemType)为单位）
}SqList;

Status InitList_Sq(SqList &L){
    //构造一个空的线性表L。
    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;
}//InitList_Sq

Status ListInsert_Sq(SqList &L,int i,ElemType e){
    int *newbase,*q,*p;
    if(i<1||i>L.length+1)    return ERROR;        //i值不合法
    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;            //表增长
    return OK;
}//InitList_Sq

Status ListDelete_Sq(SqList &L,int i,ElemType &e){
    //在顺序线性表L中删除第i个元素，并用e返回其值
    //i的合法值为1<=i<=ListLength_Sq(L)
    int *p,*q;
    if((i<1)||(i>L.length))    return ERROR;    //i值不合法
    p=&(L.elem[i-1]);                        //p为被删除元素的位置
    e=*p;                                    //被删除元素的值赋给e
    q=L.elem+L.length-1;                    //表尾元素的位置
    for(++p;p<=q;++p)    *(p-1)=*p;            //被删除元素之后的元素左移
    --L.length;                                //表长减1
    return OK;
}//ListDelete_Sq

int LocateElem_Sq(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)){
    //在顺序线性表L中查找第1个值与e满足compare()的元素的位序
    //若找到，则返回其在L中得位序，否则返回0
    int i=1;
    int *p=L.elem;
    while(i<=L.length && !(*compare)(*p++,e))    ++i;
    if(i<=L.length)    return i;
    else    return 0;
}//LocateElem_Sq

int Compare_Sq(ElemType e1,ElemType e2){
    //比较两个ElemType类型的元素是否相等。相等返回1，否则返回-1。
    if(e1==e2)    
        return 1;
    else    
        return 0;
}//Compare_Sq

void MergeList_Sq(SqList La,SqList Lb,SqList &Lc){
    //已知顺序线性表La和Lb的元素按值非递减排序
    //归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排序
    int *pa,*pb,*pc;
    int *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(!pc)    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_Sq

 

#include "stdafx.h"
#include "stdlib.h"
#include "stdio.h"
#include "malloc.h"

#include "SqList.h"

int main(int argc, char* argv[])
{
    SqList L;
    int s1=123,s2=456;
    int l;

    InitList_Sq(L);
    ListInsert_Sq(L,1,s1);
    ListInsert_Sq(L,2,s2);
    printf("%d\t%d\t",*L.elem,L.elem[0-1]);

    l=LocateElem_Sq(L,*(L.elem+1),Compare_Sq);
    printf("%d\t",l);
    return 0;
}