数据结构(C语言版)顺序表相关算法代码实现

　　这两天实现了一下顺序表的相关操作，包括顺序表初始化、创建、遍历、第i个元素前插入，删除第i个元素、查找元素e的位置、清空顺序表、销毁顺序表、合并两个非递减顺序表操作。

　　这次在网上学习到了新的布局方法，将顺序表的存储结构定义，函数说明部分放在了头文件里，源文件中实现的是主函数和各功能函数。

　　这次使用的编译环境是vc++6.0

//头文件部分
#define LIST_INIT_SIZE 5
#define INCREAMENT 5
typedef char Elemtype;
typedef int Status;
//线性表存储结构定义
typedef struct {
Elemtype *elem;
int length;
int listsize;
}SqList;
//函数说明部分
Status InitList(SqList &L);
Status CreateList(SqList &L,int size);
Status TraverseList(SqList L);
Status ListInsert(SqList &L,int i,Elemtype e);
Status ListDelete(SqList &L,int i,Elemtype &e);
int LocateElem(SqList L,Elemtype e,Status (*compare)(Elemtype e,Elemtype temp));
Status ClearList(SqList &L);
Status DestroyList(SqList &L);
Status EqualElem(Elemtype e,Elemtype temp);
void MergeList(SqList La,SqList Lb,SqList &Lc);

//源文件部分
#include<stdio.h>
#include <stdlib.h>//malloc函数包含在其中
//将自定义头文件包含进来时只能用""
#include"ListHeader.h"
//程序入口
void main(){
    int size=;
    SqList list;
    Elemtype deletes;
    InitList(list);
    CreateList(list,size);
//    TraverseList(list);
//    ListInsert(list,5,'o');
//    TraverseList(list);
//    ListDelete(list,5,deletes);
//    TraverseList(list);
//    printf("找到符合compare关系的元素位序是：%d\n",LocateElem(list,'b',EqualElem));
//    ClearList(list);
//    TraverseList(list);
//    DestroyList(list);
//    TraverseList(list);
    SqList list2;
    InitList(list2);
    CreateList(list2,);
    SqList list3;
    InitList(list3);
    MergeList(list,list2,list3);
    TraverseList(list3);
    getchar();
}
//初始化一个顺序表
Status InitList(SqList &L){
       //分配内存
    L.elem = (Elemtype *)malloc(LIST_INIT_SIZE*sizeof(Elemtype));
    if(!L.elem){
        return false;
    }
    L.length=;
    L.listsize=LIST_INIT_SIZE;
    return true;
}
//创建顺序表(判断是否需要重新分配内存，将元素读入)
Status CreateList(SqList &L,int size){
    if(size>L.listsize){
        Elemtype *newbase;
        newbase=(Elemtype *)realloc(L.elem ,(L.listsize+INCREAMENT)*sizeof(Elemtype));
        if(!newbase){
            return false;
        }
        L.elem=newbase;
        L.listsize+=INCREAMENT;
        }
    printf("输入创建顺序表内容：\n");
    for(int i=;i<size;i++){
        scanf("%c",L.elem+i);
        getchar();//输入了6个元素，只输入三次就自动结束，因为vc6.0将回车也算进字符里，这里用getchar()接收
    }
    L.length=size;
    return true;
}
//顺序表的遍历，用指针来操作
Status TraverseList(SqList L){
    if(L.length==){
        printf("空表！");
        return false;
    }
    printf("遍历结果：\n");
    for(int i=;i<L.length;i++){
        printf("%c",*(L.elem++));
        printf("\n");
    }
    return true;
}
//顺序表中第i个元素之前插入元素，下标是i-1
Status ListInsert(SqList &L,int i,Elemtype e){
    //非法判断
    if(i<||i>L.length){
        return false;
    }
    if(L.length>=L.listsize){
        Elemtype *newbase;//这里为了更好的判断出空间分配结果，新建一个变量newbase
        newbase=(Elemtype *)realloc(L.elem,(L.listsize+INCREAMENT)*sizeof(Elemtype));
        if(!newbase){
            return false;
        }
        L.listsize+=INCREAMENT;
        }
    Elemtype *itemp,*ttemp;
    itemp=&(L.elem[i-]);
    ttemp=&(L.elem[L.length-]);
    for(ttemp;ttemp>=itemp;ttemp--){
        *(ttemp+)=*ttemp;
        }
    *itemp=e;              //这里的itemp始终指向第i个元素的位置，所以用他赋值较好
    L.length+=;
    return true;
}
//删除顺序表中第i个元素
Status ListDelete(SqList &L,int i,Elemtype &e){
    if(i<||i>L.length){
        return false;
    }
    Elemtype *itemp=&(L.elem[i-]);
    e=*itemp;
    Elemtype *ttemp=&(L.elem[L.length-]);
    for(itemp;itemp<ttemp;itemp++){
        *itemp=*(itemp+);
    }
    L.length--;
    return true;
}
//返回顺序表中第一个与e满足compare()关系的元素位序,不存在返回0
int LocateElem(SqList L,Elemtype e,Status (*compare)(Elemtype e,Elemtype temp)){
    int i=;
    Elemtype *temp=L.elem;
    while(!(*compare)(e,*temp)&&i<=L.length){
        temp++;
        i++;
    }
    if(i>L.length){
        i=;
    }
    return i;
}
//清空顺序表，只让length=0
Status ClearList(SqList &L){
    L.length=;
    return true;
}
//销毁顺序表，释放elem指针
Status DestroyList(SqList &L){
    if(L.elem){
        free(L.elem);
    }
    L.length=;
    return true;
}
//两个元素是否相等
Status EqualElem(Elemtype e,Elemtype temp){
    if(e==temp){
        return true;
    }
    return false;
}
//将两个值不递减的顺序表合并到一个新的顺序表中
void MergeList(SqList La,SqList Lb,SqList &Lc){
    Lc.listsize=La.length+Lb.length;
    Lc.length=Lc.listsize;
    Lc.elem=(Elemtype *)malloc(Lc.listsize*sizeof(Elemtype));
    Elemtype *pa,*pb,*pa_last,*pb_last,*pc;
    pa=&La.elem[];
    pb=&Lb.elem[];
    pa_last=&(La.elem[La.length-]);
    pb_last=&(Lb.elem[Lb.length-]);
    pc=&Lc.elem[];
    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++;
    }
}