2024年数据结构第二章--线性表_initsize(1)，2024年最新2024物联网嵌入式开发开发面试题及答案

2401_85013955

于 2024-05-14 03:53:56 发布

阅读量613

点赞数 10

分类专栏：程序员文章标签：物联网嵌入式硬件学习

本文链接：https://blog.csdn.net/2401_85013955/article/details/138830671

版权

程序员专栏收录该内容

19 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

test函数内部x=1024
调用test后x=1024

这时结果已经发生了变化，原因是&代表的是对操作过后的结果带回去，意思就是这里的X 不是谁的复制品，它改变的就是main函数里X的值。
如果你还没有明白“&”带回来的意思，就去C++在线工具敲一敲上面的代码，仔细体会一下&的含义吧！！

线性表的顺序表示

顺序表的定义

顺序表就是具有顺序存储结构的线性表。顺序表的特点是表中元素的逻辑顺序与其物理顺序相同。

顺序表的实现–静态分配

 # include<stdio.h>
 #define MaxSize 10 //定义最大长度
 typedef struct {
 int  data [MaxSize];  //用静态的“数组”存放数据元素
 int length;               //顺序表的当前长度
}SqList;                //顺序表的类型定义（静态分配方式）

//基本操作--初始化一个顺序表
void InitList(SqList &L){
for(int i=0;i<MaxSize;i++)
	L.dada[i]=0;//将所有数据元素设置为默认初始值
L.ength=0;    //顺序表初识长度为0
}
int main(){
 SqList L; //声明一个顺序表
 InitList(L);  //初始化顺序表
 //.......后续操作
 return 0;
}

在静态分配时，由于数组的大小和空间事先已经固定好，一旦空间占满，再加入心得数据将会产生溢出，进而导致程序崩溃。
而在动态分配时，存储数组的空间时在程序执行过程中通过动态存储分配语句分配的，一旦数据空间占满，就另外开辟一块更大的存储空间，用以替换原来的存储空间，从而达到扩充存储数组空间的目的，而不需要为线性表一次性地划分所有空间。

顺序表的实现–动态分配

#include <stdio.h>
# define InitSize 10 //默认的最大长度
typedef struct {
int \*data;   //指示动态分配数组的指针
int MaxSize;  //顺序表的最大容量
int length; //顺序表的当前长度
}SeqList;

int main(){
SeqList L;   //声明一个顺序表
InitList(L); //初始化顺序表
//.......其他操作函数
IncreaseSize(L,5);
return 0;
}
void InitList(SeqList &L){
//用malloc 函数申请一片连续的存储空间
L.data=(int \*)malloc(InitSize\*sizeof(int));
L.length=0;
L.MaxSize=InitSize;
}

//增加动态数组的长度
void IncreaseSize(SeqList &L,int len){
int \*p=L.data;
L.data=(int \*)malloc((L.MaxSize+len)\*sizeof(int));
for(int i=0;i<L.length;i++){
L.data[i]=p[i];   //将数据复制到新区域
}
L.MaxSize=L.MaxSize+len; //顺序表最大长度增加len
free（p);  //释放原来的内存空间
}

在这里插入图片描述
malloc函数动态申请一片连续的存储空间
free函数动态的释放内存的空间
C的初识动态分配语句为：
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);
其中（ElemType *)是因为malloc函数返回一个指针，需要强制转换型为你定义数据元素的类型指针
sizeof(ElemType)*InitSize意思是：数据元素所占存储内存空间大小 * 顺序表的初始长度=存放的存储空间大小
注意
1、malloc、free函数的头文件需要引用# include<stdlib.h>
2、动态分配并不是链式存储，它同样属于顺序存储结构。

顺序表的特点

（1）随机访问，通过首地址和元素号即可在世家O(1)内找到指定的元素，
（2）存储密度高，每个结点只存储数据元素
（3）扩展容量不方便（扩展长度的时间复杂度也比较高）
（4）插入、删除操作不方便，需要移动大量元素

顺序表的基本操作—插入

用存储位置的相邻来体现数据元素之间得到逻辑关系
ListInsert(&L,i,e): 插入操作。在表中的第i个位置插入指定元素e。

在这里插入图片描述

# define MaxSize 10 //定义最大长度
typedef struct{
   int data[MaxSize]; //用静态的“数组”存放数据元素
   int length;        //顺序表的当前长度
}SqList;            //顺序表的类型定义

bool ListInsert(SqList &L,int i,int e){
   if(i<1||i>L.length+1)   //判断i的范围是否有效
   		return false;
   if(L.length>=MaxSize)   //当前存储空间已满，不能插入
   		return false;
   for(int j=L.length;j>=i;j--)  //将第i个元素及之后的元素后移
   		L.data[j]=L.data[j-1];
   L.data[i-1]=e;            //在位置i处放入e
   L.length++;               //长度加1
   return ture;
}
int main(){
    SqList L;    //声明一个顺序表
    InitList(L);    //初始化顺序表
    // 顺序表的其他函数的其他操作
    ListInsert(L,3,3);
}

插入操作的时间复杂度

在这里插入图片描述
最好情况：
新元素插入到表尾，不需要移动元素。
i=n+1,循环0次；最好时间复杂度=O(1)
最坏情况：
新元素插入到表头，需要将原有的n个元素全部向后移动
i=1，循环n次；最坏时间复杂度=O(n)
平均情况：
假设新元素插入到任何一个位置的概率相同，即i=1,2,3,…,length+1的概率都是p=1/(n+1)
i=1,循环n次；i=2时，循环n-1次；i=3,循环n-2次…i=n+1时，循环0次
平均循环次数=np+(n-1)p+(n-2)p+…+1p=n/2
平均时间复杂度=O(n)

顺序表的基本操作–删除

删除上面顺序表中的第三个元素e，并输出删除的元素，这里需要用到“&”，体会前面的“带回来”

# define MaxSize 10 //定义最大长度
typedef struct{
   int data[MaxSize]; //用静态的“数组”存放数据元素
   int length;        //顺序表的当前长度
}SqList;            //顺序表的类型定义

bool ListDelete(SqList &L,int i,int &e){
   if(i<1||i>L.length+1)   //判断i的范围是否有效
   		return false;
   	e=L.data[i-1];   //将删除的元素赋值给e
   for(int j=i;j<L.length;j++)  //将第i个元素及之后的元素前移
   		L.data[j-1]=L.data[j];
   L.length--;               //线性表长度-1
   return ture;
}
int main(){
    SqList L;    //声明一个顺序表
    InitList(L);    //初始化顺序表
    // 顺序表的其他函数的其他操作
    int e=-1;//用变量e把删除的元素“带回来”
    if(ListDelete(L,3,e))
    	printf("已删除第3个元素，删除元素值为=%d\n",e);
    else
    	printf("位序i不合法，删除失败\n");
    reuturn 0;
}

在这里插入图片描述