数据结构与算法基础（王卓）（3）：关于线性表的操作

已于 2023-05-04 09:02:06 修改
阅读量1k 收藏 5
点赞数
分类专栏： 数据结构（王卓） 文章标签： 数据结构
于 2022-12-01 19:30:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zz_zzzzzzz__/article/details/128104788
版权

目录

前置：

二、线性表的销毁

三、线性表的清空

四、线性表是否为空 

五、返回线性表元素个数

六、返回线性表第i个元素值

重难点算法：（算法时间复杂度:O(n)）

七、查找元素

八、线性表的插入

九、线性表的删除

十、定位元素位序（第几个元素）

十一、指定元素的前驱与后继

十二（附加）、对线性表内部所有元素进行统一同一操作

前置：

//#include<iostream>
#include<stdlib.h>//存放exit

#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
#define OVERFLOW   -2   

#define MAXlength 100  //初始大小为100，可按需修改

typedef int Status;         //函数调用状态

struct Poly
{
    float p;
    int e;
};

struct Sqlist
{
    Poly* elem;
    int length;
};

位置：PPT第二章：72

二、线性表的销毁

void DestroyList(Sqlist& L)
{
    if (L.elem) delete L.elem;
}

三、线性表的清空

void ClearList(Sqlist& L)
{
    L.length = 0;
    //将线性表的长度设置为0
}

四、线性表是否为空 

int IsEmpty(Sqlist L)
{
    if (L.length == 0)
        return true;
    else
        return false;
}

五、返回线性表元素个数

int Listlength(Sqlist L)
{
    return L.length;
}

六、返回线性表第i个元素值

int GetElem(Sqlist L,int i,Poly ele)//element:元素
{
    if (i <= 0 || i > L.length)
        return ERROR;
        ele = L.elem[i-1];
        return OK;
}

int GetElem(Sqlist L,int i,Poly ele)//element:元素
{
    if (i <= 0 || i > L.length)
        return ERROR;
        ele = L.elem[i-1];
        return OK;
}

或者：

bool GetELem(const SqList &L, const size_t i, ElemType &e)
{
    if(i<1 || i>MAXSIZE)
    {
        cerr<<"out of range"<<endl;
        return false;
    }
    e = L.elem[i-1];
    return true;
}

 ele = L.elem[i-1]:

elem是结构体Sqlist里面的一个指针（型）变量成员，指向一个Ploy类型的目标变量

也就是说，其本身就是这个类型的对象的首地址，至于剩下的，就不用我多说了吧

如果还要我说，那就详见：C语言日记 25 指针与数组_宇 -Yu的博客-CSDN博客

另外，视频里没有说，但是介绍基本操作时要求的操作：

定位元素位序（第几个元素）

指定元素的前驱与后继

对线性表内部所有元素进行统一同一操作

这几个操作算法，我们在本文末尾再补充完整

这个（以上）算法的复杂度都为常量阶O(1)

顺序表可以随机存取（只要进行一次赋值操作，想要哪个都可以）这是其非常大的优点

比如链表就没有（不能实现）这样的功能

重难点算法：（算法时间复杂度:O(n)）

七、查找元素

project1：

int LocateElem(Sqlist L, Poly i)
{
    int a;
    for (a = 0; L.elem[a] != i; a++);
    cout << "元素序号:  " << a << endl;
    // cout<<

}

注意，我们要的，是把所有符合条件的元素筛选出来，而不是只选取第一个：

project2：

int LocateElem(Sqlist L, Poly i)
{
    for (int a = 0; a <= L.length; a++)
    {
        if (i == L.elem[a])
            return a + 1;
        return 0;
    }
}

可结果却显示：

 为什么？？？ 

完整代码：

#include<stdlib.h>
#include<math.h>//OVERFLOW,exit
#define OK          1
struct Poly
{
    float p;
    int e;
};

struct Sqlist
{
    Poly* elem;
    int length;
};


int LocateElem(Sqlist L, Poly i)
{
    for (int a = 0; a <= L.length; a++)
    {
        if (i == L.elem[a])
            return a + 1;
        return 0;
    }
}

原因不在我写的操作函数里，而是在前面的类体当中；

究其根本原因，还是因为：==不能直接比较结构体，需要手撸比较的工具：

    bool operator==(Poly& t) 
    {
        return t.p == p && t.e == e;
    }

project 3：

#include<math.h>//OVERFLOW,exit
#define OK          1
struct Poly
{
    float p;
    int e;
    bool operator==(Poly& t) 
    {
        return t.p == p && t.e == e;
    }
};

struct Sqlist
{
    Poly *elem;
    int length;
};


int LocateElem(Sqlist L, Poly i)
{
    for (int a = 0; a <= L.length; a++)
    {
        if (i == L.elem[a])
            return a + 1;
        return 0;
    }
}
int main()
{

}

 用while语句实现：

#include<stdlib.h>
#include<math.h>//OVERFLOW,exit
#define OK          1
struct Poly
{
    float p;
    int e;
    bool operator==(Poly& t)
    {    return t.p == p || t.e == e;   }
    bool operator!=(Poly& t)
    {
        return t.p != p && t.e != e;
    }
};

struct Sqlist
{
    Poly* elem;
    int length;
};

int LocateElem(Sqlist L, Poly i)
{
    int a = 0;
    while (a <= L.length && i != L.elem[a])
        a++;
    if(a <= L.length)
        return a + 1;
    return 0;
}
int main()
{

}

八、线性表的插入

project 1：

int ListInsert(Sqlist L,int i,Poly e)
{//insert:插入//i:插入位置(位置序号)
    if (i<1 || i>L.length + 1)
        return ERROR;

    //把插入位置后面的元素全部往后移
    for (int j = L.length - 1; j >= i - 1; j--)//j为下标
        L.elem[j + 1] = L.elem[j];
    //放元素
    L.elem[i-1] =  e;
    return 0;
}

记得（别忘了）写：

    if (L.length == MAXlength)return ERROR;
和

    L.length++;

project 2：

int ListInsert(Sqlist L,int i,Poly e)
{//insert:插入//i:插入位置(位置序号)
    if (i<1 || i>L.length + 1)
        return ERROR;
    if (L.length == MAXlength)return ERROR;//当前储存空间已满
    //把插入位置后面的元素全部往后移
    for (int j = L.length - 1; j >= i - 1; j--)//j为下标
        L.elem[j + 1] = L.elem[j];
    //放元素
    L.elem[i-1] =  e;
    L.length++;
    return 0;
}

//#include<iostream>
#include<stdlib.h>//存放exit

#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
#define OVERFLOW   -2   

#define MAXlength 100  //初始大小为100，可按需修改

typedef int Status;         //函数调用状态

struct Poly
{
    float p;
    int e;
};

struct Sqlist
{
    Poly* elem;
    int length;
};

int ListInsert(Sqlist L,int i,Poly e)
{//insert:插入//i:插入位置(位置序号)
    if (i<1 || i>L.length + 1)
        return ERROR;
    if (L.length == MAXlength)return ERROR;
    //把插入位置后面的元素全部往后移
    for (int j = L.length - 1; j >= i - 1; j--)//j为下标
        L.elem[j + 1] = L.elem[j];
    //放元素
    L.elem[i-1] =  e;
    L.length++;
    return 0;
}
int main()
{

}

注意：

i：位序；不是下标

j：数组下标（用于访问数据）

L.length：总的元素个数，i的最大值

九、线性表的删除

int ListDelete(Sqlist L,int i)
{
    if (i < 1 || i > L.length )
        return ERROR;
    for (int j = i - 1; j <= L.length-1; j++)
        L.elem[j] = L.elem[j + 1];
    L.length--;
}

按照书上的写法：（不要忘了：    return OK;）

int ListDelete(Sqlist L,int i)
{
    if (i < 1 || i > L.length )
        return ERROR;
    for (int j = i ; j <= L.length; j++)
        L.elem[j-1] = L.elem[j];
    L.length--;
    return OK;
}
bool EraseList(Sqlist &L, const int &i)
{
    //异常判断
    if(i<0 || i>L.length)
    {
        cerr << "wrong erase position!" << endl;
        return false;
    }
    if(L.length == 0)
    {
        cerr << "List has no length" << endl;
        return false;
    }
    //将位于删除位置之后的元素依次向前挪动一位
    for (int p = i + 1; p < L.length; ++p)
    {
        L.elem[p - 1] = L.elem[p];
    }
    //线性表长度-1
    L.length -= 1;
    return true;
    //算法时间复杂度：O(n)
}

视频里没有说，但是介绍基本操作时要求的操作：

十、定位元素位序（第几个元素）

Status LoacteElem(Sqlist L, Poly e)
{
    int i = 0;
    if (!&L)//初始条件：L存在
        return false;
    while (L.elem[i] != e)i++;
    if (e == L.elem[i])
        cout << "元素位序为：" << i + 1 << endl;
    return false;
}

 当然，还得在前面手写等于和不等于判断表达式：

struct Poly
{
    float p;
    int e;

    bool operator==(Poly t)
    {
        return t.p == p && t.e == e;
    }
    bool operator!=(Poly t)
    {
        return t.p != p || t.e != e;
    }
};

Issues：

（1）：为什么赋初值时 i = 0；（为什么赋给i = 0？）输出结果时输出 i + 1？

i = 0：

显然，线性表以数组形式进行存储，而数组下标下限默认为0；所以在赋初值时必须令 i = 0（而不是 i = 1）

实现让程序从访问数组首个元素开始对线性表（内的）元素逐个访问寻找元素

输出 i + 1：

每个元素的位序恰巧为其下标加一（例：第一个元素的下标为零）

而在程序跳出其中的while循环以后，i的值恰好为我们所要定位的元素的下标

所以在输出时，其元素位序即为i + 1；

（2）：更改为下图形式为什么会报错？

详细地说：

数组名不是既可以代表（代指）整个数组，又可以代指这个数组的头指针（首个元素的地址）吗？

那么，为什么

  • (!L)无法代表线性表首元素地址
  • L->elem无法访问线性表内的元素
  • 无法用L = (L + 1)让线性表指向下一位地址

 ？？？

原因其实很简单：

L在程序里，作为一个采用引用传值的变量

传过来的默认就是一个线性表，自然无法被看作是一个头指针了

至于为什么不能写L->elem，必须写成 L.elem[i]：

因为我们定义的 Poly* elem本身就是一个指向（Poly型）目标对象的指针

如果一定要使用指针访问来实现这个操作算法，那就利用L.elem作为指针：

Status LoacteElem(Sqlist& L, Poly e)
{
    int i = 0;
    if (!&L)//初始条件：L存在
        return false;
    while (*(L.elem) != e)
    {
        L.elem= L.elem + 1;
        i++;
    }
    if (e == *(L.elem))
        cout << "元素位序为：" << i + 1 << endl;
    return false;
}

在elem不是指针类型（Poly elem）时：（用指针访问）    

Status LoacteElem(Sqlist& L, Poly e)
{
    int i = 0;
    auto p = &L.elem;
    if (!&L)//初始条件：L存在
        return false;
    while (*p != e)
    {
        p++;
        i++;
    }
    if (e == (L.elem))
        cout << "元素位序为：" << i + 1 << endl;
    return false;
}

注意：这种情况下（elem不是指针类型）,不能再想当然地，简单用 

&L.elem = &L.elem + 1;

 来实现由当前元素转移到下一元素，结果：

十一、指定元素的前驱与后继

前驱：

<Prior：先前的，较早的; 优先的，较重要的;  在前面的> 

<current：现在的; 当前的;流通的; 流行的;电流; (海洋或江河的)水流; 气流; ; 潮流; 趋向>

Status PriorElem(Sqlist& L, Poly e_current, Poly& e_prior)
{
    int i = 0;
    if (!&L || L.elem[i] != e_current)
        //L存在且e_current不是第一个元素
        cerr << "无意义" << endl;
        return false;
    while (L.elem[i] != e_current)i++;
    e_prior = L.elem[i - 1];
    return true;
}

后继：

Status NextElem(Sqlist& L, Poly e_current, Poly& e_next)
{
    int i = L.length - 1;
    if (!&L || L.elem[i] != e_current)
        //L存在且e_current不是最后一个元素
        cerr << "无意义" << endl;
        return false;
    while (L.elem[i] != e_current)i--;
    e_next = L.elem[i + 1];
    return true;
}

十二（附加）、对线性表内部所有元素进行统一同一操作

<Traverse:横越; 穿过;>：对元素进行操作的内容；

例如：我们在这里给实数加一

（1）在函数内部实现：

Status ListTraverse(Sqlist& L)
{
    if (!&L)
        return false;
    int i = 0;
    while (i < L.length-1)
    {
        (L.elem->p)++;
        i++;
    }
    return true;
}

（2）在操作函数外部通过构造visit函数（辅助）实现

1、visit函数在结构体内部：

struct Sqlist
{
    Poly* elem;
    int length;

    int visit()
    {
        int i = 0;
        while (i < length - 1)
        {
            elem->p++;
            i++;
        }
        return true;
    }

};

Status ListTraverse(Sqlist& L)
{
    if (!&L)
        return false;
    int visit();
    return true;
}

这样，在修改对线性表的元素的操作时只需修改visit函数即可

2、visit函数在结构体体之外(独立，自成一派)：

struct Sqlist
{
    Poly* elem;
    int length;
};

int visit(Sqlist& L)
    {
        int i = 0;
        while (i < L.length - 1)
        {
            L.elem->p++;
            i++;
        }
        return true;
    }

Status ListTraverse(Sqlist& L)
{
    if (!&L)
        return false;
    int visit();
    return true;
}

注意：

这里（面）用的结构体不是类，不可能存在说像类一样把成员函数定义在其结构体范围之外 

也不存在在这个地方用什么友元函数

有关于线性表的所有基本操作到此为止，完结撒花

下一节，我们开关于链表的学习 

宇 -Yu
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
青岛大学王卓数据结构与算法课程PPT截图
02-17
青岛大学王卓数据结构与算法课程PPT截图 带目录方便复习
线性表的代码实现（基于c语言）
m0_71772987的博客
03-15 615
printf("前驱值:%d\n后继值:%d", PriorElem(&L, cur_e), NextElem(&L, cur_e));定义：一个线性表是n个数据元素的有限序列，当n=0时称为空表，除了第一个元素和最后一个元素，其它元素都有直接前驱和直接后继元素。#返回表中与e相等的元素的序号。1、头文件(list.h)#调用线性表相关操作示例。#返回第i个数据元素的值。源文件(list.c)
C++实现线性顺序表的初始化，插入，删除，销毁，清空等功能
fxyqh的博客
01-11 3395
C++实现线性顺序表的初始化，插入，删除，销毁，清空等功能 以下代码主要严蔚参考敏主编的《数据结构》（C语言）编写 //线性顺序表 #include <iostream> #define MAX_INTT_LIST 100 #define Elemtype int #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 typedef int Status; using namespace std; typedef struct
数据结构与算法基础-学习-03-线性表之链式表-初始化、销毁、清理、获取长度、判断为空、获取元素等实现
qq_45111959的博客
11-28 899
数据结构与算法基础-学习-03-线性表之链式表-初始化、销毁、清理、获取长度、判断为空、获取元素等实现
数据结构--线性表的销毁,逆置
fly
10-07 7115
c语言进行多次输入时可采用EOF来实现 while(scanf("%c%c%c",&ah,&ch,&bh)!=EOF)//进行多次输入用EOF
数据结构--笔记--线性表
tao0212的博客
08-22 129
线性表------逻辑结构线性表是具有（每个数据元素所占空间一样大）数据类型的n（n≥0）个的（有次序），其中n为，当n = 0时线性表是一个。注：数据结构三要素——逻辑结构、数据的运算、存储结构（物理结构）
数据结构与算法基础.pdf
03-14
王卓老师数据结构与算法基础笔记
DataStructure-Algorithmics:数据结构与算法基础（青岛大学-王卓）
04-12
DataStructure-Algorithmics 数据结构与算法基础（青岛大学-王卓）
王卓《数据结构与算法》第二章 线性表
12-24
王卓《数据结构与算法》第二章 线性表PPT
数据结构与算法基础青岛大学王卓老师视频截图PPT第5-8章
最新发布
10-10
前4章b站评论区已有人整理，后面的内容觉得有些乱，就自己整理了一下。
数据结构C语言-线性表的定义、销毁及增删改查（数据运算）
T1cH9的博客
05-26 1279
声明部分： #include <stdio.h> #include <stdlib.h> #define INIT_SIZE 1 #define BOLCK_SIZE 10 typedef struct { int *data; int length; int MaxSize; } SqList; SqList CreateListInt(); //创建线性表 void DestoryList(SqList *L); //销毁线性表 void Inc
数据结构———线性表（考研：第二章）
L093117l的博客
04-28 445
数据结构——线性表（考研）一、线性表的基本概念二、线性表的实现1.顺序存储2.链式存储（1）单链表（2）双链表（3）循环链表（4）静态链表（借助数组实现）三、线性表的应用 一、线性表的基本概念 1.线性表的定义 线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长。 2.线性表的基本操作 InitList(&L):初始化表。构造一个空的线性表。 Length（L）：求表长。返回线性表L的长度，即L中数据元素的个数 LocateElem（L，e）：按值查找操作。在表L中查找具有给定关键值的
销毁线性表
m0_47058889的博客
04-14 4401
销毁i线性表 void DestroyList(Link node*&L) { Linknode*pre=L,*p=L-> next; while(p!=Null) { 加粗样式free(pre); pre=p; p=pre->next; } free(pre); } 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习...
线性表的销毁
qq_45543503的博客
12-02 2924
v oid DestroyList(List &L) { if (L.elems) delete []L.elems;//释放存储空间 L.length = 0; L.size = 0; }
线性表的顺序存储的介绍 — 基本运算(销毁线性表、输出线性表、增删查等)和 静态分配和动态分配
weixin_53161762的博客
03-11 2305
一、什么是线性表？ 线性表是由n(n≥0)个属性相同的数据元素a1,a2…an组成的一个有限序列。 可以表示为 A= (a1, a2, a3, … ai … an) 二、线性表的特征： 1、有且只有一个表头元素a1，它无前驱； 2、有且只有一个表尾元素an，它无后继； 3、表头元素与表尾元素外，其它所有元素有且只有一个前驱，也有且只有一个后继。 4、线性表中结点的个数n称为线性表的长度。当n＝0时，称为空表。 线性表 A= (a1, a2, a3, … ai … an) ，以线性表A为例，a2的前驱是a1，
c语言如何销毁线性表
weixin_35750747的博客
01-13 660
在 C 语言中，可以使用 free() 函数来销毁线性表。在使用前需要先使用 malloc() 或者 calloc() 函数为线性表分配内存，然后再在不再使用该线性表时，使用 free() 函数释放该线性表占用的内存。 例如： int* list = (int*) malloc(sizeof(int) * 10); // 使用线性表 ... free(list); ...
线性链表的操作（查找、插入、删除、销毁）
CODEING一场空的博客
01-21 2494
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef int elemtype; typedef struct LNode { elemtype data; elemtype len; struct LNode *next; }LNode, *Linklist; Linklist Initlist()//初始化线性表 { ...
数据结构-线性表的链式表示--单链表的基本操作（初始化；销毁；头插法，尾插法创建；按序号，按值查找；求长度；插入；删除；合并；打印）（带注解）
qq_62630363的博客
11-19 330
为了避免顺序表在做插入，删除操作时，要移动大量元素，我们用链式存储结构来标识线性表，但它同时也失去了顺序表的可随机存取的优点。
数据结构第二章--线性表
m0_61402375的博客
07-19 62
线性表是具有相同数据类型的n（n>=0）个数据元素的有限序列。其中n为表长，当n等于零时，线性表示一个空表，若用L命名线性表，则其一般表示为，L=(a1,a2...ai,ai+1..an)几个概念要注意ai是线性表中的"第i个"元素线性表中的位序。(位序从1开始，数组下标从0开始）。a1是表头元素,an是表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱，除最后一个元素外，每个元素有且仅有一个直接后继。表中元素的个数有限，表中元素具有逻辑上的顺序性，表中元素有其先后次序的。
数据结构与算法基础（青岛大学-王卓
08-26
数据结构与算法基础（青岛大学-王卓）是一个40个小时的教学视频系列，共有173集。该系列视频主要讲解了数据结构与算法的基础知识。如果你想学习这方面的知识，我建议你可以观看这个系列的教学视频。你可以在以下链接中找到这个系列的学习资源： 此外，我还找到了另一个链接，里面可能包含一些相关的学习资料：你可以点击链接获取更多信息。 希望这些资源能对你的学习有所帮助！<span class="em">1</span><span class="em">2</span> #### 引用[.reference_title] - *1* *2* [数据结构与算法基础-青岛大学-王卓](https://blog.csdn.net/weixin_45433031/article/details/128307330)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值