顺序线性表

#define true    1
#define false   0 
#define ok      1
#define error   0
#define infeasible  -1
#define overflow    -2

#define list_init_size  100
#define list_increment  10

typedef int status;

//elemtype也可以定义为其它类型 
typedef struct{
    char name[20];
    int age;
}elemtype; 
#define key age     //key为排序的的依据 

//typedef顺序线性表类型 
typedef struct {
    elemtype *elem;
    int length;
    int listsize;
}listtype;

// 建一个空的顺序线性表 
status Initlist(listtype &l){
    l.elem =(elemtype*)malloc(list_init_size*sizeof(elemtype));
    if(!l.elem ){
        printf("没有足够空间开辟。\n");
        system("pause"); 
        exit(overflow);      
    }
    l.length=0;
    l.listsize=list_init_size;
    return ok;
}

//释放一个顺序线性表 
status Destroylist(listtype &l){
    if(!l.elem ){
        return error; 
    }
    free(l.elem );
    l.elem=NULL;
    l.length=0;
    l.listsize =0;
    return ok;
}

//重置一个顺序线性表 
status Clearlist(listtype &l){
    if(!l.elem ){
        return error;
    }
    l.length =0;
    return ok;
}

//检查顺序线性表是否为空 
status listEmpty(listtype l){
    if(l.length){                   //l.length=0则执行else 
        return ok;
    }else{
        return error;
    }
}

//测量线性表长度 
status listLength(listtype l,int &n){
    if(!l.elem ){
        return error;
    }
    n=l.length;
    return ok;
}

//取下标i-1的元素并赋给e 
status Getelem(listtype l, int i, elemtype & e){
    if((i<1||i>l.length)||l.length>=l.listsize){  //i值不合法or动态内存已满 
        return error;
    } 
    i--;
    e=l.elem[i];
}

//在顺序线性表中第i-1处插入一个元素e 
status listInsert(listtype &l,int i,elemtype e){
    if((i<1||i>l.length+1)||l.length>=l.listsize){  //i值不合法or动态内存已满 
        return error;
    } 
    i--;
    int j;
    for(j=l.length-1;j>=i;j--){
        l.elem[j+1]=l.elem[j];
    } 
    l.elem[i]=e;
    l.length++;
    return ok;                                   
}

//打印顺序线性表中所有元素 
status listPrint(listtype l){
    if(!l.length){
        return error;
    }
    int i;
    for(i=0;i<=l.length-1;i++){
        printf("\t%s\t\t%d\n",l.elem[i].name,l.elem[i].age); 
        }
    return ok;
}

//顺序线性表升序排序
status Sortlist(listtype &l){
    if(!l.length){
        return error;
    }
    int is_exchanged=1;
    int i,len;
    len=l.length;
    elemtype t;
    while (is_exchanged){
        is_exchanged=0;
        for(i=1;i<=len-1;i++){              //不是i<=len，stulist的下标上界为len-1 
            if(l.elem[i-1].key>l.elem[i].key){
                t=l.elem[i-1];
                l.elem[i-1]=l.elem[i];
                l.elem[i]=t;
                is_exchanged=1;
            }   
        }
    }
    return ok;
}   

//将la和lb升序排列并赋给lc 
status Mergelist(listtype la,listtype lb,listtype &lc){
    int alength, blength,la_point=0,lb_point=0,count=0;
    alength= la.length-1 ;
    blength=lb.length-1 ;
    lc.length =lc.listsize =la.length +lb.length ;
    lc.elem =(elemtype*)malloc(sizeof(elemtype)*lc.listsize );
    if(!lc.elem ) {
        printf("没有足够空间开辟。\n");
        return error; 
    }
    while(la_point<=alength&&lb_point<=blength){
        if(la.elem[la_point].key<=lb.elem[lb_point].key){
            lc.elem[count]=la.elem[la_point];           //
            count++;                                    // 这三句即 lc.elem[count++]=la.elem[la_point++];
            la_point++;                                 //
        }else{
            lc.elem[count]=lb.elem[lb_point];
            count++;
            lb_point++;
        }
    } 
    while(la_point<=alength){                           //插入la的剩余元素 
        lc.elem[count++]=la.elem[la_point++];
    }
    while(lb_point<=blength){                           //插入lb的剩余元素 
        lc.elem[count++]=lb.elem[lb_point++];
    }
    return ok;
}