【データ構造】順次リニアテーブルC言語を記憶して実現する

＊ファイル名:順次保存する線形表
*基本操作:
*InitList(&L)/空の線形表Lを作成します.
*DestoryList(&L)//リニアテーブルの削除
＊ClearList(&L)/／リニアテーブルを空のテーブルにリセットする
*ListEmpty(L)//リニアテーブルの空き操作
*ListLength(L)//Lの要素の個数を返します.
*GetElem(L,i,&e)/検索してi番目の要素に戻ります.
*Locateelem(L,e,compre()//リニアテーブルで最初にcompreを満たす要素
*PriorElem(L,curcuue,&preue)//若cur_eは、線形表の要素であり、最初ではない場合はpre_を用いる.eその前駆に戻る
*NextElem(L,curcuue,&nextcuue)//若cur_eは、線形表の要素であり、最後ではない場合、pre_を用いる.eその後継を返します
*ListInsert(&L,i,e)//i番目の要素の前(i-2)に新しい要素eを挿入します.
*ListDelete(&L,i,&e)//Lのi番目の要素を削除し、eで値を返します.
*ListTraverse(L,visit()//各要素をvisit()で巡回
＊次の二つの操作は、本で線形表に適用した例です.
＊ユニオン(&La,Lb)//LbのうちLaに属さない要素をLaに挿入する
*MergeList(La,Lb,&Lc)//LaとLbが秩序よく並べられていて、彼らをLcに帰して秩序よく並べられていると仮定する.
＊特徴:
＊シーケンス構造の線形表は、ある位置の要素に直接アクセスできます.
*ただし、メモリ容量が足りないとメモリの再割り当てが必要ですので、面倒です.

#include 
#include 
#include 

typedef  int  ElemType;   //           
typedef  int  Status;     //        ，    1，    0

#define OK  1
#define FAILED 0
#define TRUE 1
#define FALSE 0

#define LIST_INIT_SIZE  100 //             
#define LIST_INC  10        //                

typedef struct {
    ElemType    *elem;  //      
    int         length; //    （    ）
    int         listsize;   //         
}List, *L;

//         
Status InitList(List &L){
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if(!L.elem){
        printf("malloc failed
");
        return FAILED;
    }
    L.length = 0;   //         
    L.listsize = LIST_INIT_SIZE;    //       
    return OK;
}//InitList

//       
Status DestoryList(List &L){
    free(&L);
    return OK;
}//DestoryList

//          
//         0
Status ClearList(List &L){
    for(int idx = 0; idx < L.length; idx++){
        L.elem[idx] = 0;
    }
    return OK;
}

//        
Status ListEmpty(List L){
    if(L.length == 0){
        return TRUE;    //      
    } else if(L.length == 1){
        return FALSE;   //       
    }
}

//  L      
int ListLength(List L){
    return L.length;
}

//        i   
ElemType GetElem(List L, int i){
    if(L.length < i){
        printf("Get error
");
        return -1;
    }
    return L.elem[i];
}

//          e     ，        
//         -1
int LocateElem(List L, ElemType e){
    if(ListEmpty(L) == TRUE){
        //      
        printf("the list is empty
");
        return -1;
    }
    for(int idx = 0; idx= L.length){  //           
                printf("e has no next in ths list
");
            } else {
                return (idx+1);
            }
        }
    }
    printf("can not find next of e
");
    return -1;
}

//    
//   i    ，   i i          
Status ListInsert(List &L, ElemType e, int i){
    if(i > L.length){   //        ，       
        printf("insert error
");
        return FAILED;
    }
    if(L.length >= L.listsize){ //      ，        
        ElemType* newBase = (ElemType *)realloc(L.elem, (L.listsize+LIST_INC)*sizeof(ElemType));
        if(!newBase){
            printf("realloc failed
");
            return FAILED;
        }
        L.elem = newBase;
        L.listsize += LIST_INC;
    }
    if(i == L.length){  //            ，         
        L.elem[i] = e;
        return OK;
    }
    for(int idx = L.length-1; idx>=i; idx--){
        L.elem[idx] = L.elem[idx+1];
    }
    L.elem[i] = e;
    L.length++;
    return OK;
}

//     i   ，  e  
//        
Status ListDelete(List &L, int i, ElemType &e){
    if(i >= L.length){
        printf("there is no such elem
");
        return FAILED;
    }
    e = L.elem[i];
    for(int idx = i+1; idx