美文网首页
三. 线性表

三. 线性表

作者: CoCc | 来源:发表于2018-08-19 17:47 被阅读0次

    线性表: 零个或多个数据源元素的有限序列。

    线性表的顺序存储结构，指的是用一段地址连续的存储单元一次存储线性表的数据元素。其中，线性表的长度应该小于或等于数组的长度。

    顺序结构的查询，插入与删除

    #define MAXSIZE 10
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int ElemType;
typedef int Status;

typedef struct {
    ElemType data[MAXSIZE];
    int length;
}Sqlist;

// 根据下标查找数据元素
Status getElem(Sqlist L, int i, ElemType *e) {
    if (L.length == 0 || i < 1 || i > L.length) { return ERROR; }
    
    *e = L.data[i - 1];
    return OK;
}

// 插入e到i下标的位置
Status ListInsert(Sqlist *L, int i, ElemType e) {
    int k;
    if (L->length == MAXSIZE) { return ERROR; } //线性表已满
    if (i < 1 || i > L->length + 1) { return ERROR; } //i超出范围
    if (i <= L->length) {
        for (k = L->length - 1; k >= i - 1; k--) { //将要插入位置后数据元素向后移动一位
            L->data[k + 1] = L->data[k];
        }
    }
    L->data[i - 1] = e; //将新元素插入
    L->length++;
    return OK;
}

// 删除元素
Status ListDelete(Sqlist *L, int i, ElemType *e) {
    int k;
    if (L->length == 0) { return ERROR; }
    if (i < 1 || i > L->length) { return ERROR; }
    *e = L->data[i - 1];
    if (i < L->length) {
        for (k = i; k < L->length; k++) {
            L->data[k - 1] = L->data[k];
        }
    }
    L->length--;
    return OK;
}

    线性表顺序存储结构的优缺点

    优点

    • 无须为表示表中元素之间的逻辑关系而增加额外的存储空间。
    • 可以快速的存取表中任一位置的元素。

    缺点

    • 插入和删除操作需要移动大量元素。
    • 当线性表长度变化较大时，难以确定存储空间的容器。
    • 造成存储空间的“碎片”。

    线性表的链式存储结构

    为了表示每个数据元素ai 与其直接后继元素ai + 1之间的逻辑关系，对数据元素ai来说，除了存储其本身的信息之外，还需存出一个指示其直接后继的信息(即直接后继的存储位置)。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称做指针或链。这两部分信息组成数据元素ai的存储映像，称为结点(Node)。

    n个结点(ai 的存储映像)链结成一个链表，即为线性表的链式存储结构，因为此链表的每个结点中只包含一个指针域，所以叫做单链表。

    链表中第一个结点的存储位置叫做头指针，最后一个结点指针为NULL或"^"，同时在单链表的第一个结点钱附设一个结点，称为头结点。头结点的指针域存储指向第一个结点的指针。

    头指针与头结点的异同

    • 头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。
    • 头指针具有标识作用，所以常用头指针冠以链表的名字。
    • 无论链表是否为空，头指针是链表的必要元素
    • 头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义(也可存放链表的长度)。
    • 有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其他结点的操作就统一了。
    • 头结点不一定是链表必须要素。

    单链表的查询，插入与删除

    所花的时间复杂度都为O(n)，对于插入或删除数据越频繁的操作，单链表的效率优势就越明显。

    typedef struct Node {
    ElemType data;
    struct Node *next;
}Node;

typedef struct Node *LinkList;

//根据下标查找元素
Status GetElem(LinkList L, int i, ElemType *e) {
    int j = 1;
    LinkList p;
    p = L->next;
    while (j < i && p) {
        p = p->next;
        ++j;
    }
    if (!p || j > i) { return ERROR; }
    
    *e = p->data;
    return OK;
}

//插入元素
Status ListInsert(LinkList *L, int i, ElemType e) {
    int j = 1;
    LinkList p, s;
    p = *L;
    while (p && j < i) {
        p = p->next;
        ++j;
    }
    if (!p || j > i) { return ERROR; }
    
    s = (LinkList)malloc(sizeof(Node));
    s->data = e;
    s->next = p->next;
    p->next = s;
    
    return OK;
}

//删除元素
Status ListDelete(LinkList *L, int i, ElemType *e) {
    int j = 1;
    LinkList p, q;
    p = *L;
    while (p && j < i) {
        p = p->next;
        ++j;
    }
    if (!p || j > i) { return ERROR; }
    
    q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    
    return OK;
}

    单链表的整表创建与删除

    创建

//随机产生n个元素的值，建立带表头结点的单线性表L(头插法)
void CreateListHead(LinkList *L, int n) {
    LinkList p;
    srand(time(0)); /*初始化随机数种子*/
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;  /*建立一个带头结点的单链表*/
    
    for (int i = 0; i < n; i++) {
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand() % 100 + 1;
        p->next = (*L)->next;
        (*L)->next = p;
    }
}

//尾插法
void CreateListTail(LinkList *L, int n) {
    LinkList p, r;
    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;  /*r为指向尾部的结点*/
    
    for (int i = 0; i < n; i++) {
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand() % 100 + 1;
        r->next = p;
        r = p;  /*把r的位置移到p，相当于r在整个单链表的最后面*/
    }
    r->next = NULL;   /*再让r->next = NULL，确认为尾部*/

//不明白的地方: r = *L。L为结构体指针，指向链表中的第一个结点，一个空链表第一个结点就直接->NULL了，这里的赋值直接让r指向尾部的结点
}

删除
Status ClearList(LinkList *L) {
    LinkList p, q;
    p = (*L) ->next;
    while (p) {
        q = p->next;
        free(p);
        p = q;
    }
    
    (*L)->next = NULL;
    return OK;
}

*L是指整个单链表，而r是指向尾结点的变量，r会随着循环不断地变化结点，而L则是随着循环增长为一个多结点的链表。

    单链表结构与顺序存储结构优缺点

    存储分配方式

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

    时间性能

    • 查找
      • 顺序存储结构O(1)。
      • 单链表O(n)。
    • 插入和删除
      • 顺序存储结构需要平均移动表长一半的元素，时间为O(n)。
      • 单链表在线出某位置的指针后，插入和删除时间仅为O(1)。

    空间性能

    • 顺序存储结构需要预分配存储空间，分大了，浪费，分小了易发生上溢。
    • 单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制。

    静态链表

    定义一个数组，其中数组中的元素由两个数据域组成，data与cur。data用来存放数据元素，cur相当于单链表中的next指针，存放该元素的后继在数组中的下标，通常也成为游标。这种数组描述的链表叫做静态链表，也叫做游标实现法。
    对数组第一个和最后一个元素作为特殊元素处理，不存数据。通常把未被使用的数据元素称为备用元素。而数组第一个元素，即下标为0的元素的cur就存放备用链表的第一个结点的下标(空闲空间的下标)；而最后一个元素的cur则存放第一个有元素值的下标，相当于单链表中的头结点作用，当整个链表为空时，则为0²。

    静态链表的创建，插入和删除

    typedef struct {
    ElemType data;i
    int cur;
}Component, StaticLinkList[MAXSIZE];

//创建
Status InitList(StaticLinkList space) {
    for (int i = 0; i < MAXSIZE; i++) {
        space[i].cur = i + 1;
    }
    space[MAXSIZE - 1].cur = 0; /*目前静态链表为空，最后一个元素的cur为0*/
    return OK;
}

//插入
/*若备用空间链表非空，则返回分配的结点下标，否则返回0*/
int Malloc_SLL(StaticLinkList space) {
    int i = space[0].cur;
    if (space[0].cur) { 
        space[0].cur = space[i].cur;
    }
    return i;
}

/*在L中第i个元素之前插入新的数据元素e*/
// 假设L的第一个cur为7，i为3
Status ListInsert(StaticLinkList L, int i, ElemType e) {
    int j, k;
    k = MAXSIZE - 1; // k = 9
    if (i < 1 || i > ListLength(L) + 1) { return ERROR; }
    j = Malloc_SLL(L); // j = 7，备用链表的值为8
    if (j) {
        L[j].data = e; //下标7的数据源为e
        for (int l = 1; l <= i - 1; l++) {
            k = L[k].cur; // k = L[1].cur = 2       
        }
        L[j].cur = L[k].cur; // L[7].cur = L[2].cur = 3
        L[k].cur = j; // L[2].cur = 7
        return OK;
    }
    return ERROR;
}

大致思路为: 把新的数据元素添加到最后，然后找到i - 1的cur(游标)与备用链表的cur进行交换。使得i  - 1的cur直接指向当前链表的备用

/*删除在L中第i个数据元素e*/
Status ListDelete(StaticLinkList L, int i) {
    int j = 0, k = MAXSIZE - 1;
    if (i < 1 || i > ListLength(L)) { return ERROR; }
    for (j = i; j <= i - 1; j++) {
        k = L[k].cur;
    }
    j = L[k].cur;
    L[k].cur = L[j].cur;
    Free_SSL(L, j);
    return OK;
}

/*返回L中数据元素个数*/
int ListLength(StaticLinkList L) {
    int j = 0;
    int i = L[MAXSIZE - 1].cur;
    while (i) {
        i = L[i].cur;
        j++;
    }
    return j;
}

/*将下标为k的空闲结点回收到备用链表*/
void Free_SSL(StaticLinkList space, int k) {
    space[k].cur = space[0].cur;
    space[0].cur = k;
}

    静态链表优缺点

    优点

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

    缺点

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

    循环链表

    将单链表中终端结点的指针端由空指针改为指向头结点，就使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表，简称循环链表。

    举例: 合并两个循环列表
代码示例
假设两个循环链表的尾指针为rearA何rearB

p = rearA->next; //拿到头结点
rearA->next = rearB->next->next; //A链表尾结点就指向了B链表的第一个结点
q = rearB->next;
rearB->next = p; //B链表的尾结点指向了A链表的头结点
free(q);

    双向链表

    双向链表是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。

    typedef struct DulNode {
    ElemType data;
    struct DulNode *prior;
    struct DulNode *next;
}DulNode, *DuLinkList;

//插入
/*p为要插入的下标的前一个结点，s为要插入的结点*/
s->prior = p;
s->next = p->next;
p->next->prior = s;
p->next = s;

//删除
/*p为要删除的结点*/
p->prior->next = p->next;
p->next->prior = p->prior;
free(p);

    相关文章

      网友评论

          本文标题：三. 线性表

          本文链接：https://www.haomeiwen.com/subject/spenbftx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|三. 线性表|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！