数据结构-线性表

线性表的抽象数据类型定义

ADT List{
数据对象：D = {a_i | a_i∈ ElemSet , i=1,2,3,…,n,n≥0}
数据关系：R1 = {<a_i-1,a_i> | a_i-1 ,a_i ∈D, i=2,…,n}
基本操作：
InitList(&L)
操作结果：构造一个空的线性表L。
Destory(&L)
初始条件：
操作结果：
ClearList(&L)
初始条件：
操作结果：
ListEmpty(L)
初始条件：
操作结果：
LsitLength(L)
初始条件：
操作结果：
GetElem(L,i,&e)
初始条件：
操作结果：
LocateElem(L,e,compare())
初始条件：
操作结果：
PriorElem(L,cur_e,&pre_e)
初始条件：
操作结果：
NextElem(L,cur_e,&next_e)
初始条件：
操作结果：
ListInsert(&L,i,e)
初始条件：
操作结果：
ListDelete(&L,i,&e)
初始条件：
操作结果：
ListTraverse(L,visit())
初始条件：
操作结果：
}ADT List

线性表的实现

线性表的实现有顺序和链式

存储方式	特点	优点	缺点
顺序表	需要分配连续的存储空间	可以随机访问，便于进行查询	插入或者删除操作需要移动大量元素
单链表	不需要分配连续的存储空间	插入或者删除操作不需要移动大量元素	顺序访问，不便于查询操作

*注（
删除表长为n的用数组标识的线性表中任意一个元素，平均移动的元素的个数为 (n-1)/2
在表长为n的用数组表示的线性表中任意插入一个元素，平均需要移动的元素个数为 n/2
）

1.顺序存储（SqList顺序表）

优点：随机的存储
缺点：插入或者删除需要移动大量元素

顺序表第i个数据元素a_i的存储位置计算：
(假设线性表的每个元素需占用L 个存储单元)
公式： Loc(a_i)=Loc(a₁)+(i-1) * L
或者
Loc(a_i)=Loc(a₀)+i * L

顺序表结构体定义

#define LIST_INIT_SIZE 100 /* 存储空间初始分配容量 */
typedef struct {
    ElemType elem[LIST_INIT_SIZE];    //存储空间基址
    int length;        //当前长度
    } S

InitList初始化顺序表

//创建并初始化为空表
Status InitList(SqList &L)
{
    // TODO (#1#): 创建空表
    L.length=0;
    return OK;
    //-------------------------------------
}

ListLength求顺序表长度

//求表L的长度
int ListLength(SqList L)
{
    // TODO (#1#): 求顺序表长度
    return L.length;
    //-------------------------------------
}

GetElem取表L中的第i个元素

//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR
Status GetElem(SqList L, int i, ElemType &e)
{
    if(i<1||i>L.length+1)
    return ERROR;
    return L.elem[i-1];
}

ListInsert插入元素在表L中插入第i个元素e

//在表L中插入第i个元素e. 操作成功返回OK,失败时返回ERROR
Status ListInsert(SqList &L, int i, ElemType e)
{
    // TODO (#1#): 在 SHUNXU表中插入元素
        if(i<1||i>L.length+1){
            return ERROR;
        }
        int j=L.length;
        for(j;j>=i;j--){
            L.elem[j]=L.elem[j-1];
        }
        L.elem[i-1] = e ;       // 插入e
        L.length=L.length+1;
        return OK;
}

ListDelete删除表L中第i个元素

//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR
Status ListDelete(SqList &L, int i, ElemType &e)
{
    // TODO (#1#): 在顺序表中删除元素
    if(i<1||i>L.length+1)
    return ERROR;
    int j;
    e=L.elem[i-1];
    for(j=i;j<=L.length;j++){
        L.elem[j-1]=L.elem[j];
    }
    --L.length;
    return OK;
    //-------------------------------------
}

ListTraverse遍历表L

//遍历表L,对每个元素调用visit(x).
Status ListTraverse(SqList L, Status (*visit)(ElemType))
{
    // TODO (#1#): 遍历顺序表
    for (int j=0; j<L.length; j++)
        if ( ! visit(L.elem[j]) )  return ERROR;
    return OK;
    //-------------------------------------
}

2.链式存储（LinkList单链表）

优点：插入或者删除不需要移动大量元素；动态生成结点
缺点：顺序访问元素

手工操作

单链表代码实现

单链表结构体定义

typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

InitList创建并初始化为空表

//创建并初始化为空表
Status InitList(LinkList &L)
{
    // TODO (#1#): 创建空表
    L=(LinkList)malloc(sizeof(LNode));//头指针指向首元结点
    L->next=NULL;//首元结点指针域设为空
        return OK;
    //-------------------------------------
}

ClearList将表L置空

//将表L置空
Status ClearList(LinkList &L)
{
    // TODO (#1#): 清空表
    LinkList p=L->next;
    while(p)
    {
        L->next=p->next;
        p=p->next;
        free(p);
    }
    return OK;
}

ListEmpty判断表L是否为空表

//判断表L是否为空表
bool ListEmpty(LinkList L)
{
    // TODO (#1#): 链表判空
    if(L->next==NULL)
    return TRUE;
    return FALSE;
    //-------------------------------------
}

DestroyList销毁整个表

//销毁整个表(从此之后不再可用)
Status DestroyList(LinkList &L)
{
    // TODO (#1#): 销毁表
    LinkList p=L->next;
    while(p)
    {
        L->next=p->next;
        p=p->next;
        free(p);
    }
    free(L);
    return ERROR;
    //-------------------------------------
}

ListLength求表L的长度

//求表L的长度
int ListLength(LinkList L)
{
    // TODO (#1#): 链表求长度
        int countLength=1;      //设置计数器为0
        LinkList p=L->next;      //p指向首元结点
        while(p->next)
        {
            p=p->next;
            countLength++;
        }
        return countLength;
    //-------------------------------------
}

GetElem获取i位置的元素

//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR
Status GetElem(LinkList L, int i, ElemType &e)
{
    // TODO (#1#): 实现取元素GetElem(L,i,&e)
   LinkList p=L;//设置指针p指向首元结点
    int j=0;
    while(p&&j<i)
    {
        p=p->next;
        j++;
    }
    if(!p||j>i)return ERROR;
    e=p->data;;
    return   OK;
}

LocateElem在表L中定位元素e首次出现的位置

//在表L中定位元素e首次出现的位置. 操作成功返回位序,失败时返回0
int LocateElem(LinkList L, ElemType e)
{
    // TODO (#1#): 在表中定位元素e,用compare(a,b)匹配元素
   LinkList p;
    int j;
    p = L->next; j = 1;
    while(p!=NULL) {
        if( compare(p->data,e) )  return j;
        p=p->next;
        j++;
    }
    return 0;
}

ListInsert在表L中插入第i个元素e

//在表L中插入第i个元素e. 操作成功返回OK,失败时返回ERROR
Status ListInsert(LinkList &L, int i, ElemType e)
{
    // TODO (#1#): 在链表中插入元素
    int j=0;
    LinkList p=L;
    while(p&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(!p||j>i-1)return ERROR;
    LinkList s=(LinkList)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
}

ListDelete删除表L中第i个元素

//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR
Status ListDelete(LinkList &L, int i, ElemType &e)
{
    LinkList p=L;//设置指针p指向首元结点
    int j=0;
    while(p&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(!p||j>i)return ERROR;
    LinkList s;
    s=p->next; //指针s指向要删除的第i个元素；
    e=s->data;//把第i个元素的数据域赋给e;
    p->next=s->next;
    free(s);
    return OK;
    //-------------------------------------
}