精华内容
下载资源
问答
  • 在一个长度为n的顺序表的任一位置
    2022-03-05 15:16:53

    在顺序表中,逻辑上相邻的两个元素物理存储上也一定相邻(对)

    线性表采用顺序存储,必须占用一段地址连续的存储单元(对)

    某顺序表的第一个元素的存储地址是500,每个元素占4个单元,则第8个元素的起始地址是(D)

    A.504 B.508 C.516 D.528

    长度为n的非空线性表采用顺序存储结构,在第i个元素前插入一个数据元素,i的合法值应该是(A)

    A.1<=i<=n+1 B.0<=i<=n+1 C.i>0 D.1<=i<=n-1

    在长度为n的顺序表中的第i(1<=i<=n+1)个元素前插入一个元素,需要移动的元素个数为(B)

    A.n-i B.n-i+1 C.i D.n-i-1

    在长度为n的顺序表中的第i(1<=i<=n+1)个元素前删除一个元素,需要移动的元素个数为(A)

    A…n-i B.n-i+1 C.n-i-1 D.i

    假设删除长度为n的顺序表中的每个元素的概率相同,则删除一个元素平均要移动的元素的个数是(D)
    A.n/2 B.(n+1)/2 C.n D.(n-1)/2

    在长度为n的顺序表中的第i(1<=i<=n+1)个元素前插入一个元素,其算法复杂度为(B)

    A.O(1) B.O(n)C.O(n*n) D.O(logn)(以2为底)

    在长度为n的顺序表中读取第i(1<=i<=n+1)个元素,其算法复杂度为(A)这道题考察的是getelem,不是定位操作locateelem

    A.O(1) B.O(n)C.O(n*n) D.O(logn)(以2为底)

    在长度为n的顺序表中删除第i(1<=i<=n+1)个元素,其算法复杂度为(B)
    A.O(1) B.O(n)C.O(n*n) D.O(logn)(以2为底)

    更多相关内容
  • 【单选题】在长度为 n顺序表中进行顺序查找,查找失败时需与键值比较次数是 ( ) 。【单选题】一个具有n个顶点e条边的图中,所有顶点的度数之和等于 ( )。(5.0分)【填空题】假设有序线性表a[20]上进行折半查找,则...

    【单选题】在长度为 n 的顺序表中进行顺序查找,查找失败时需与键值比较次数是 ( ) 。

    【单选题】一个具有n个顶点e条边的图中,所有顶点的度数之和等于 ( )。(5.0分)

    【填空题】假设在有序线性表a[20]上进行折半查找,则比较一次查找成功的结点数为1;比较两次查找成功的结点数为 ( ) ;比较四次查找成功的结点数为 ( ) 。

    【判断题】一个连通图的生成树是一个极小连通子图。(3.0分)

    【单选题】39.mp3

    【单选题】42.mp3

    【填空题】在一个具有n个顶点的完全无向图和完全有向图中分别包含有 ____ 和 ____ 条边。 (10.0分)

    【单选题】在长度为 n 的有序顺序表中,采用二分法查找,在等概率的情况下,查找成功的平均查找长度是 ( ) 。

    【判断题】在非连通图的遍历过程中,调用深度优先搜索算法的次数等于图中连通分量的个数。(3.0分)

    【单选题】38.mp3

    【单选题】任一个连通图的生成树 ( ) 。(5.0分)

    【判断题】在AOE网中,任何一个关键活动提前完成,整个工程都会提前完成。(3.0分)

    【判断题】若在有向图的邻接矩阵中,主对角线以下的元素均为0,则该图一定存在拓扑有序序列。(3.0分)

    【判断题】一个图的邻接矩阵表示是惟一的。(3.0分)

    【简答题】23.mp3

    【简答题】期中考试.docx

    【判断题】在有数值相同的权值存在时,带权连通图的最小生成树可能不惟一。(3.0分)

    【单选题】对线性表进行顺序查找时,要求线性表的存储结构是 ( ) 。

    【单选题】31.mp3

    【单选题】下面关于对图的操作的说法不正确的是 ( ) 。(5.0分)

    【单选题】对线性表用二分法查找时要求线性表必须是 ( ) 。

    【填空题】高度为6的平衡二叉排序树,其每个分支结点的平衡因子均为0,则该二叉树共有 ( )个结点。

    【简答题】04.mp3

    【单选题】下面的各种图中,哪个图的邻接矩阵一定是对称的 ( ) 。(5.0分)

    【简答题】请按照实践教程课本实验7,完成此次作业,包括课后大作业。

    【论述题】请完成实践教程中实验5和实验6 Excel2010基本操作和高级应用

    【单选题】不含任何结点的空树 。

    【单选题】对22个记录的有序表作折半查找,当查找失败时,至少需要比较 ( ) 次关键字。

    【单选题】32.mp3

    【多选题】为莎士比亚创作和演出活动奠定基础的“大学才子”有

    【单选题】已知图的邻接表如下所示,根据算法,则从顶点0出发按广度优先遍历的结点序列是 ( ) (5.0分)

    【判断题】有向图用邻接表表示,顶点vi的出度是对应顶点vj链表中结点个数。(3.0分)

    【单选题】在长度为 n 的线性表中进行顺序查找,在等概率的情况下,查找成功的平均查找长度是 ( ) 。

    【单选题】设顺序表为{ 4 ,6,12,32,40,42,50,60,72,78,80,90,98},用二分法查找72,需要进行的比较次数是 ( ) 。

    【填空题】03.mp3

    【填空题】具有n个顶点e条边的有向图和无向图用邻接表表示,则邻接表的边结点个数分别为____和 ____ 条。 (10.0分)

    【填空题】对一棵二叉排序树进行 ( ) 遍历,可以得到一个键值从小到大次序排列的有序序列。

    【判断题】有向图用邻接矩阵表示,删除所有从顶点i出发的弧的方法是,将邻接矩阵的i行全部元素置为0。(3.0分)

    【简答题】请完成实践教程实验8内容。

    【单选题】40.mp3

    【单选题】在有序表A[80]上进行二分法查找,查找失败时,需对键值进行最多比较次数是 ( ) 。

    【填空题】具有n个顶点的连通图至少具有 ____ 条边。(5.0分)

    【单选题】41.mp3

    【单选题】在查找过程中,若同时还要做插入、删除操作,这种查找称为 ( ) 。

    【单选题】具有8个顶点的有向图最多有 ( ) 条边。(5.0分)

    【多选题】《哈姆莱特》代表了莎士比亚戏剧艺术的高峰,它的艺术特点有

    【简答题】请同学们熟悉实验1、实验2和实验9的内容,按实践教材内容进行操作。

    【单选题】下面关于图的存储结构的叙述中正确的是 ( ) 。(5.0分)

    【填空题】对于表长为 n 的线性表要进行顺序查找,则平均时间复杂度为 ( ) 。

    【单选题】广度优先遍历类似于二叉树的 ( ) 。(5.0分)

    展开全文
  • 创建一个顺序表, 向顺序表中插入元素,查找顺序表中的元素(按值查找和按序号查找),删除顺序表中的某个元素,输出顺序表中的元素算法: #include <stdio.h> #include <stdlib.h> #define ListSize ...

    创建一个顺序表, 向顺序表中插入元素,查找顺序表中的元素(按值查找和按序号查找),删除顺序表中的某个元素,输出顺序表中的元素算法:

    #include <stdio.h>
    #include <stdlib.h>
    #define ListSize 100
    typedef int ListData;
    
    typedef struct
    {
        ListData *data;
        int length;
    }SeqList;
    
    void InitList(SeqList &L)//初始化顺序表
    {
        L.data=(ListData*)malloc(ListSize*sizeof(ListData));
        if(L.data==NULL)
        {
            printf("存储分配失败\n");
            exit(1);
        }
        L.length=0;
    }
    
    void CreatList(SeqList &L)//创建顺序表
    {
        printf("要创建顺序表的长度为:\t");
        scanf("%d",&L.length);
        printf("Please input your elements:\n");
        for(int i=0;i<L.length;i++)
            scanf("%d",&L.data[i]);
    }
    
    void InsertList(SeqList &L,ListData x,int i)//向顺序表中插入元素
    {
        if(i<0||i>L.length||L.length==ListSize)
            printf("插入失败\n");
        else
        {
            for(int j=L.length;j>i;j--)
                L.data[j]=L.data[j-1];
            L.data[i]=x;
            L.length++;
        }//插入成功
    }
    
    int FindByValue(SeqList &L,ListData x)//按值查找
    {
        int i=0;
        while(i<L.length&&L.data[i]!=x)
            i++;
        if(i<L.length) return i;//查找成功
        else {printf("查找失败\n");return -1;}//查找失败
    }
    
    int FindByNumber(SeqList &L,int i)//按序号查找
    {
        if(i<0||i>=L.length)
        {
            printf("查找失败\n");
            return -1;
        }
        else return L.data[i];
    }
    
    void DeleteList(SeqList &L,ListData x)//删除顺序表中的元素
    {
        int i=FindByValue(L,x);
        if(i>=0)
        {
            L.length--;
            for(int j=i;j<L.length;j++)
                L.data[j]=L.data[j+1];
        }
        else printf("删除失败\n");//表中没有x
    }
    
    void ShowList(SeqList L)//输出顺序表的元素
    {
        printf("输出顺序表中的元素:\n");
        for(int i=0;i<L.length;i++)
            printf("%d\t",L.data[i]);
        printf("\n");
    }
    
    int main()
    {
        SeqList L;
        InitList(L);
        CreatList(L);
        int m,n;
        printf("要插入的元素及插入位置分别为:\t");
        scanf("%d%d",&m,&n);
        InsertList(L,m,n);
        ShowList(L);
        printf("要查找元素值为:\t");
        scanf("%d",&m);
        n=FindByValue(L,m);
        if(n>=0) printf("按值查找该元素的位置为:\t%d\n",n);
        printf("要查找元素位置为:\t");
        scanf("%d",&n);
        m=FindByNumber(L,n);
        if(m>=0) printf("按序号查找该位置的元素值为:\t%d\n",m);
        printf("要删除元素值为:\t");
        scanf("%d",&m);
        DeleteList(L,m);
        ShowList(L);
        return 0;
    }
    
    

    运行结果
    在这里插入图片描述

    展开全文
  • 线性表文档之顺序表

    2022-04-05 21:35:38
    线性表文档之顺序表

    顺序表

    定义

    概念

    线性表的顺序存储称为顺序表,它是用一组地址连续的存储单元依次存储线性表中的数据元素,从而使得逻辑上相邻的两个元素在物理位置上也相邻。

    1 个元素存储在线性表的起始位置,第 i 个元素的存储位置后面紧接着存储的是第 i+1 个元素,称 i 为元素 ai 在线性表中的位序。

    所谓线性表中任一数据元素可以随机存取,就是可以通过常数访问或者修改线性表中的数据元素,通常用高级程序设计语言中的数组来描述线性表的顺序表存储结构。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tRcLl4SX-1649165730021)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220326234106962.png)]

    结构体

    线性表的结构体定义如下:

    #define MAXSIZE 100 // 这里定义了一个整型常量 MAXSIZE,值为 100,表示数组长度为 100
    
    typedef struct {
        int data[MAXSIZE];// 存放顺序表元素的数组,默认是 int 类型,可换成其他类型
        int length;// 存放顺序表实际元素个数,而非 MAXSIZE
    } SeqList;// 顺序表类型的定义
    

    如图,一个顺序表包括一个存储表中元素的数组 data[] 和一个指示元素个数的变量 length

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XavvzHG5-1649165730022)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220326235312646.png)]

    注:下面的内容是补充,通常都使用静态分配,考研知道静态分配结构体定义就行,下面的内容了解即可。

    一维数组可以是静态分配的,也可以是动态分配的。在静态分配时,由于数组的大小和空间已经固定,一旦空间占满,再加入新的数据就会产生溢出,进而导致程序奔溃。而int data[MAXSIZE] 就是静态分配的,通常使用的是静态分配。

    而在动态分配时,存储数组的空间是在程序执行过程中通过动态存储分配语句分配的,一旦数据空间占满,就可以另外开辟一块更大的存储空间,用来替换原来的存储空间,从而达到扩充存储数组空间的目的,而不需要为线性表一次性划分所有空间。而动态分配的结构体定义语句如下:

    #define INIT_SIZE 100 // 顺序表长度的初始定义
    typedef struct {
        int *data;// 设置数据类型是整型,可以修改为其他类型。指定动态分配数组的指针
        int MAXSIZE;// 数组的最大容量
        int length;// 顺序表实际元素个数
    } SeqList;// 动态分配数组顺序表的类型定义
    

    C 语言初始动态分配语句为(该语句通常写在初始化函数 init 中):

    L.data = (int*)malloc(sizeof(int)*INIT_SIZE);
    

    而如果想要扩容,即重新为 L.data 分配更大的空间就可以了。

    特点

    顺序表的主要特点:

    • 顺序表最主要的特点是随机访问,即可以通过首地址和元素序号可以在时间 O(1) 内找到指定的元素。如数组 L = [1, 2, 3, 4, 5] 可以通过 L[2] 访问到 L 中的第 3 个元素。
    • 顺序表的存储密度高,每个节点只存储数据元素。
    • 顺序表逻辑上相邻的元素物理上也相邻,所以插入和删除操作需要移动大量元素。

    基本操作

    注,完整代码请参考:

    概述

    顺序表的常见基本操作如下:

    • void init(SeqList *L):初始化顺序表。
    • int findByIndex(SeqList L, int index, int *ele):通过下标查找顺序表中的元素,保存到 ele 中。
    • int findByEle(SeqList L, int ele, int *index):通过指定值 ele 在顺序表中查找元素,并将元素的下标保存到 index 中。
    • int insert(SeqList *L, int index, int ele):在顺序表中指定 index 位置插入新元素 ele
    • int add(SeqList *L, int ele):在顺序表的尾部添加新元素 ele
    • removeByIndex(SeqList *L, int index, int *ele):删除指定 index 位置的元素,并将被删除元素保存到 ele 中。
    • size(SeqList L):获取顺序表中实际元素个数。
    • isEmpty(SeqList L):判断顺序表是否为空。
    • print(SeqList L):打印顺序表中所有元素。

    init

    初始化顺序表操作。即将顺序表的 length 字段值置为 0,初始时顺序表中没有任何元素,所以为零。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eWibsZqK-1649165730025)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220327120359273.png)]

    实现代码如下:

    /**
     * 初始化顺序表,仅需要将 length 置为 0 即可
     * @param list 待初始化的顺序表
     */
    void init(SeqList *list) {
        // 仅需要将 length 置为 0 即可
        (*list).length = 0;
        // 或者可以用下面的语法
        // list->length=0;
    }
    

    注意,如果顺序表结构体定义中 data 是动态分配的,则需要在 init 函数中队 data 进行初始化分配。

    findByIndex

    在顺序表中查找指定位序(用数组表示顺序表,所以从 0 开始)的元素,而用 ele 存放查找的元素。如果查找成功则返回 1,否则返回 0。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0NQ2NTKB-1649165730027)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220327121134783.png)]

    实现步骤:

    • 参数校验,如果下标 index 小于零或者大于 MAXSIZE 则无法获取到元素;如果下标大于等于顺序表的实际元素个数 length 也会返回 0。
    • 然后通过下标直接访问 data 数组中的元素即可,无论是最好的情况还是最坏的情况,时间复杂度都是 O(1)

    实现代码如下:

    /**
     * 查找顺序表中指定索引所表示的元素
     * @param list 待查询的顺序表
     * @param index 索引,即数组的下标,从 0 开始
     * @param ele 保存查找到的元素
     * @return 如果查询成功则返回 1,如果查找失败则返回 0
     */
    int findByIndex(SeqList list, int index, int *ele) {
        // 0.参数校验
        // 0.1 如果索引小于 0 或者大于等于设定的最大长度,则无法获取到元素
        if (index < 0 || index >= MAXSIZE) {
            return 0;
        }
        // 0.2 如果索引在 [0, MAXSIZE) 范围内,但超过了实际元素个数,也是无法获取到的
        if (index >= list.length) {
            return 0;
        }
        // 1.查找指定索引所表示的元素
        // 1.1 直接返回下标为 index 的元素值即可,不需要遍历循环
        *ele = list.data[index];
        return 1;
    }
    

    findByEle

    在顺序表 list 中查找第一个元素值等于 ele 的元素,并返回它在顺序表中的位序(即数组下标)。如果顺序表中存在元素 ele 则函数返回 1,如果顺序表中不存在该元素则返回 0。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kNY1xYla-1649165730030)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220327122539755.png)]

    实现步骤:

    • 遍历顺序表所有元素,然后与指定值 ele 进行比较,如果相等则用 index 保存该元素在顺序表中的位序(即下标)。并且返回 1 退出程序。
    • 遍历完顺序表发现不存在与指定值 ele 相等的元素,则返回 0。

    实现代码如下:

    /**
     * 查找指定元素在顺序表中的索引
     * @param list 待查询的顺序表
     * @param ele 指定元素
     * @param index 保存查询成功的索引
     * @return 如果查询成功则返回 1,查询失败则返回 0
     */
    int findByEle(SeqList list, int ele, int *index) {
        // 循环顺序表中的所有元素
        for (int i = 0; i < list.length; i++) {
            // 比较迭代的每一个元素的值是否等于传入的参数值,如果相等则返回对应的索引(下标)
            if (list.data[i] == ele) {
                // 保存索引
                *index = i;
                // 结束程序
                return 1;
            }
        }
        return 0;
    }
    

    insert

    在顺序表 list 的第 index0<=index<list.length)个位置插入新元素 ele。若 index 的输入不合法,则返回 0,表示插入失败;否则,将第 index 个元素及其后的所有元素依次往后移动一个位置,腾出一个空位置插入新元素 ele,顺序表的长度 length 增加 1,表示插入成功,返回 0。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nha4lbrR-1649165730033)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220327140904743.png)]

    实现步骤:

    • 参数校验,如果 index 小于 0 或者大于 MAXSIZE 都不是有效参数;如果顺序表已经满了,也无法进行插入操作;如果 index 超过顺序表实际元素个数也无法插入成功,都返回 0 表示插入失败。
    • 将顺序表中 index 及之后的所有元素向后移动一位。
    • 然后将空出来的 index 位置填入待插入的元素 ele
    • 最后修改顺序表的 length 增加 1。

    实现代码如下:

    /**
     * 向顺序表指定索引处插入一个新元素。原索引处的元素及之后的所有元素都向后移动一位。
     * @param list 顺序表
     * @param index 指定插入位置
     * @param ele 待插入的新元素
     * @return 如果插入成功则返回 1,如果插入失败则返回 0
     */
    int insert(SeqList *list, int index, int ele) {
        // 0.参数校验
        // 0.1 如果索引小于 0 或者大于等于设定的最大长度,则插入失败
        if (index < 0 || index >= MAXSIZE) {
            return 0;
        }
        // 0.2 向顺序表中插入元素要检查顺序表是否已经满了,如果已经满了则不能再插入新元素则插入失败
        if (list->length == MAXSIZE) {
            return 0;
        }
        // 0.3 如果插入的索引超过了数组长度的范围也不行
        if (index > list->length) {
            return 0;
        }
        // 1.如果顺序表没有满,则继续插入元素
        // 1.1 循环顺序表,从后往前遍历,将指定索引及之后的所有元素(包括指定索引)向后移动一位
        for (int i = list->length - 1; i >= index; i--) {
            list->data[i + 1] = list->data[i];
        }
        // 1.2 将移动后空出来的位置(即指定索引所在的位置)插入新元素
        list->data[index] = ele;
        // 1.3 不要忘记将 length 加 1 表示顺序表新增一个元素
        list->length++;
        return 1;
    }
    

    add

    为了弥补 insert 方法无法在顺序表尾部插入的问题(因为参数校验,所以不能插入,当然可以修改代码让它能够通过 insert 方法插入)。直接在顺序表的尾部插入新元素 ele

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WP6WkHVP-1649165730037)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220327141647114.png)]

    实现步骤:

    • 参数校验,如果顺序表已满,则返回 0 表示插入失败。
    • 直接在顺序表的 list->length 位置插入新元素 ele,因为该位置为空,所以直接赋值即可。
    • 插入新元素后,将顺序表的 length 加 1。
    • 返回 1 表示插入成功。

    实现代码如下:

    /**
     * 直接添加新元素到顺序表的尾部
     * @param list 顺序表
     * @param ele 待添加的新元素
     * @return 如果插入成功则返回 1,否则返回 0
     */
    int add(SeqList *list, int ele) {
        // 0.校验
        // 0.1 向顺序表中插入元素要检查顺序表是否已经满了,如果已经满了则不能再插入新元素则添加失败
        if (list->length == MAXSIZE) {
            return 0;
        }
        // 1.插入新元素
        // 1.1 直接获取顺序表的 length,然后将新元素的值赋予到 length 位置即可
        list->data[list->length] = ele;
        // 1.2 注意修改 length
        list->length++;
        return 1;
    }
    

    removeByIndex

    删除顺序表 list 中第 index0<=index<list.length)个位置(表示数组下标)的元素,用引用变量 ele 存放被删除元素的值。若输入的 index 不合法则返回 0 表示删除失败;否则,将被删元素赋给引用变量 ele,并将第 index+1 个元素及其后的所有元素依次往前移动一个位置,返回 1 表示删除成功。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C2frFDN1-1649165730041)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220327143142460.png)]

    实现步骤:

    • 参数校验。如果下标 index 小于零或者大于 MAXSIZE 表示超出范围,返回 0 表示删除失败;如果顺序表为空则无法删除元素,返回 0 表示删除失败;如果下标 index 大于等于顺序表长度 list->length 则也无法删除,返回 0 表示删除失败。
    • 将待删元素 list->data[index] 保存到引用变量 ele 中。
    • 然后将 index+1 及其后的所有元素都向前移动一位,即用后面的元素覆盖前面的元素。
    • 循环完成后,将顺序表的实际元素个数 length 减去 1,表示已经删除一个元素。
    • 返回 1 表示删除成功。

    实现代码如下:

    /**
     * 移除顺序表中指定索引的元素
     * @param list 顺序表
     * @param index 指定索引,即下标,从 0 开始
     * @param ele 被删除元素的数据值
     * @return 如果删除成功则返回 1,删除失败则返回 0
     */
    int removeByIndex(SeqList *list, int index, int *ele) {
        // 0.参数校验
        // 0.1 判断输入的索引是否超出范围
        if (index < 0 || index >= MAXSIZE) {
            return 0;
        }
        // 0.2 在删除顺序表元素之前,要判断顺序表是否为空,如果为空则不能进行删除
        if (list->length == 0) {
            return 0;
        }
        // 0.3 判断输入的索引虽然在数组范围内,但是否存在元素
        if (index >= list->length) {
            return 0;
        }
        // 1.删除指定索引的元素
        // 1.1 保存待删除索引所表示的元素的数据值
        *ele = list->data[index];
        // 1.2 循环遍历顺序表,从前往后,将指定索引之后的所有元素(不包括指定索引)向前移动一步
        for (int i = index; i < list->length; i++) {
            list->data[i] = list->data[i + 1];// 后面的元素覆盖前面的元素
        }
        // 1.3 将记录数组实际元素个数的 length 减去 1,表示已经删除了一个元素
        list->length--;
        return 1;
    }
    

    size

    获取顺序表的实际元素个数,而非 MAXSIZE。在顺序表中已经有一个 length 维护了顺序表的实际元素个数,所以直接返回即可。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-meMNbrKt-1649165730042)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220327143350399.png)]

    实现步骤:

    • 直接返回顺序表的 length 属性即可。

    实现代码如下:

    /**
     * 获取顺序表的长度
     * @param list 顺序表
     * @return 顺序表中实际元素个数
     */
    int size(SeqList list) {
        return list.length;
    }
    

    isEmpty

    判断顺序表是否为空,如果顺序表为空则返回 1;如果顺序表不为空则返回 0。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UojUTgYk-1649165730043)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220327143845250.png)]

    实现步骤:

    • 判断顺序表的 length 属性值是否等于 0,如果等于 0 表示顺序表实际元素个数为 0,即为空表;否则不是空表。

    实现代码如下:

    /**
     * 顺序表是否为空
     * @param list 顺序表
     * @return 如果为空则返回 0,不为空则返回 1
     */
    int isEmpty(SeqList list) {
        return list.length == 0;
    }
    

    print

    打印顺序表所有元素。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8e0Hxxw0-1649165730090)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220327144244457.png)]

    实现步骤:

    • 遍历顺序表所有元素,按顺序输出元素值。

    实现代码如下:

    /**
     * 打印顺序表
     * @param list 待打印的顺序表
     */
    void print(SeqList list) {
        printf("[");
        for (int i = 0; i < list.length; i++) {
            printf("%d", list.data[i]);
            if (i != list.length - 1) {
                printf(", ");
            }
        }
        printf("]\n");
    }
    

    注意事项

    顺序表是否为空

    顺序表结构体 SeqList 中维护了一个字段 length 专门用来记录顺序表中实际存储的元素个数。而可以根据 list.length==0 来判断顺序表是否为空。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V6jw4dTc-1649165730092)(image-%E9%A1%BA%E5%BA%8F%E8%A1%A8/image-20220327143845250.png)]

    练习题

    以下是一些顺序表的练习题:

    展开全文
  • 第二章作业题1-顺序表

    千次阅读 2019-11-12 10:22:44
    若某线性表最常用的操作是存取任一指定序号的元素和最后进行插入和删除运算,则利用顺序表存储最节省时间。 T 时间复杂度一样,都O(1) 1-3 对于顺序存储的长度为N的线性表,删除第一个元素和插入最后一个...
  • 顺序表的存储特点是:只要确定了起始位置,表中任一元素的地址都通过下列公式得到:LOC(ai)=LOC(a1)+(i-1)*L 1≤i≤n 其中,L是元素占用存储单元的长度。如顺序表的每结点占用len内存单元,用location (ki
  • 顺序表计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中逻辑结构上相邻的数据元素存储相邻的物理存储单元中,即通过数据元素...
  • 线性表的顺序存储结构——顺序表

    千次阅读 2018-12-13 20:01:48
    顺序表是用段地址连续的存储单元依次存储线性表的数据元素,因为线性表中每元素的类型相同,通常用维数组来实现线性表,也就是把线性表中相邻的元素存在数组中相邻的位置(即用物理位置来表现元素间的关系).....
  • 2.1第二章作业1-顺序表

    千次阅读 2020-10-06 13:09:50
    1-1 对于顺序存储的长度为N的线性表,访问结点和...对于顺序存储的长度为N的线性表,删除第一个元素和插入最后一个元素的时间复杂度分别对应O(1)和O(N)。 (1分) T F 作者 徐镜春 单位 浙江大学 1-4 (neuDS)在顺序表
  • 顺序表查找基本概念查找表表示平均查找长度asl顺序表查找数据结构定义一般顺序表的查找算法算法分析递增有序查找算法算法分析二分查找,必考思想算法实现递归实现非递归算法算法分析实例算法实现索引顺序查找索引...
  • 顺序表定义及特点 1.顺序表定义 2.顺序表特点 二、顺序表定义 三、顺序表插入运算 四、顺序表删除运算 五、顺序表元素查找 六、顺序表取元素数据 七、主函数定义 注1. typedef 解释 注2. 链表知识点...
  • 顺序表作为线性表最基本的种结构。本文介绍了顺序表的定义和特点,然后给出了顺序表的常见各种操作和代码,包括了初始化、查找、插入、删除和归并(合并),并分析了程序的复杂度。
  • C++ 顺序表的类实现

    千次阅读 2019-08-30 15:57:57
    将表中元素一个一个的存入一组连续的存储单元中,这种存储结构是顺序结构,采用顺序存储结构的线性表简称顺序表”。 顺序表的存储特点是:只要确定了起始位置,表中任一元素的地址都通过下列公式得到: Loc...
  • 顺序表的原理

    千次阅读 2020-03-27 11:24:03
     既可以从的第一个表项开始逐个访问项也可以按照项的序号(下标)直接的访问。 无需表示结点间的逻辑关系而增加额外的存储空间,存储利用率提高。 可以方便的存储中的任一结点,存储速度快。  ...
  • 顺序表的查找

    千次阅读 2019-01-06 19:19:00
    1.对长度为4的顺序表进行查找,若第一个元素的概率1/8,第二个元素的概率1/4,第三个元素的概率3/8,第四个元素的概率1/4,则查找任一个元素的平均查找长度为( ) A)11/8 B)7/4 C)9/4 D)11/4 【答案...
  • 一、线性表的定义和特点 ... *其中数据元素的个数n定义为表长度 *当n=0时称为空 *将非空的线性表(n>0)记作:(a1,a2,...an) * 这里的数据元素ai(1<=i<=n)只是一个抽象的符号,其具...
  • 系列文章目录 波波的数据结构属实上的快,这里将会写些pta的解析,算是复习 预习,帮助我与大家期末不挂科 文章目录系列文章目录 # 顺序表 2-1 对于顺序存储的长度为N的线性表,访问...在N个结点的顺序表中,算
  • #数据结构#第二章:顺序表

    千次阅读 2019-09-03 23:21:11
    判断题 1-1 .对于顺序存储的长度为N的线性表,访问结点和增加结点的时间复杂度分别对应O(1)...对于顺序存储的长度为N的线性表,删除第一个元素和插入最后一个元素的时间复杂度分别对应O(1)和O(N)。 F, 顺序表删...
  • 顺序表----12基本操作实现

    千次阅读 多人点赞 2016-11-29 17:51:32
    只要确定了顺序表的起始位置顺序表任一数据元素都可以随机存取,线性表的顺序存储结构是种随机存取的存储结构。这点上与高级程序设计语言中的数组十分相似,因此通常用数组来描述数据结构中的顺序存储结构。...
  • 线性表-顺序表的基本操作

    千次阅读 2020-01-08 00:20:54
    存在唯一的一个被称作"第一个"的数据元素 存在唯一的一个被称作"最后一个"的数据元素 除第一个之外,结构中的每个数据元素均只有一个前驱 除最后一个之外,结构中的每个数据元素均只有一个后继 线性表的抽象数据...
  • 它的实现方式有很多,下面用顺序表、单链表、双链表、循环链表来对它进行实现。   线性表的抽象数据类型 数据元素:可以任意类型,只要同属于种数据类型即可; 数据关系:数据元素之间呈线性关系; 数据...
  • 1、顺序表初始化 2、顺序表插入元素 3、顺序表删除元素 4、顺序表查找元素 5、顺序表合并 线性表的顺序表示指的是用组地址连续的存储单元依次存储线性表的数据元素。 顺序存储方式不仅只用于存储线性结构。 ...
  • 数据结构——顺序表

    2019-10-04 10:40:55
    数据元素:数据的基本单位,计算机中通常作为一个整体进行考虑和处理。(数据元素也称为元素、记录等)。数据元素用于完整地描述一个对象,如:学生记录、树中棋盘的一个格局、图中的一个顶点等。 数据项:组成...
  • 单链表和顺序表的区别及优缺点

    千次阅读 2021-09-06 20:40:48
    只要确定了起始位置任一元素的地址都通过下列公式得到:elem[i]=elem[1]+elem[i-1]*length 1≤i≤n 其中,length是元素占用存储单元的长度。 单链表:单链表是种链式存取的数据结构,用组地址任意的存储...
  • 顺序表计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中逻辑结构上相邻的数据元素存储相邻的物理存储单元中,即通过数据元素...
  • 作业3-线性表抽象数据类型定义与顺序表操作 ...[解析]顺序表一个很大的缺点就是增删结点需要移动, 但是此题只表的末尾插入和删除,不需要移动,访问任意指定序号 的元素用顺序表更方便 1-3 对于顺序存储的长度为N的线
  • 数据结构——线性表之顺序表

    千次阅读 2022-03-12 21:32:30
    其实不难理解,线性表顾名思义就是像一根线一样的,生活中,排队测核酸中一条长长的队伍,一个跟着一个排着队,有一个打头,有一个收尾,如同有一根线一样把他们串联一起。还记得小时候玩过的老鹰捉小鸡的游戏吗...
  • 顺序表插入删除查找操作

    千次阅读 2017-10-11 13:37:13
    3.理解算法与程序的关系们能够将顺序表算法转换对应的程序 二、实验步骤 1.建立含有若干元素的顺序表 2.对已建立的顺序表实现插入、删除、查找等基本操作 代码如下 #include using namespace std; ...
  • 学了【数据结构】 看看这些练习题你能拿多少分

    千次阅读 多人点赞 2022-04-01 19:52:15
    按照教材算法,在一个长度为 n顺序表中为了删除位序号 5 的元素,从前到后依次移动了 15 个元素。则原顺序表长度为( )。(2分) A. 21 6 + 15 = 21 B. 20 C. 19 D. 25 39. 针对线性表,存储后如果最常用...
  • //将两个有序链表并为一个有序链表算法,该程序也可以cFree环境运行。 // c1.h (程序名) #include<string.h> #include<ctype.h> #include<malloc.h> // malloc()等 #include<limits.h> //...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,257
精华内容 10,502
关键字:

在一个长度为n的顺序表的任一位置

友情链接: lorenz.zip