线性表的顺序、链式存储结构基本操作

线性表的抽象数据类型

operation

        InitList（&L）：初始化操作，建立一个空的线性表L

        ListEmpty（L）：若线性表为空，返回true，否则返回false

        ClearList（&L）：将线性表清空

        GetElem（L,i,&e）：将线性表L中的第i个位置元素值返回给e

        LocateElem（L,e）：在线性表L中查找与给定值e相等的元素，如果查找成功，返回该                                             元素中序号表示成功，否则，返回0表示失败

        ListInsert（&L,i,e）：在线性表L中的第i个位置插入新元素e

        ListDelete（&L,i,&e）：删除线性表L中第i个位置元素，并用e返回其值

        ListLength（L）：返回线性表L的元素个数

顺序存储结构

1.顺序表的描述

#define MAXSIZE 100      //存储空间初始分配值
typedef int ElemType;
typedef struct
{
   ElemType data[MAXSIZE];    //数组，存储数据元素
    int length;               //线性表当前长度
}SqList; 

2.表的初始化

Status InitList(SqList &L){             //构造一个空的顺序表L
    L.elem = new Elem Type[MAXSIZE];    //为顺序表分配空间
    if(!L.elem) exit(OVERFLOW);         //存储分配失败 
    L.length = 0;                       //空表长度为0
    return OK;
}

3.求长度

int GetLength(SqList L){
    return (L.length);
}

4.顺序表的查找

int LocateELem(SqList, ElemType e){
//在线性表L中查找值为e的元素，返回其序号
    for(i=0;i<L.length;i++)
        if(L.elem[i]==e) 
        return i+1;    //查找成功，返回序号
    return 0；
}   

5.顺序表的插入

Status  ListInsert(SqList  &L,int i,ElemType)
{
      if( (i<1)||(i>L.length+1) )   return ERROR;    //i值不合法
      if(L.length == MAXSIZE)       return ERROR;    //当前存储空间已满
      for( j=L.length-1;j＞=i-1;j--)
          L.elem[j+1] = L.elem[j];        //插入位置及之后的元素后移
      L.elem[i-1] = e;                  //将新元素e放入第i个位置
      L.length++;                       //表长加1
      return OK;
 }

6.顺序表的删除

Status  ListDelete(SqList  &L,int  i)
{
     if((i<1) || (i>L.length))    
         return ERROR;
     for(j=i;j<=L.length-1;j++)
         L.elem[j-1]=L.elem[j];        //被删除元素之后的元素前移
     L.length--;                      //表长减1
     return OK；
 }

链式存储结构

1.单链表的结构

typedef struct Lnode{    //声明结点的类型和指向结点的指针类型
    ElemType data;        //结点的数据域
    struct Lnode *next;    //结点的指针域
}Lnode, *LinkList;        //LinkList为指向结构体Lnode的指针类型

2.单链表的初始化

Status InitList(LinkList &L){
    L = new LNode;
    L->next = NULL;
    return OK;
}    

3.链表表长

int ListLength(LingkList L){    //返回L中数据元素个数
    LinkList p;
    p = L->next;    //p指向第一个结点
    i = 0;
    while(p){        //遍历单链表，统计节点数
        i++;
        p = p->next;
    }
    return i;
}

4.按值查找

int LocateELem(LinkList L,int e)
{
	p = L->next;
    j = 1;
    while(p&&p->data!=e){
        p = p->next;
        j++;
    }
    if(p){
        return j;
    }
    else 
        return 0;            
} 

5.插入

Status ListInsert(LinkList &L,int i,ElemType e)
{ 
    int p=L，j=0;          //p指向头结点
    while(p&&(j<i-1))
    {
       p=p->next;++j;  //查找第i-1个结点，p指向i-1结点
     }
     if(!p||j>i-1)  return ERROR;   //i>表长+1或i<1，插入位置非法
     LNode*s=new LNode;      //生成新结点s
     s->data=e;        //将结点s的数据域置为e
     s->next=p->next;  
     p->next=s;        //将结点p的指针域指向结点s
     return OK;
}    

6.删除

Status ListDelete(LinkList &L,int i,ElemType &e)
{
     LNode *p=L;int j=0;    
	 LNode *q;           
     while((p->next)&&(j<i-1))
     {
       p = p->next;
       ++j;                //查找第i-1个结点，p指向该结点
      }
      if(!(p->next)||(j>i-1))  return ERROR;   //删除位置不合理
      q = p->next;          //临时保存被删除结点的地址以备释放
      p->next = q->next;    //改变删除结点前驱结点的指针域
      e = q->data;           //保存删除结点的数据域
      delete q;           //释放删除结点的空间    
      return OK;
 }