数据结构第二章线性表

第三章 线性表

1.(1)存在唯一的一个被称作“第一个”的数据元素

.(2)存在唯一的一个被称作“最后一个”的数据元素

.(3)除第一个数据元素之外，集合中每一个数据元素均只有一个前驱

.(4)除最后一个数据元素之外，集合中每一个数据元素均只有一个后继

2.顺序表示：用一组地址连续的存储单元依次存储线性表的数据元素

typedefstruct

{

  ElemType *elem;

  int length;

  int listSize;

}SqList;

StatusInitList(SqList &L)

{

   L.elem=(ElemType*)malloc(sizeof(ElemType)*LIST_INIT_SIZE);

    L.length=0;

    L.listSize=LIST_INIT_SIZE;

    return OK;

}

StatusGetElem(SqList L,int i,int &e)

{

    if(i<1||i>L.length||L.length==0)

    return ERROR;

    e=L.elem[i-1];

    return OK;

}

StatusListInsert(SqList &L,int i,int e)

{

    if(i<1||i>L.length+1)

        return ERROR;

    if(L.length==L.listSize)

    {

       L.elem=(ElemType*)realloc(L.elem,sizeof(ElemType)*(LISTINCREMENT+L.listSize));

        L.listSize+=LISTINCREMENT;

    }

    if(i<L.length+1)

    for(int j=L.length-1;j>=i-1;j--)

        L.elem[j+1]=L.elem[j];

    L.elem[i-1]=e;

    L.length++;

    return OK;

}

StatusListDelete(SqList &L,int i,int &e)

{

    if(i<1||i>L.length||L.length==0)

        return ERROR;

    e=L.elem[i-1];

    if(i<L.length)

        for(int j=i-1;j<L.length-1;j++)

            L.elem[j]=L.elem[j+1];

    L.length--;

    return OK;

}

插入元素：O(n)=n/2

删除元素：O(n)= n-1/2

2.链式结构：

 typedef struct LNode

{

    ElemType data;

    struct LNode *next;

}LNode,*LinkList;

StatusGetElem_L(LinkList L,int i,ElemType& e)

{

    LinkList p=L->next;

    int j=1;

    while(p&&j<i)

    {

        p=p->next;

        j++;

    }

    if(!p||j>i)return ERROR;

    e=p->data;

    return OK;

}

StatusListInsert_L(LinkList &L,int i,ElemType e)

{

    LinkList q,p=L;

    int j=0;

    while(j<i-1&&p)

    {

        p=p->next;

        j++;

    }

    if(!p||j>i)return ERROR;

    q=(LinkList)malloc(sizeof(LNode));

    q->data=e;

    q->next=p->next;

    p->next=q;

    return OK;

}

StatusListDelete_L(LinkList &L,int i,int &e)

{

    LinkList p,q;

    p=L;

    int j=0;

    while(j<i-1&&p->next)

    {

        p=p->next;

        j++;

    }

    if(!(p->next)||j>i)return ERROR;

    q=p->next;

    e=q->data;

    p->next=q->next;

    free(q);

    return OK;

}

voidListCreate_Lhead(LinkList &L)//头插法

{

    LinkList p;

    L=(LinkList)malloc(sizeof(LNode));

    L->next=NULL;

    for(i=n;i>0;i++)

    {

        p=(LinkList)malloc(sizeof(LNode));

        p->data=i;

        p->next=L->next;

        L->next=p;

    }

}

voidListCreate_Ltail(LinkList &L)

{

    LinkList p,q;

    L=(LinkList)malloc(sizeof(LNode));

    L->next=NULL;

    q=L;

     for(i=n;i>0;i++)

    {

        p=(LinkList)malloc(sizeof(LNode));

        p->data=i;

        q->next=p;

        q=p;

    }

    q->next=NULL;

}

StatusListClear_L(LinkList &L)

{

    LinkList p,q;

    p=L->next;

    while(p)

    {

        q=p->next;

        free(p);

        p=q;

    }

    L->next=NULL;

    return OK;

}

.静态链表：用数组描述的链表；第一个和最后一个数组空间不存数据；第一个数组空间的cur存放备用链表第一个节点的下标；最后一个数组空间的cur存放第一个有数值的元素的下标。

typedefstruct

{

    ElemType data;

    int cur;

}Component,StaticLinklist[MAXSIZE];

voidListInit_SL(StaticLinklist &space)

{

    for(int i=0;i<MAXSIZE-1;i++)

        space[i].cur=i+1;

    space[MAXSIZE-1].cur=0;

}

intMalloc_SL(StaticLinklist &space)

{

    int i=space[0].cur;

    if(space[0].cur)

        space[0].cur=space[i].cur;

    return i;

}

voidFree_SL(StaticLinklist &space,int i)

{

    space[i].cur=space[0].cur;

    space[0].cur=i;

}

intListLength_SL(StaticLinklist &space)

{

    int j=0;

    int i=MAXSIZE-1;

    while(i)

    {

        i=space[i].cur;

        j++;

    }

    return j;

}

StatusListInsert_SL(StaticLinklist &space,int i,ElemType e)

{

    int k=MAXSIZE-1;

    if(i<1||i>ListLength_SL(space)+1)

        return ERROR;

    int j=Malloc_SL(space);

    if(j)

    {

        space[j].data=e;

        for(int l=1;l<i;l++)

            k=space[k].cur;

        space[j].cur=space[k].cur;

        space[k].cur=j;

        return OK;

    }

    return ERROR;

}

StatusListDelete_SL(StaticLinklist &space,int i)

{

    if(i<1||i>ListLength_SL(space))

        return ERROR;

    int k=MAXSIZE-1;

    for(int l=1;l<i;l++)

        k=space[k].cur;

    int j=space[k].cur;

    space[k].cur=space[j].cur;

    Free_SL(space,j);

    return OK;

}

顺序结构存储：

优点：

（1）无须为表示表中元素之间的逻辑关系而增加额外的存储空间

（2）可以快速的存取表中任意位置的元素

缺点：

（1）插入和删除操作需要移动大量元素

（2）当线性表长度变化较大时，难以确定存储空间的容量

（3）造成存储空间的“碎片”

链式结构存储：

存储分配方式：顺序存储结构用一段连续的存储单元依次存储线性表的数据元素
单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素

时间性能：查找：顺序存储结构O(1) 单链表O(n) ； 插入和删除：书序存储结构O(n) 单链表O(1)

空间性能：顺序存储结构需要预分配存储空间 ； 单链表不需要预分配存储空间，元素个数不受限制

静态链表：

优点：在插入和删除操作时，不需要移动元素，从而改进了在顺序存储结构中的插入和删除操作需要移动大量元素的缺点

缺点：没有解决连续存储分配带来的表长难以确定的问题
失去了顺序存储结构随机存取的特性