码迷，mamicode.com
首页 > 其他好文 > 详细

【algo&ds】2.线性表

时间：2019-11-17 19:24:50      阅读：88      评论：0      收藏：0      [点我收藏+]

标签：ndk   改变   png   含义   eem   struct   表头   技术   hash   

1.线性表

线性表（英语：Linear List）是由n（n≥0）个数据元素（结点）a[0]，a[1]，a[2]…，a[n-1]组成的有限序列。

其中：

  • 数据元素的个数n定义为表的长度 = "list".length() （"list".length() = 0（表里没有一个元素）时称为空表）
  • 将非空的线性表（n>=1）记作：（a[0]，a[1]，a[2]，…，a[n-1]）
  • 数据元素a[i]（0≤i≤n-1）只是个抽象符号，其具体含义在不同情况下可以不同

一个数据元素可以由若干个数据项组成。数据元素称为记录，含有大量记录的线性表又称为文件。这种结构具有下列特点：存在一个唯一的没有前驱的（头）数据元素；存在一个唯一的没有后继的（尾）数据元素；此外，每一个数据元素均有一个直接前驱和一个直接后继数据元素。

2.线性表的存储结构

  • 顺序表
  • 链表
    • 单链表
      • 动态单链表
      • 静态单链表
    • 双链表
    • 循环链表
      • 单循环链表
      • 双循环链表
    • 静态链表

3.顺序表

利用数组的连续存储空间顺序存放线性表的各元素

技术图片

3.1结构体定义

如果需要使用自定义的结构体来维护一个顺序表，通常来讲结构体的元素一般是一个固定大小的数组（可用长度足够大），以及当前数组存放的元素个数，也即数组的长度

typedef struct LNode *List;
struct LNode {
    ElementType Data[MAXSIZE];
    int Last;//记录顺序表的最后一个元素的下标
} ;
struct LNode L;
List PtrL;

访问结构体的成员

  • 访问下标为 i 的元素：L.Data[i] 或 PtrL->Data[i]
  • 线性表的长度：L.Last+1 或 PtrL->Last+1
  • 指针变量PtrL还可以这样访问两个属性(*PtrL).Data[i]和(*PtrL).Last，不过这种访问方式并不常用

而一般来讲，为了简单，不会去维护这样一个结构体，(因为一旦维护了这个结构体，就需要去封装相应的函数，比如说常见的插入、删除、查找等操作)，而是直接类似下面这样

ElementType data[MaxSize];
int length;

定义一个足够大的数组，然后定义一个对应关联的变量来时刻维护数组的长度。

这两种定义方式没有什么区别，一种是把常用操作封装好，方便调用，另一种则是需要时刻自己维护对应的属性。因为顺序表的结构足够简单，所以不定义结构体也是可以的。

3.2顺序表的常见操作

为了方便，这一节内容记录的都是在定义的结构体基础上，封装的常见操作。

1.初始化

List MakeEmpty( ) {
    List PtrL;
    PtrL = (List )malloc( sizeof(struct LNode) );
    PtrL->Last = -1;
    return PtrL;
}

初始化的顺序表，长度为0，所以Last为-1

2.查找

int Find( ElementType X, List PtrL ) {
    int i = 0;
    while( i <= PtrL->Last && PtrL->Data[i]!= X )
        i++;
    if (i > PtrL->Last) return -1; /* 如果没找到，返回-1 */
    else return i; /* 找到后返回的是存储位置 */
}

查找操作比较简单，从顺序表的第一个元素（下标为0开始）开始遍历。

还有一种更加巧妙一点的实现方式，就是引入哨兵思想。

int Find( ElementType X, List PtrL ) {
    PtrL->Data[0] = x;//顺序表第一个元素就是哨兵，赋值为x
    int i = PtrL->Last;//从最后一个元素开始遍历
    while( PtrL->Data[i]!= X )
        i--;
    return i;
}

这样做的好处很明显，少了边界的判断，可以优化时间复杂度，编码也更加简单。

注意：这里把下标为0的元素设置为哨兵，则要求顺序表从下标为1开始存储。而且，函数如果没有找到，则一定返回i=0

3.插入

技术图片

看图示应该要注意，移动的方向是从后往前移，如果从前往后移，则Data[i]=Data[i+1]=...=Data[n]，因为后面的元素都被前面移过来的元素给覆盖了。

void Insert( ElementType X, int i, List PtrL ) {
    int j;
    if ( PtrL->Last == MAXSIZE-1 ) { /* 表空间已满，不能插入*/
        printf(＂表满＂);
        return;
    }
    if ( i < 1 || i > PtrL->Last+2) { /*检查插入位置的合法性*/
        printf(＂位置不合法＂);
        return;
    }
    for ( j = PtrL->Last; j >= i-1; j-- )
        PtrL->Data[j+1] = PtrL->Data[j]; /*将 ai～ an倒序向后移动*/
    PtrL->Data[i-1] = X; /*新元素插入*/
    PtrL->Last++; /*Last仍指向最后元素*/
    return;
}

为什么这里需要判断顺序表的空间是否已满？

因为这个数组，是在初始化之后就固定了数组可容纳的元素个数MaxSize，一旦超出，则程序下标就会越界。C++提供了动态数组vector，可以很方便的支持动态扩展数组长度，而且基本的插入删除等操作都封装好了，可以很方便的使用。

4.删除

技术图片

同样的，需要注意元素移动的方向，如果从后往前移，则最后面的元素会一直覆盖到Data[i]。

void Delete( int i, List PtrL ) {
    int j;
    if( i < 1 || i > PtrL->Last+1 ) { /*检查空表及删除位置的合法性*/
        printf (“不存在第%d个元素”, i );
        return ;
    }
    for ( j = i; j <= PtrL->Last; j++ )
        PtrL->Data[j-1] = PtrL->Data[j]; /*将 ai+1～ an顺序向前移动*/
    PtrL->Last--; /*Last仍指向最后元素*/
    return;
}

5.排序

因为排序算法比较多，本文不展开讲解，可以参考以下博文，内容包括了常见的十大排序算法的算法分析，时间复杂度和空间复杂度分析以及c实现和动图图解。

https://www.cnblogs.com/ericling/p/11877219.html

4.链表

不要求逻辑上相邻的两个元素物理上也相邻；通过“链”建立起数据元素之间的逻辑关系。插入、删除不需要移动数据元素，只需要修改“链”。

4.1单链表

技术图片

typedef struct LNode *List;
struct LNode {
    ElementType Data;
    List Next;
};
struct Lnode L;
List PtrL;
1.求表长
int Length ( List PtrL ) {
    List p = PtrL; /* p指向表的第一个结点*/
    int j = 0;
    while ( p ) {
        p = p->Next;
        j++; /* 当前p指向的是第 j 个结点*/
    }
    return j;
}

时间复杂度O(n)

2.查找

按序查找

List FindKth( int K, List PtrL ) {
    List p = PtrL;
    int i = 1;
    while (p !=NULL && i < K ) {
        p = p->Next;
        i++;
    }
    if ( i == K ) return p;
    /* 找到第K个，返回指针 */
    else return NULL;
    /* 否则返回空 */
}

时间复杂度O(n)

按值查找

List Find( ElementType X, List PtrL ) {
    List p = PtrL;
    while ( p!=NULL && p->Data != X )
        p = p->Next;
    return p;
}

时间复杂度O(n)

3.插入

（1）先构造一个新结点，用s指向；
（2）再找到链表的第 i-1个结点，用p指向；
（3）然后修改指针，插入结点 ( p之后插入新结点是 s)

List Insert( ElementType X, int i, List PtrL ) {
    List p, s;
    if ( i == 1 ) { /* 新结点插入在表头 */
        s = (List)malloc(sizeof(struct LNode)); /*申请、填装结点*/
        s->Data = X;
        s->Next = PtrL;
        return s; /*返回新表头指针*/
    }
    p = FindKth( i-1, PtrL ); /* 查找第i-1个结点 */
    if ( p == NULL ) { /* 第i-1个不存在，不能插入 */
        printf("参数i错");
        return NULL;
    } else {
        s = (List)malloc(sizeof(struct LNode)); /*申请、填装结点*/
        s->Data = X;
        s->Next = p->Next; /*新结点插入在第i-1个结点的后面*/
        p->Next = s;
        return PtrL;
    }
}
4.删除

（1）先找到链表的第 i-1个结点，用p指向；
（2）再用指针s指向要被删除的结点（p的下一个结点）;
（3）然后修改指针，删除s所指结点;
（4）最后释放s所指结点的空间。

List Delete( int i, List PtrL ) {
    List p, s;
    if ( i == 1 ) { /* 若要删除的是表的第一个结点 */
        s = PtrL; /*s指向第1个结点*/
        if (PtrL!=NULL) PtrL = PtrL->Next; /*从链表中删除*/
        else return NULL;
        free(s); /*释放被删除结点 */
        return PtrL;
    }
    p = FindKth( i-1, PtrL ); /*查找第i-1个结点*/
    if ( p == NULL ) {
        printf("第%d个结点不存在", i-1);
        return NULL;
    } else if ( p->Next == NULL ) {
        printf("第%d个结点不存在", i);
        return NULL;
    } else {
        s = p->Next; /*s指向第i个结点*/
        p->Next = s->Next; /*从链表中删除*/
        free(s); /*释放被删除结点 */
        return PtrL;
    }
}

4.2双链表

技术图片

双向链表，又称为双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

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

4.3循环链表

4.3.1单循环链表

存储结构和单链表相同。

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

// 设立尾指针的单循环链表的12个基本操作
void InitList(LinkList *L) { // 操作结果：构造一个空的线性表L
    *L = (LinkList)malloc(sizeof(struct LNode)); // 产生头结点，并使L指向此头结点
    if (!*L) // 存储分配失败
        exit(OVERFLOW);
    (*L)->next = *L; // 指针域指向头结点
}

void DestroyList(LinkList *L) { // 操作结果：销毁线性表L
    LinkList q, p = (*L)->next; // p指向头结点
    while (p != *L) { // 没到表尾
        q = p->next;
        free(p);
        p = q;
    }
    free(*L);
    *L = NULL;
}

void ClearList(LinkList *L) /* 改变L */ { // 初始条件：线性表L已存在。操作结果：将L重置为空表
    LinkList p, q;
    *L = (*L)->next; // L指向头结点
    p = (*L)->next; // p指向第一个结点
    while (p != *L) { // 没到表尾
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = *L; // 头结点指针域指向自身
}

Status ListEmpty(LinkList L) { // 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
    if (L->next == L) // 空
        return TRUE;
    else
        return FALSE;
}

int ListLength(LinkList L) { // 初始条件：L已存在。操作结果：返回L中数据元素个数
    int i = 0;
    LinkList p = L->next; // p指向头结点
    while (p != L) { // 没到表尾
        i++;
        p = p->next;
    }
    return i;
}

Status GetElem(LinkList L, int i, ElemType *e) { // 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
    int j = 1; // 初始化，j为计数器
    LinkList p = L->next->next; // p指向第一个结点
    if (i <= 0 || i > ListLength(L)) // 第i个元素不存在
        return ERROR;
    while (j < i) { // 顺指针向后查找，直到p指向第i个元素
        p = p->next;
        j++;
    }
    *e = p->data; // 取第i个元素
    return OK;
}

int LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType)) { // 初始条件：线性表L已存在，compare()是数据元素判定函数
    // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
    //           若这样的数据元素不存在，则返回值为0
    int i = 0;
    LinkList p = L->next->next; // p指向第一个结点
    while (p != L->next) {
        i++;
        if (compare(p->data, e)) // 满足关系
            return i;
        p = p->next;
    }
    return 0;
}

Status PriorElem(LinkList L, ElemType cur_e, ElemType *pre_e) { // 初始条件：线性表L已存在
    // 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
    //           否则操作失败，pre_e无定义
    LinkList q, p = L->next->next; // p指向第一个结点
    q = p->next;
    while (q != L->next) { // p没到表尾
        if (q->data == cur_e) {
            *pre_e = p->data;
            return TRUE;
        }
        p = q;
        q = q->next;
    }
    return FALSE; // 操作失败
}

Status NextElem(LinkList L, ElemType cur_e, ElemType *next_e) { // 初始条件：线性表L已存在
    // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
    //           否则操作失败，next_e无定义
    LinkList p = L->next->next; // p指向第一个结点
    while (p != L) { // p没到表尾
        if (p->data == cur_e) {
            *next_e = p->next->data;
            return TRUE;
        }
        p = p->next;
    }
    return FALSE; // 操作失败
}

Status ListInsert(LinkList *L, int i, ElemType e) /* 改变L */ { // 在L的第i个位置之前插入元素e
    LinkList p = (*L)->next, s; // p指向头结点
    int j = 0;
    if (i <= 0 || i > ListLength(*L) + 1) // 无法在第i个元素之前插入
        return ERROR;
    while (j < i - 1) { // 寻找第i-1个结点
        p = p->next;
        j++;
    }
    s = (LinkList)malloc(sizeof(struct LNode)); // 生成新结点
    s->data = e; // 插入L中
    s->next = p->next;
    p->next = s;
    if (p == *L) // 改变尾结点
        *L = s;
    return OK;
}

Status ListDelete(LinkList *L, int i, ElemType *e) /* 改变L */ { // 删除L的第i个元素，并由e返回其值
    LinkList p = (*L)->next, q; // p指向头结点
    int j = 0;
    if (i <= 0 || i > ListLength(*L)) // 第i个元素不存在
        return ERROR;
    while (j < i - 1) { // 寻找第i-1个结点
        p = p->next;
        j++;
    }
    q = p->next; // q指向待删除结点
    p->next = q->next;
    *e = q->data;
    if (*L == q) // 删除的是表尾元素
        *L = p;
    free(q); // 释放待删除结点
    return OK;
}

void ListTraverse(LinkList L, void(*vi)(ElemType)) { // 初始条件：L已存在。操作结果：依次对L的每个数据元素调用函数vi()
    LinkList p = L->next->next; // p指向首元结点
    while (p != L->next) { // p不指向头结点
        vi(p->data);
        p = p->next;
    }
    printf("\n");
}

4.3.2双循环链表

// 线性表的双向链表存储结构
typedef struct DuLNode {
    ElemType data;
    struct DuLNode *prior, *next;
} DuLNode, *DuLinkList;

// 带头结点的双向循环链表的基本操作(14个)
void InitList(DuLinkList *L) {
    // 产生空的双向循环链表L
    *L = (DuLinkList)malloc(sizeof(DuLNode));
    if (*L)
        (*L)->next = (*L)->prior = *L;
    else
        exit(OVERFLOW);
}

void DestroyList(DuLinkList *L) {
    // 操作结果：销毁双向循环链表L
    DuLinkList q, p = (*L)->next; // p指向第一个结点
    while (p != *L) { // p没到表头
        q = p->next;
        free(p);
        p = q;
    }
    free(*L);
    *L = NULL;
}

void ClearList(DuLinkList L) { // 不改变L
    // 初始条件：L已存在。操作结果：将L重置为空表
    DuLinkList q, p = L->next; // p指向第一个结点
    while (p != L) { // p没到表头
        q = p->next;
        free(p);
        p = q;
    }
    L->next = L->prior = L; // 头结点的两个指针域均指向自身
}

Status ListEmpty(DuLinkList L) {
    // 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
    if (L->next == L && L->prior == L)
        return TRUE;
    else
        return FALSE;
}

int ListLength(DuLinkList L) {
    // 初始条件：L已存在。操作结果：返回L中数据元素个数
    int i = 0;
    DuLinkList p = L->next; // p指向第一个结点
    while (p != L) { // p没到表头
        i++;
        p = p->next;
    }
    return i;
}

Status GetElem(DuLinkList L, int i, ElemType *e) {
    // 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
    int j = 1; // j为计数器
    DuLinkList p = L->next; // p指向第一个结点
    while (p != L && j < i) { // 顺指针向后查找，直到p指向第i个元素或p指向头结点
        p = p->next;
        j++;
    }
    if (p == L || j > i) // 第i个元素不存在
        return ERROR;
    *e = p->data; // 取第i个元素
    return OK;
}

int LocateElem(DuLinkList L, ElemType e, Status(*compare)(ElemType, ElemType)) {
    // 初始条件：L已存在，compare()是数据元素判定函数
    // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
    // 若这样的数据元素不存在，则返回值为0
    int i = 0;
    DuLinkList p = L->next; // p指向第1个元素
    while (p != L) {
        i++;
        if (compare(p->data, e)) // 找到这样的数据元素
            return i;
        p = p->next;
    }
    return 0;
}

Status PriorElem(DuLinkList L, ElemType cur_e, ElemType *pre_e) {
    // 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
    // 否则操作失败，pre_e无定义
    DuLinkList p = L->next->next; // p指向第2个元素
    while (p != L) { // p没到表头
        if (p->data == cur_e) {
            *pre_e = p->prior->data;
            return TRUE;
        }
        p = p->next;
    }
    return FALSE;
}

Status NextElem(DuLinkList L, ElemType cur_e, ElemType *next_e) {
    // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
    // 否则操作失败，next_e无定义
    DuLinkList p = L->next->next; // p指向第2个元素
    while (p != L) { // p没到表头
        if (p->prior->data == cur_e) {
            *next_e = p->data;
            return TRUE;
        }
        p = p->next;
    }
    return FALSE;
}

DuLinkList GetElemP(DuLinkList L, int i) { // 另加
    // 在双向链表L中返回第i个元素的地址。i为0，返回头结点的地址。若第i个元素不存在，
    // 返回NULL
    int j;
    DuLinkList p = L; // p指向头结点
    if (i < 0 || i > ListLength(L)) // i值不合法
        return NULL;
    for (j = 1; j <= i; j++)
        p = p->next;
    return p;
}

Status ListInsert(DuLinkList L, int i, ElemType e) {
    // 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1
    // 改进算法2.18，否则无法在第表长+1个结点之前插入元素
    DuLinkList p, s;
    if (i < 1 || i > ListLength(L) + 1) // i值不合法
        return ERROR;
    p = GetElemP(L, i - 1); // 在L中确定第i个元素前驱的位置指针p
    if (!p) // p=NULL,即第i个元素的前驱不存在(设头结点为第1个元素的前驱)
        return ERROR;
    s = (DuLinkList)malloc(sizeof(DuLNode));
    if (!s)
        return OVERFLOW;
    s->data = e;
    s->prior = p; // 在第i-1个元素之后插入
    s->next = p->next;
    p->next->prior = s;
    p->next = s;
    return OK;
}

Status ListDelete(DuLinkList L, int i, ElemType *e) {
    // 删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
    DuLinkList p;
    if (i < 1) // i值不合法
        return ERROR;
    p = GetElemP(L, i); // 在L中确定第i个元素的位置指针p
    if (!p) // p = NULL,即第i个元素不存在
        return ERROR;
    *e = p->data;
    p->prior->next = p->next; // 此处并没有考虑链表头，链表尾
    p->next->prior = p->prior;
    free(p);
    return OK;
}

void ListTraverse(DuLinkList L, void(*visit)(ElemType)) {
    // 由双链循环线性表L的头结点出发，正序对每个数据元素调用函数visit()
    DuLinkList p = L->next; // p指向头结点
    while (p != L) {
        visit(p->data);
        p = p->next;
    }
    printf("\n");
}

void ListTraverseBack(DuLinkList L, void(*visit)(ElemType)) {
    // 由双链循环线性表L的头结点出发，逆序对每个数据元素调用函数visit()
    DuLinkList p = L->prior; // p指向尾结点
    while (p != L) {
        visit(p->data);
        p = p->prior;
    }
    printf("\n");
}

4.4静态链表

前面讲解的都是动态链表，即需要指针来建立结点之间的连接关系。而对有些问题来说结点的地址是比较小的整数（例如5位数的地址），这样就没有必要去建立动态链表，而应使用方便得多的静态链表。
静态链表的实现原理是hash，即通过建立一个结构体数组，并令数组的下标直接表示结点的地址，来达到直接访问数组中的元素就能访问结点的效果。另外，由于结点的访问非常方便，因此静态链表是不需要头结点的。静态链表结点定义的方法如下：

struct Node{
    typename data;//数据域
    int next;//指针域
}node[size];

参考资料：

【algo&ds】2.线性表

标签：ndk   改变   png   含义   eem   struct   表头   技术   hash   

原文地址：https://www.cnblogs.com/ericling/p/11877552.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！