线性表操作实现-优快云博客

#include <stdio.h>  
#include <stdlib.h>  

#define TRUE 1  
#define FALSE 0  
#define OK 1  
#define ERROR 0  
#define INFEASIBLE -1  
#define OVERFLOW -2  

#define LIST_INST_SIZE 5  
#define LISTINCREMENT 1  

typedef int Status;  
typedef int ElemType;  

typedef struct   
{  
        ElemType *elem;  
        int length;  
        int listsize;  
} sql;  

static ElemType element;  

/*函数名：InitList() 
  参数：sql L 
  初始条件：无 
  功能：构造一个空线性表 
  返回值：存储分配失败：OVERFLOW 
          存储分配成功：OK*/  
Status InitList(sql &L)  
{  
       if((L.elem = (ElemType*)malloc(sizeof(ElemType)* LIST_INST_SIZE)) == NULL)  
       return OVERFLOW;  
       else  
       {  
           L.length = 0;  
           L.listsize = LIST_INST_SIZE;  
           return OK;   
       }   
}   
/*函数名：DestroyList() 
  参数: sql L 
  初始条件：线性表L已存在 
  功能：销毁线性表 
  返回值：L.elem == NULL:ERRor 
          L.elem != NUll:OK*/  
Status DestroyList(sql &L)  
{  
                if(L.elem == NULL)  
                return ERROR;  
                else  
                {  
                    free(L.elem);  
                    return OK;   
                }   
}   
/*函数名：ClearList() 
  参数：sql L； 
  初始条件：线性已存在表L  
  功能：清空线性表 
  返回值：L.elem == NULL :ERROR 
          L.elem != NULL :OK*/  
Status ClearList(sql &L)  
{  
       if (L.elem == NULL) return ERROR;  
       else  
       {  
           L.length = 0;  
           return OK;  
       }   
}   

/*函数名：LIstEmpty() 
  参数：sql L; 
  初始条件：线性表存在 
  功能：判断线性表是否为空 
  返回：空：TRUE 
        非空：FALSE*/  
Status ListEmpty(sql &L)  
{   
       if (L.length == 0) return true;  
       else return false;  
}     
/*函数名：ListLength() 
  参数：sql L 
  初始条件:线性表已存在 
  功能：返回线性表长度 
  返回值：线性表长度（L.length）*/  
Status ListLength(sql &L)  
{  
       return L.length;   
}   
/*函数名：GetElem() 
  参数: SqList L, int i,ElemType *e(这里面用了全局变量element)  
  初始条件：线性表已存在 
  功能：用e返回线性表第i个元素的值 
  返回值： (i < 1)||(i > ListLength(L)) : OVERFLOW 
           1<= i <=ListLength(l) :OK*/  
Status GetElem(sql &L, int i,ElemType &e )  
{  
       if ((i < 1)||(i > ListLength(L)) )   
       return OVERFLOW;  
       int j;  
       ElemType *p;  
       p = L.elem;   
       for (j = 0; j < i - 1; j++)  
           L.elem++;   
       e = *L.elem;   
       L.elem = p;  
       return OK;   
}   
/*函数名：LocateElem() 
  参数：sql L, ElemType element 
  初始条件：线性表L已存在 
  功能：返回顺序表中第一个与element相等的元素的位序 
  返回值：若L中存在与element相等的元素，则返回 第一个符合条件的元素位序 
          若不存在，则返回0*/  
Status LocateElem(sql &L, ElemType E)  
{  
       int i;  
       ElemType *p;  
       p = L.elem;   
       for (i = 1;i <= L.length; i++)  
       {  
           if (*L.elem == E)  
           {  
                       L.elem = p;  
                       return i;   
           }   
           L.elem++;   
       }   
       L.elem = p;  
       return 0;   
}   
/*函数名：PriorElem() 
  参数：sql L, Elemtype cur_e, ElemType *pre_e 
  初始条件：线性表已存在，i>1&&i<=L.length,LocationElem()存在  
  功能：用pre_e返回线性表中cur_e的前驱 
  返回值： i<=1||i>L.length：OVERFLOW 
           i>1&&i<=L.length：OK        */  
Status PriorElem(sql &L, ElemType cur_e, ElemType *pre_e)  
{  
       ElemType *p = L.elem;  
       int i;  
       i = LocateElem(L, cur_e);     //为什么 用&L不行   因为这是按引用调用   
       if (i == 0) return OVERFLOW;  
       int j;  
       for (j = 0;j < i - 2; j++)  
       {  
           L.elem++ ;  
       }   
       *pre_e = *L.elem;    //注意 pre_e = L.elem 不行    
       L.elem = p;  
       return OK;   
}                     
/*函数名：ListInsert（）； 
  参数：sql L, int i, ElemType e 
  初始条件：线性表L已存在，1 <= i <=L.length + 1; 
  功能：在线性表第i个元素前插入e 
  返回值：失败：ERROR 
          成功：OK */  
Status ListInsert(sql &L, int i, ElemType e)  
{  
       int *q = &(L.elem[i - 1]);   
       ElemType *newbase, *p;  
       if (i < 1||i > (L.length)+1)  
       return ERROR;  
       if (L.length >= L.listsize)  
       {  
                    newbase = (ElemType*)realloc(L.elem,L.listsize + LISTINCREMENT*sizeof(ElemType)) ;  
                    if (newbase == NULL)  
                    exit(OVERFLOW);  
                    L.elem = newbase;  
                    L.listsize+=LISTINCREMENT;                  
       }   
       for (p = &(L.elem[L.length - 1]);p >= q; p--)  
           *(p + 1) = *p;  
       *q = e;  
       ++L.length;  
       return OK;      
}   
/*函数名：ListDelete（） 
  参数：sql L, int i;ElemType *e;  
  初始条件：线性表L已存在。1<= i <= L.length 
  功能：删除线性表中第i个元素,并用e返回被删数的值  
  返回值：失败：ERROR 
          成功：OK*/  
Status ListDelete(sql &L, int i, ElemType &e)  
{  

       if ((i < 1)||(i > L.length))   
       return ERROR;   
       e = (L.elem[i - 1]);   
       ElemType  *q;        
       for (q = &(L.elem[i - 1]); q < &(L.elem[L.length - 1]); q ++ )  
       {  
           *q = *(q + 1);   
       }   
       L.length--;  
       return OK;   
}   
Status ListSee(sql &L)  
{  
       if ((L.elem == NULL)||(L.length==0))  
       return ERROR;  
       else  
       {  
           int  i;  
           for (i = 0; i < L.length; i++)  
           {  
               printf("%d ",L.elem[i]);  
           }  
           printf("\n");  
       }  
       return OK;  
}  
Status ListScan(sql &L)  
{  
       int i, a;  
       printf("enter numbers:");  
       for (i = 0;i < LIST_INST_SIZE ; i++)  
       {  
        scanf("%d",&a);  
        ListInsert(L, L.length + 1, a);  
       }      
}  

int main()  
{  
    sql La, Lb;   
    int i, e;   
    InitList(La);                 
    InitList(Lb);      
    ListScan(La);      
    ListScan(Lb);   
    for (i = 0; i < Lb.length; i++)  
    {  
        e = Lb.elem[i];   
        if (!LocateElem(La, e))    
        ListInsert(La, La.length + 1, e);   
       // Lb.elem++;   
    }   
    printf("La = ");  
    ListSee(La);   
    system ("pause");  
    return 0;  
}