数据结构和算法学习总结03 线性表---顺序表

#include <stdio.h>  
#include <stdlib.h>  
  
#define EXIST 1              //存在数据元素，不为空
#define EMPTY 0              //为空
#define OK 1                 //成功
#define ERROR 0              //出现错误
#define OVERFLOW -1          //元素溢出
  
const int LIST_SIZE = 5;          //顺序表长度
  
typedef int Status;          //把整型定义成Status(状态)           用于定义各种操作方法
typedef int ElemType;        //把整型定义成ElemType(元素类型)     用于定义变量
  
typedef struct               
{  
        ElemType *elem;      //顺序表
        int length;          //顺序表的当前长度
        int listsize;        //顺序表的长度
} List;  
  
/*
  函数名：InitList() 
  功能：构造一个空线性表 
  返回值：存储分配失败：ERROR
          存储分配成功：OK
*/  
Status InitList(List &L)  
{  
       if((L.elem = new ElemType[LIST_SIZE])== NULL)
           //(ElemType*)malloc(sizeof(ElemType)* LIST_SIZE)) == NULL)   
           //malloc动态分配内存空间，成功返回指针，失败返回NULL
       return ERROR;  
       else  
       {  
           L.length = 0;  
           L.listsize = LIST_SIZE;  
           return OK;   
       }   
}  
 
/*
  函数名：DestroyList() 
  初始条件：线性表L已存在 
  功能：销毁线性表 
  返回值：ERROR
          OK
*/  
Status DestroyList(List &L)  
{  
     if(L.elem == NULL)  
     return ERROR;  
     else  
     {  
          free(L.elem);           //系统自带的函数free()
          return OK;   
     }   
}  
 
/*
  函数名：ClearList() 
  初始条件：线性表L已存在  
  功能：清空线性表 
  返回值：ERROR
          OK
*/  
Status ClearList(List &L)  
{  
       if (L.elem == NULL) return ERROR;  
       else  
       {  
           L.length = 0;  
           return OK;  
       }   
}   
   
/*
  函数名：IsEmpty()  
  初始条件：线性表存在 
  功能：判断线性表是否为空 
  返回：EMPTY
        EXIST
*/  
Status IsEmpty(List &L)  
{   
       if (L.length == 0) return EMPTY;  
       else return EXIST;  
}  
   
/*
  函数名：Length() 
  初始条件:线性表已存在 
  功能：返回线性表长度 
  返回值：线性表长度（L.length）
*/  
Status Length(List &L)  
{  
    return L.length;   
}   

/*
  函数名：GetElem() 
  参数: List &L, int i)  
  初始条件：线性表已存在 
  功能：用e返回线性表第i个元素的值 
  返回值： (i < 1)||(i > ListLength(L)) : OVERFLOW 
           1<= i <=ListLength(l) :OK
*/  
Status GetElem(List &L, int i)  
{  
       if ((i < 1)||(i > Length(L)))   
       return OVERFLOW;  
       int j;  ElemType e;
       ElemType *p;  
       p = L.elem;   
       for (j = 0; j < i - 1; j++)  
           L.elem++;   
       e = *L.elem;   
       L.elem = p; 
       return e;
}   

/*
函数名：GetLocateElem() 
  参数：List &L, ElemType value
  初始条件：线性表L已存在 
  功能：返回顺序表中第一个与element相等的元素的位序 
  返回值：若L中存在与element相等的元素，则返回 第一个符合条件的元素位序 
          若不存在，则返回0
*/  
Status GetLocateElem(List &L, ElemType value)  
{  
       int i;  
       ElemType *p;  
       p = L.elem;   
       for (i = 1;i <= L.length; i++)  
       {  
           if (*L.elem == value)  
           {  
                 L.elem = p;  
                 return i; 
           }   
           L.elem++;   
       }   
       L.elem = p;  
       return 0;   
}  
 
/*
  函数名：GetPreElem()
  参数：List &L, ElemType e, ElemType *pre_e 
  初始条件：线性表已存在，i>1&&i<=L.length,GetLocateElem()存在  
  功能：用pre_e返回线性表中e的前驱 
  返回值： OVERFLOW 
           OK        
*/  
Status GetPreElem(List &L, ElemType e, ElemType *pre_e)  
{  
       ElemType *p = L.elem;  
       int i;  
       i = GetLocateElem(L, e);           //这里不用&L   因为这是按引用调用   
       if (i == 0) return OVERFLOW;  
       int j;  
       for (j = 0;j < i - 2; j++)  
       {  
           L.elem++;  
       }   
       *pre_e = *L.elem; 
       L.elem = p;  
       return OK;   
} 
                    
/*
  函数名：InsertList()； 
  参数：List &L, int i, ElemType e 
  初始条件：线性表L已存在，1 <= i <=L.length + 1; 
  功能：在线性表第i个元素前插入e 
  返回值：失败：OVERFLOW
          成功：OK 
*/  

Status InsertList(List &L, int i, ElemType e)  
{    
       ElemType *newList, *p; 
       int j;
       if (i < 1||i > (L.length)+1)  
       return OVERFLOW;  
       if (L.length >= L.listsize)  
       {  
             newList = new ElemType[L.listsize + 1];
                 //(ElemType*)realloc(L.elem,L.listsize + sizeof(ElemType)) ; 
              
             for(j=0;j<L.length;j++)
             {
                 newList[j]=L.elem[j];
             }
             free(L.elem);
             L.elem = newList;  
             L.listsize++;                  
       }
       int *q = &(L.elem[i - 1]); 
       for (p = &(L.elem[L.length - 1]);p >= q; p--)  
           *(p + 1) = *p;  
       *q = e;  
       L.length++;  
       return OK;      
}   

/*函数名：ListDelete() 
  参数：List &L, int i, ElemType *e;  
  初始条件：线性表L已存在。1<= i <= L.length 
  功能：删除线性表中第i个元素,并用e返回被删数的值  
  返回值：失败：OVERFLOW 
          成功：OK*/  
Status ListDelete(List &L, int i, ElemType &e)  
{  
         
       if ((i < 1)||(i > L.length))   
       return OVERFLOW;   
       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 PrintfList(List &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(List &L)  
{  
       int i, a;  
       printf("enter numbers:");  
       for (i = 0;i < LIST_SIZE ; i++)  
       {  
        scanf("%d",&a);  
        InsertList(L, i+1, a);  
       }    
       return 1;
}  
  
int main()  
{  
    List La, Lb;   
    int i, e;   
    InitList(La);                 
    InitList(Lb);      
    ListScan(La);      
    ListScan(Lb);    
    for (i = 0; i < Lb.length; i++)  
    {  
        e = GetElem(Lb,i+1);
        printf("\n%d",e);             //将顺序表Lb的数据元素通过位置查询一个个输出
        if (!GetLocateElem(La, e))    
        InsertList(La, 6, e);         //判断Lb中的一个数据La中是否也有，如果没有，插入到La后
       // Lb.elem++;   
    }   
    printf("\nLa = ");  
    PrintfList(La);   
    return 0;  
}