数据结构C实现之线性表

研究生还是要读的，但是专业一定要是自己喜欢的 =。=

zju，wait me！

#include <iostream>
#include <cstdio>
#include <cstdlib>
#define ElementType int
#define Maxsize 100
#define Status bool
#define not_exist 10000
#define none -1
using namespace std;
typedef Status (*func)(ElementType,ElementType);  //a pointer to function

//create a structure of list by using array
typedef struct AList{
    ElementType arr[Maxsize];
    unsigned length;
}*Alist;

//create a structure of list by using linknode
typedef struct LNode{
    ElementType value;
    struct LNode* next;
}*Llist,*Node;

//calculating's method of Alist
Status InitAlist(Alist &l);
Status DestroyAlit(Alist &l);
Status ClearAlist(Alist &l);
Status IsAlistEmpty(Alist l);
unsigned AlistLength(Alist l);
Status GetAlist(Alist l,unsigned i,ElementType &e);
unsigned LocateAelem(Alist l,ElementType e,func compare);
Status PriorAelem(Alist l,ElementType cur_e,ElementType &pre_e);
Status NextAelem(Alist l,ElementType cur_e,ElementType &next_e);
Status AlistInsert(Alist &l,unsigned i,ElementType e);
Status AlistDelete(Alist &l,unsigned i,ElementType &e);
Status AlistTraverse(Alist l,void (*visit)(ElementType e));

//calculating's method of Llist
Status InitLlist(Llist &l);
Status DestroyLlit(Llist &l);
Status ClearLlist(Llist &l);
Status IsLlistEmpty(Llist l);
unsigned LlistLength(Llist l);
Status GetLlist(Llist l,unsigned i,ElementType &e);
unsigned LocateLelem(Llist l,ElementType e,func compare);
Status PriorLelem(Llist l,ElementType cur_e,ElementType &pre_e);
Status NextLelem(Llist l,ElementType cur_e,ElementType &next_e);
Status LlistInsert(Llist &l,unsigned i,ElementType e);
Status LlistDelete(Llist &l,unsigned i,ElementType &e);
Status LlistTraverse(Llist l,void (*visit)(ElementType e));

//test func
Status isequal(ElementType a, ElementType b){
    if(a==b){
        return true;
    }else{
        return false;
    }
}
void printit(ElementType e){
    printf("%d ",e);
}

int main(){
    // test these two struct of list
    //Alist l;
    //InitAlist(l);
    /*for(unsigned i=0;i<5;i++){
        AlistInsert(l,i,i*(i*3));
    }*/
    //printf("%d\n",LocateAelem(l,145,test1));
    //printf("%p",l);
    //AlistDelete(l,0,e);
    //printf("%d\n",e);
    //printf("%d\n",l->length);
    //AlistTraverse(l,printit);
    /*Llist l;
    InitLlist(l);
    for(int i=0;i<5;i++){
        LlistInsert(l,i,i*i);
    }
    LlistTraverse(l,printit);
    printf("\n");
    LlistInsert(l,3,7);
    LlistTraverse(l,printit);
    printf("\n");
    int e;
    LlistDelete(l,3,e);
    LlistTraverse(l,printit);
    printf("\n");
    GetLlist(l,3,e);
    printf("%d\n",e);*/
    return 0;
}

Status InitAlist(Alist &l){
    l=(Alist)malloc(sizeof(struct AList));
    if(l==NULL){
        return false;
    }
    l->length=0;
    return true;
}

Status DestroyAlit(Alist &l){
    if(l!=NULL){
        free(l);
        l=NULL;
        return true;
    }else{
        exit(0);
    }
}

Status ClearAlist(Alist &l){
    if(l==NULL){
        exit(0);
    }
    if(l->length!=0){
        free(l);
        InitAlist(l);
        return true;
    }else{
        return false;
    }
}

Status IsAlistEmpty(Alist l){
    if(l->length>0){
        return false;
    }else{
        return true;
    }
}

unsigned AlistLength(Alist l){
    if(l!=NULL){
        return l->length;
    }else{
        exit(0);
    }
}

Status GetAlist(Alist l,unsigned i,ElementType &e){
    if(l==NULL){
        exit(0);
    }else if(i<1||i>l->length){
        return false;
    }else{
        e=l->arr[i];
        return true;
    }
}

unsigned LocateAelem(Alist l,ElementType e,func compare){
    if(l==NULL){
        exit(0);
    }else{
        for(unsigned i=0;i<l->length;i++){
            if(compare(e,l->arr[i])){
                return i;
            }
        }
        return not_exist;
    }
}

Status PriorAelem(Alist l,ElementType cur_e,ElementType &pre_e){
    if(l==NULL){
        exit(0);
    }else{
        for(unsigned i=0;i<l->length;i++){
            if(i!=0&&l->arr[i]==cur_e){
                pre_e=l->arr[i-1];
                return true;
            }
        }
        return false;
    }
}

Status NextAelem(Alist l,ElementType cur_e,ElementType &next_e){
    if(l==NULL){
        exit(0);
    }else{
        for(unsigned i=0;i<l->length;i++){
            if(i!=l->length-1&&l->arr[i]==cur_e){
                next_e=l->arr[i+1];
                return true;
            }
        }
        return false;
    }
}

Status AlistInsert(Alist &l,unsigned i,ElementType e){
    if(l==NULL){
        exit(0);
    }else if(l->length==0&&i==0){
        l->arr[i]=e;
        l->length++;
        return true;
    }else if(i<1||i>l->length){
        return false;
    }else{
        for(unsigned k=l->length;k>i;k--){
            l->arr[k]=l->arr[k-1];
        }
        l->arr[i]=e;
        l->length++;
        return true;
    }
}

Status AlistDelete(Alist &l,unsigned i,ElementType &e){
    if(l==NULL||l->length==0){
        exit(0);
    }else if(i<0||i>l->length-1){
        return false;
    }else{
        e=l->arr[i];
        for(unsigned k=i;k<l->length-1;k++){
            l->arr[k]=l->arr[k+1];
        }
        l->arr[l->length-1]=none;
        l->length--;
        return true;
    }
}

Status AlistTraverse(Alist l,void (*visit)(ElementType e)){
    if(l==NULL){
        exit(0);
    }else if(l->length<1){
        return false;
    }else{
        for(unsigned i=0;i<l->length;i++){
            visit(l->arr[i]);
        }
        return true;
    }
}

Status InitLlist(Llist &l){
    l=(Llist)malloc(sizeof(struct LNode));
    if(l==NULL){
        return false;
    }
    l->value=-1;
    l->next=NULL;
    return true;
}

Status DestroyLlit(Llist &l){
    if(l!=NULL){
        Node p=l;
        Node tmp;
        while(p!=NULL){
            tmp=p;
            p=p->next;
            free(tmp);
        }
        return true;
    }else{
        exit(0);
    }
}

Status ClearLlist(Llist &l){
    if(l==NULL){
        exit(0);
    }else{
        Llist p=l->next;
        DestroyLlit(p);
        InitLlist(l);
        return true;
    }
}

Status IsLlistEmpty(Llist l){
    if(l!=NULL){
        return true;
    }else{
        return false;
    }
}

unsigned LlistLength(Llist l){
    unsigned cnt=0;
    Llist p=l;
    while(p->next!=NULL){
        p=p->next;
        cnt++;
    }
    return cnt;
}

Status GetLlist(Llist l,unsigned i,ElementType &e){
    if(l==NULL){
        exit(0);
    }else if(i<1||i>LlistLength(l)){
        return false;
    }else{
        unsigned cnt=0;
        Llist p=l;
        while(p->next!=NULL&&cnt<i){
            p=p->next;
            cnt++;
        }
        e=p->value;
        return true;
    }
}

unsigned LocateLelem(Llist l,ElementType e,func compare){
    if(l==NULL){
        exit(0);
    }else{
        Llist p=l;
        unsigned cnt=1;
        while(p!=NULL){
            if(compare(e,p->value)){
                return cnt;
            }
            p=p->next;
            cnt++;
        }
    }
    return not_exist;
}

Status PriorLelem(Llist l,ElementType cur_e,ElementType &pre_e){
    if(l==NULL){
        exit(0);
    }else{
        Llist p=l;
        Llist pre;
        while(p!=NULL){
            if(pre!=NULL&&p->value==cur_e){
                pre_e=pre->value;
            }
            pre=p;
            p=p->next;
        }
        return true;
    }
}

Status NextLelem(Llist l,ElementType cur_e,ElementType &next_e){
    if(l==NULL){
        exit(0);
    }else{
        Llist p=l;
        while(p!=NULL){
            if(p->next!=NULL&&p->value==cur_e){
                next_e=p->next->value;
            }
            p=p->next;
        }
        return true;
    }
}

Status LlistInsert(Llist &l,unsigned i,ElementType e){
    if(l==NULL){
        exit(0);
    }else if(i==0&&LlistLength(l)==0){
        Node en;
        InitLlist(en);
        en->value=e;
        l->next=en;
        return true;
    }else if(i<1||i>LlistLength(l)){
        return false;
    }
    else{
        Llist p=l;
        unsigned cnt=0;
        while(p!=NULL&&cnt!=i-1){
            p=p->next;
            cnt++;
        }
        Node en;
        InitLlist(en);
        en->value=e;
        Llist tmp=p->next;
        p->next=en;
        en->next=tmp;
        return true;
    }
}

Status LlistDelete(Llist &l,unsigned i,ElementType &e){
    if(l==NULL){
        exit(0);
    }else if(i<1||i>LlistLength(l)){
        return false;
    }else{
        Llist p=l;
        unsigned cnt=0;
        while(p!=NULL&&cnt!=i-1){
            p=p->next;
            cnt++;
        }
        Llist tmp=p->next;
        e=tmp->value;
        p->next=tmp->next;
        free(tmp);
        return true;
    }
}

Status LlistTraverse(Llist l,void (*visit)(ElementType e)){
    if(l==NULL){
        exit(0);
    }else{
        Llist p=l;
        while(p!=NULL){
            visit(p->value);
            p=p->next;
        }
        return true;
    }
}