第3章线性表(一)

最新推荐文章于 2024-07-10 15:18:52 发布

黎丶辰

最新推荐文章于 2024-07-10 15:18:52 发布

阅读量425

点赞数

分类专栏：数据结构文章标签：数据结构算法 c++

本文链接：https://blog.csdn.net/Tian_baby/article/details/123165975

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

第3章线性表

线性表的定义

线性表（List）：零个或者多个数据元素的有限序列。

强调：首先它是一个序列。然后强调线性表是有限的。

(直接)前驱元素、(直接)后继元素。

线性表元素的个数n(n≥0)定义为线性表的长度，当n=0时，称为空表。

线性表的抽象数据类型

ADT 线性表(List)
Data
	线性表的数据对象的集合{a1,a2,a3,……,an},每个元素的类型均为Datatype。其中，
除了第一个元素a1之外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，
每个元素只有一个直接后继元素。数据元素之间的关系是一对一的关系。
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的元素个数。
endADT

线性表的顺序存储结构

顺序存储定义

线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。

顺序存储方式

一般使用一位数组来实现顺序存储结构，把第一个数据元素存到数组下标为0的位置中，接着把线性表相邻的元素存储在数组冲相邻为位置。

线性表的顺序存储代码：

#define MAXSIZE 20			// 存储空间初始化分配量
typedef int ElemType;		// ElemType类型根据实际情况而定，这里假设为int
typedef struct {
    ElemType data[MAXSIZE];	// 数组存储数据元素，最大值为MAXSIZE
    int length;				// 线性表当前长度
}SqList;

这里，我们就发现描述顺序存储结构需要三个属性：

存储空间的起始位置：数组data，它的存储位置就是存储空间的存储空间。
线性表的最大存储容量：数组长度MaxSize。
线性表的当前长度：length。

数据长度与线性表长度区别

线性表的长度是线性表中数据元素的个数。(线性表长度≤数组长度)。

地址计算方法

线性表的第i个元素是要存储在数组下标i-1的位置。

用数组存储顺序表意味着要分配固定长度的数组空间，由于线性表中可以进行插入和删除操作，因此分配的数组空间要大于等于当前线性表的长度。

存储器中的每个存储单元都有自己的编号，这个编号称为地址。

顺序存储结构的插入与删除

获得元素操作（GetElem）

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;

// Status是函数的类型，其值是函数结果状态代码，如OK等
// 初识条件：顺序线性表L已存在，1≤i≤ListLength(L)
// 操作结果：用e返回L中第i个数据元素的值。
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;
}

注意：这里的返回值类型是Status是一个整型，返回OK代表1，ERROR代表0。之后代码中出现不在详解。

插入操作（ListInsert）

插入算法思路：

如果插入位置不合理，抛出异常；
如果线性表长度大于等于数组长度，抛出异常或者动态增加容量。
从最后一个元素开始向前遍历到第i个位置，分别将它们都向后移动一个位置。
将要插入的元素填入位置i处
表长度加一

Status ListInsert(SqList *L, int i, ElemType e) {
    int k;
    if (L->length == MAXSIZE)     //线性表已满
        return ERROR;
    if (i < 1 || i > L->length)        //i不满足范围
        return ERROR;
    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;
}

删除操作

删除的思路：

如果删除位置不合理，抛出异常。
取出删除元素。
从删除元素位置开始遍历到最后一个元素位置，分别将它们都向前移动一个位置；
表长度减一。

代码实现

//删除元素
//初始条件：线性表L已经存在，1≤i≤ListLength(L)
//操作结果：删除L的第i个数据元素，并用e返回其值，L长度减1
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;
}

时间复杂度：

最好的情况是O(1);最坏的情况是O(n)。

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

优点：

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

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

代码汇总

#define MAXSIZE 20            // 存储空间初始化分配量
typedef int ElemType;        // ElemType类型根据实际情况而定，这里假设为int
typedef struct {
    ElemType data[MAXSIZE];    // 数组存储数据元素，最大值为MAXSIZE
    int length;                // 线性表当前长度
} SqList;

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;

// Status是函数的类型，其值是函数结果状态代码，如OK等
// 初识条件：顺序线性表L已存在，1≤i≤ListLength(L)
// 操作结果：用e返回L中第i个数据元素的值。
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;
}

Status ListInsert(SqList *L, int i, ElemType e) {
    int k;
    if (L->length == MAXSIZE)     //线性表已满
        return ERROR;
    if (i < 1 || i > L->length)        //i不满足范围
        return ERROR;
    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;
}

//删除元素
//初始条件：线性表L已经存在，1≤i≤ListLength(L)
//操作结果：删除L的第i个数据元素，并用e返回其值，L长度减1
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;
}

线性表的链式存储结构

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

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

链表中第一个节点的存储位置叫做头指针。整个链表结构的存取就必须从指针开始进行了。链表的最后一个结点指针为空。（NULL或者用“^”符号表示）。

有时候，我们为了方便对链表进行操作，会在单链表的第一个结点前面附设一个结点，称为头结点。这个头结点的数据域可以不存储任何信息。

头指针和头结点的异同

头指针

头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。
头指针具有标识作用，所以常用头指针冠以链表的名字。
无论链表是否为空，头指针均不为空。头指针是链表的必要元素。

头结点

头结点是为了操作统一和方便建立的，放在第一元素的结点之前，其数据域一般无意义(也可以用来存放链表的长度)。
有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作就与其它结点的操作就统一了。
头结点不一定是链表必须要素。

线性表链式存储结构代码描述

带头结点的单链表

C语言结构体指针描述单链表结点。

typedef int ElemType;
typedef struct Node {
    ElemType data;
    struct Node *next;
} Node;
typedef struct Node *LinkList;  //定义LinkList

结点有存放数据元素的数据域和存放后继结点地址的指针域组成。

单链表的读取

获取链表第i个数据的算法思路：

声明一个指针p指向链表第一个结点，初始化j从1开始；
当j < i时，遍历链表，让P的指针向后移动，不断指向下一个结点，j累加1；
若到链表末尾p为空，则说明第i个结点不存在；
否则查找成功，返回p的数据。

代码实现

//初始条件：顺序表L已经存在，1≤i≤ListLength(L);
//操作结果：用e返回第i个数据元素的值。
Status GetElem(LinkList L, int i, ElemType *e) {
    int j;
    LinkList p; // 声明一个指针p
    p = L->next; //p指向链表的第一个结点
    j = 1;
    while (p && j < i) {
        p = p->next;  //p指向下一个指针
        j++;
    }
    if (!p || j > i)
        return ERROR;
    *e = p->data;
    return OK;
}

说白了，就是从头开始找，知道第i个结点为止。核心思想：“工作指针后移。”

时间复杂度分析：最好O(1),最坏O(n)。找第一个或者是最好，找最后一个或者超出范围，是最坏。

单链表的插入与删除

假设要将结点s插入到结点p和p之间：需要

s->next = p->next;/

p->next = s;

单链表第i个数据插入结点的思路：

整体是先找到第i个结点然后插入结点。

声明一指针p指向链表的头结点，初始化j从1开始；
当j<i时，就遍历链表，让p的指针向后移动，不断指向下一节点，j累加1；
若到链表末尾p为空，则说明第i个结点不存在；
如果查找成功，在系统中生成一个空结点s；
将数据元素e赋值给s->data；
单链表插入成功标准语句：s->next= p->next; p->next = s;
插入成功并返回。

代码实现：

//初识条件：顺序线性表L已经存在；1≤i≤ListLength(L)
//操作结果：在L中第i个结点为止之前插入新的数据元素e，L的长度加1
Status ListInsert(LinkList *L,int i ,ElemType e){
    int j;
    LinkList p,s;
    p = *L;
    j = 1;
    //寻找第i-1个结点
    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;
}

单链表的删除

删除链表中的一个结点只要：

p->next = p->next->next;

单链表中第i个数据删除结点的算法思路：

声明一个指针p指向链表的头结点，初始化j从1开始；
当j<i的时候遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1；
若链表到达末尾p为空，说明第i个结点不存在
否则查找成功，将要删除的值赋值给q；
单链表的删除语句：p->next = p->next->next;
将q结点中的数据赋值给e，作为返回(不是返回值是利用指针访问地址来返回)。
释放q结点空间
返回成功。

代码实现：

//初识条件：顺序线性表L已经存在；1≤i≤ListLength(L)
//操作结果：删除L的第i个结点，并用e返回其值，L的长度减1
Status ListDelete(LinkList *L, int i, ElemType *e) {
    int j;
    LinkList p, q;
    p = *L;
    j = 1;
    //寻找第i个结点
    while (p->next && j < i) {
        p = p->next;
        j++;
    }
    if (!(p->next) || j > i)
        return ERROR;
    q = p->next;
    p->next = q->next;//相当于p->next = p->next->next
    *e = q->data;
    free(q);
    return OK;
}

对整个算法。我们可以容易得出插入删除的时间复杂度都是O(n),主要是寻找的时候比较复杂。插入和删除都是O(1)。

单链表的整表创建

单链表整表创建的算法思路：

声明一个指针p和计数器i；
初始化一个空链表L；
让L的头结点的指针指向NULL，即建立一个带头结点的单链表；
循环创建结点：
1. 生成一个新的节点赋值给p；
2. 随机生成一个数字赋值给p的数字域p->data；
3. 将p插入到头结点与前一个新节点之间。

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

上面的这种是头插法，将新建的结点插在，头结点和原来的head->next中间。还有一种方式是尾插法。

// 随机产生n个元素的值，建立带表头结点的单链线性表(尾插法)
void CreateListTail(LinkList *L, int n) {
    LinkList p, r;       //p用来表示新生成的结点，r用来表示队尾结点。
    int i;
    srand(time(0));
    *L = (LinkList) malloc(sizeof(Node));  // 整个线性表
    r = *L;
    for (i = 0; i < n; ++i) {
        p = (Node *) malloc(sizeof(Node)); //生成新的结点
        p->data = rand() % 100 + 1;
        //现在r是当前已生成链表的队尾结点，p是新的结点。
        r->next = p;        //将表尾终端结点的指针指向新结点
        r = p;              //将新定义的结点定义为队尾结点
    }
    r->next = NULL;        //表示当前链表结束
}

循环结束后应该让队尾指针置空，以便于遍历的时候确定是队尾。

单链表的整表删除

算法思路：

声明一个结点p和q；
将第一个结点赋值给p；
循环
1. 将下一结点赋值给q；
2. 释放p
3. 将q赋值给p。

代码实现：

//初始条件：顺序表L已经存在。
//操作：将L重置为空表
Status ClearList(LinkList *L) {
    LinkList p, q;
    p = (*L)->next;
    while (p) {  //没有到队尾
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;
    return OK;
}

得先完成当前节点对于下一个结点的备份才能释放当前结点。

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

存储方式：

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

时间性能：

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

空间性能

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

通过上面的对比，我们得出一些经验性的结论：

若线性表需要频繁查找，很少进行插入和删除操作时，宜采用顺序存储结构。若需要频繁插入和删除时，宜采用单链表结构。
当线性表中的元素个数变化较大，或者根本不知道有多大时，最好用单链表结构，这样可以不需要考虑存储空间的大小问题。

黎丶辰

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
第3章线性表(一)

第3章线性表线性表的定义线性表（List）：零个或者多个数据元素的有限序列。强调：首先它是一个序列。然后强调线性表是有限的。 (直接)前驱元素、(直接)后继元素。线性表元素的个数n(n≥0)定义为线性表的长度，当n=0时，称为空表。线性表的抽象数据类型ADT 线性表(List)Data 线性表的数据对象的集合{a1,a2,a3,……,an},每个元素的类型均为Datatype。其中，除了第一个元素a1之外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每个
复制链接

扫一扫