数据结构和算法学习总结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;
}