2024年大数据最新数据结构与算法——线性表（链表篇）_线性链表(2)，程序员如何应对中年危机

最新推荐文章于 2024-06-15 06:34:43 发布
最新推荐文章于 2024-06-15 06:34:43 发布
阅读量548 收藏 20
点赞数 21
分类专栏： 程序员 文章标签： 大数据 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_82241942/article/details/138637410
版权

img
img
img

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

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

需要这份系统化资料的朋友，可以戳这里获取

void test(){
LinkList L; //声明一个指向单链表的指针
// 初始化空表
InitList(L);
…
}

//判断单链表是否为空
bool Empty(LinkList L){
if(L == NULL){
return true;
}else{
return false;
}
}


在线性表的顺序存储结构中，由于逻辑上相邻的两个元素在物理位置上也相邻，则每个元素的存储位置都可以从线性表的起始位置计算得到，而在单链表中，任何两个元素的存储位置之间没有固定的联系，要想取得第 
 
 
 
 
 i 
 
 
 
 i 
 
 
 i个数据元素必须从头指针出发寻找，因此，**单链表是非随机存储结构。**


**单链表的局限性：无法逆向检索，有时候不方便**  
   



#### 🚢基本操作


  

##### 👻插入操作


###### ⛅按位序插入


`插入操作`，在表L中的第 
 
 
 
 
 i 
 
 
 
 i 
 
 
 i个位置上插入指定元素


想要在第i个位置上插入元素，那么就要找到第 
 
 
 
 
 i 
 
 
 − 
 
 
 1 
 
 
 
 i-1 
 
 
 i−1个结点，然后将新结点插入其后面  
   



**带头结点情况：**


![在这里插入图片描述](https://img-blog.csdnimg.cn/291d0b46af244f76b34bd490ddf4bbd3.png#pic_center)

typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode, *LinkList

//在第i个位置插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1){
return false;
}
LNode *p; //指针p指向当前扫描的结点
int j=0; //当前p指针的是第几个结点
while (p != NULL && j<i-1){ //循环找到第i-1个结点
p = p->next;
j++;
}
if(p == NULL){ //i值不合法
return false;
}
LNode *t = (LNode *)malloc(sizeof(LNode));
t->data = e;
t->next = p->next;
p->next = t; //将结点t连接到p之后
return true; //插入成功
}


  

**不带头结点情况：**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/84bf08431a2945708d9f3d21a86c4eda.png#pic_center)

typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode, *LinkList

//在第i个位置插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1){
return false;
}
if(i==1){
LNode *t = (LNode *)malloc(sizeof(LNode));
t->data = e;
t->next = L;
L = t: //头指针指向新结点
return true;
}
LNode *p; //指针p指向当前扫描的结点
int j = 1; //当前p指向的是第几个结点
p = L; //p指向第一个结点(注意：不是头结点)
while(p != NULL && j<i-1){ //循环找到第i-1个结点
p = p->next;
j++;
}
if(p == NULL){ //i值不合法
return false;
}
LNode *t = (LNode *)malloc(sizeof(LNode));
t->data = e;
t->next = p->next;
p->next = t;
return true; //插入成功
}


`当i=1时`，执行插入操作所需要的时间复杂度为 
 
 
 
 
 T 
 
 
 ( 
 
 
 n 
 
 
 ) 
 
 
 = 
 
 
 O 
 
 
 ( 
 
 
 1 
 
 
 ) 
 
 
 
 T(n) = O(1) 
 
 
 T(n)=O(1)  
 `当i>1 && i<=n时`，时间复杂度为 
 
 
 
 
 T 
 
 
 ( 
 
 
 n 
 
 
 ) 
 
 
 = 
 
 
 O 
 
 
 ( 
 
 
 n 
 
 
 ) 
 
 
 
 T(n)=O(n) 
 
 
 T(n)=O(n)


但是，值得注意的是，实际上插入这个操作真正时间复杂度为 
 
 
 
 
 T 
 
 
 ( 
 
 
 n 
 
 
 ) 
 
 
 = 
 
 
 O 
 
 
 ( 
 
 
 1 
 
 
 ) 
 
 
 
 T(n)=O(1) 
 
 
 T(n)=O(1)，而程序运行所耗费的时间都在找到要插入的元素位置的前一个位置，所以综合考究:



> 
> **📌平均时间复杂为 
>  
>  
>  
>  
>  T 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  = 
>  
>  
>  O 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  
>  T(n) = O(n) 
>  
>  
>  T(n)=O(n)**
> 
> 
> 


  

###### ⛅指定结点的后插操作

typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode, *LinkList

//后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode *p, ElemType e){
if(p == NULL){
return false;
}
LNode *t = (LNode *)malloc(sizeof(LNode));
if(s==NULL){ //内存分配失败
return false;
}
t->data = e; //用结点t保存数据元素e
t->next = p->next;
p->next = t //将结点t连接到p之后
return true;
}



> 
> **📌平均时间复杂度为 
>  
>  
>  
>  
>  T 
>  
>  
>  ( 
>  
>  
>  o 
>  
>  
>  ) 
>  
>  
>  = 
>  
>  
>  N 
>  
>  
>  ( 
>  
>  
>  1 
>  
>  
>  ) 
>  
>  
>  
>  T(o) = N(1) 
>  
>  
>  T(o)=N(1)**
> 
> 
> 


  

###### ⛅指定节点的前插操作

typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode, *LinkList

//后插操作：在p结点之前插入元素e
bool InsertNextNode(LNode *p, ElemType e){
if(p == NULL){
return false;
}
LNode *t = (LNode *)malloc(sizeof(LNode));
if(s==NULL){ //内存分配失败
return false;
}
t->next = p->next;
p->next = t; //新结点t连接到p之后
t->data = p->data; //将p中元素复制到t中
p->data = e; //p中元素覆盖为e
}



> 
> **📌平均时间复杂度为 
>  
>  
>  
>  
>  T 
>  
>  
>  ( 
>  
>  
>  o 
>  
>  
>  ) 
>  
>  
>  = 
>  
>  
>  n 
>  
>  
>  ( 
>  
>  
>  1 
>  
>  
>  ) 
>  
>  
>  
>  T(o) = n(1) 
>  
>  
>  T(o)=n(1)**
> 
> 
> 


  

##### 👻删除操作


`删除操作`。删除表L中第 
 
 
 
 
 i 
 
 
 
 i 
 
 
 i个位置的元素，并用 
 
 
 
 
 e 
 
 
 
 e 
 
 
 e返回删除元素的值  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/cb024c2df57f41358eb93661936281bf.png#pic_center)


  

###### ⛅按位序删除


**带头结点情况：**

typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode, *LinkList

//带头结点的删除操作
bool ListDelete(LinkList &L, int i, ElemType &e){
if(i<1){
return false;
}
LNode *p; //指针p指向当前扫描到的结点
int j=0; //当前p指向的是第几个结点
p = L; //L指向头结点，头结点是第0个结点(不存数据)
while(p != NULL && j<i-1){ //循环找到第i-1个结点
p = P->next;
j++;
}
if(p == NULL){ //i值不合法
return false;
}
if(p->next == NULL){ //第i-1个结点之后已无其他结点
return false;
}
LNode *q = P->next; //令q指向被删除结点
e = q->data; //用e返回元素的值
p->next = q->next; //将*q结点从链中断开
free(q); //释放结点的存储空间
return true; //删除成功
}



> 
> **📌在删除操作中，最坏和平均时间复杂度为 
>  
>  
>  
>  
>  T 
>  
>  
>  ( 
>  
>  
>  o 
>  
>  
>  ) 
>  
>  
>  = 
>  
>  
>  o 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  
>  T(o) = o(n) 
>  
>  
>  T(o)=o(n)**
> 
> 
> 


最好时间复杂度: 
 
 
 
 
 T 
 
 
 ( 
 
 
 n 
 
 
 ) 
 
 
 = 
 
 
 O 
 
 
 ( 
 
 
 1 
 
 
 ) 
 
 
 
 T(n) = O(1) 
 
 
 T(n)=O(1)


  

###### ⛅指定节点的删除

typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode, *LinkList

//删除指定结点p
bool DeleteNode(LNode *p){
if(p == NULL){
return false;
}
LNode *q = p->next; //令q指向*p的后继结点
p->data = p->next->data //和后继结点交换数据域
p->next = q->next; //将*q结点从链中断开
free(q); //释放后继结点的存储空间
return true;
}


但是，使用这个算法有个问题，如果p是最后一个结点，那么当程序执行到`p->data = p->next->data`这一句时，会出现空指针的错误，所以只能从表头开始依次寻找p的前驱



> 
> **📌时间复杂度为 
>  
>  
>  
>  
>  T 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  = 
>  
>  
>  O 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  
>  T(n) = O(n) 
>  
>  
>  T(n)=O(n)**
> 
> 
> 


  

##### 👻查找操作（带头结点）


###### ⛅按位查找操作


`按位查找操作`。获取表L中第i个位置的元素的值

typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode, *LinkList

//按位查找，返回第i个元素(带头结点)
LNode * GetElem(LinkList L, int i){
if(i<0){
return NULL;
}
LNode *p; //指针p指向当前扫描的结点
int j = 0; //当前p指向的是第几个结点
p = L; //L指向头结点，头结点是第0个结点(不存数据)
while(p != NULL && j<i){ //循环找到第i个结点
p = p->next;
j++;
}
return p;
}



> 
> **📌平均时间复杂度为 
>  
>  
>  
>  
>  T 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  = 
>  
>  
>  O 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  
>  T(n) = O(n) 
>  
>  
>  T(n)=O(n)**
> 
> 
> 


  

###### ⛅按值查找操作


`按值查找操作`。根据给定的值在表L中查找与之相同的指定元素

typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode, *LinkList

//按值查找操作(带头结点)
LNode * LocateElem(LinkList L, ElemType e){
LNode *p = L->next;
// 从第1个结点开始查找数据域为e的结点
while(p != NULL && p->data != e){
p = p->next;
}
return p; //找到后返回该结点指针，否则返回NULL
}



> 
> **📌平均时间复杂度为 
>  
>  
>  
>  
>  T 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  = 
>  
>  
>  O 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  
>  T(n) = O(n) 
>  
>  
>  T(n)=O(n)**
> 
> 
> 


  

##### 👻单链表的创建


###### ⛅尾插法


每次都在最后一个元素之后插入新的元素

LinkList List_Taillnsert(LinkList &L){ //正向建立单链表
int x; //设ElemType为整型
L = (LinkList)malloc(sizeof(LNode)); //建立头结点，初始化空表
LNode *s, *r = L; //r为表尾指针
scanf(“%d”, &x); //输入结点的值
while(x != 9999){ //输入9999表示结束
s = (LNode *)malloc(sizeof(LNode));
s->data = x;
r->next = s; //在r结点之后插入元素x
r = s; //r指向新的表尾结点,永远保持r指向最后一个结点
scanf(“%d”, &x);
}
r->next = NULL; //尾结点指针置空
return L;
}



> 
> **📌平均时间复杂度为： 
>  
>  
>  
>  
>  T 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  = 
>  
>  
>  O 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  
>  T(n) = O(n) 
>  
>  
>  T(n)=O(n)**
> 
> 
> 


  

###### ⛅头插法


每次都在头结点之后插入新元素，头插法较为重要，当遇到链表的逆置操作时，可以使用头插法实现

LinkList List_Taillnsert(LinkList &L){ //逆向建立单链表
LNode *s;
int x;
L = (LinkList)malloc(sizeof(LNode)); //创建头结点
L->next = NULL; //初始为空链表
scanf(“%d”, &x); //输入结点的值
while(x != 9999){ //输入9999标志结束
s = (LNode*)malloc(sizeof(LNode)); //创建新结点
s->data = x;
s->next = L->next;
L->next = s; //将性结点插入表中，L为头指针
scanf(“%d”, &x);
}
return L;
}



> 
> **📌平均时间复杂度为： 
>  
>  
>  
>  
>  T 
>  
>  
>  ( 
>  
>  
>  n 


![img](https://img-blog.csdnimg.cn/img_convert/42f176cda771c604abcd49e91de46acd.png)
![img](https://img-blog.csdnimg.cn/img_convert/8be7317a56d5c27ef6e38883bcec9375.png)
![img](https://img-blog.csdnimg.cn/img_convert/04f98d90914a5155cfb8d1421746ce19.png)

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

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

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**

inkList List\_Taillnsert(LinkList &L){      //逆向建立单链表
    LNode \*s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));        //创建头结点
    L->next = NULL;                             //初始为空链表
    scanf("%d", &x);                            //输入结点的值
    while(x != 9999){                           //输入9999标志结束
        s = (LNode\*)malloc(sizeof(LNode));      //创建新结点
        s->data = x;
        s->next = L->next; 
        L->next = s;                    //将性结点插入表中，L为头指针
        scanf("%d", &x);
    }
    return L;
}

**📌平均时间复杂度为：

T

(

n

[外链图片转存中…(img-sX9bjuIt-1715271041991)]
[外链图片转存中…(img-1WlObfd1-1715271041991)]
[外链图片转存中…(img-a302fHzh-1715271041991)]

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

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

需要这份系统化资料的朋友，可以戳这里获取

2301_82241942
关注
  • 21
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法之线性表(超详细顺序表、链表)
bigsai
01-14 3391
原创公众号：bigsai 文章已收录在 全网都在关注的数据结构与算法学习仓库 欢迎star 前言 通过前面数据结构与算法基础知识我么知道了数据结构的一些概念和重要性，那么我们今天总结下线性表相关的内容。当然，我用自己的理解解分享给大家。 其实说实话，可能很多人依然分不清线性表，顺序表，和链表之间的区别和联系！ 线性表：逻辑结构， 就是对外暴露数据之间的关系，不关心底层如何实现，数据结构的逻辑结构大分类就是线性结构和非线性结构而顺序表、链表都是一种线性表。 顺序表、链表：物理结构，他是实现一个结构实际物.
数据结构核心原理与算法应用
06-15
“程序设计 = 算法 + 数据结构”，编程者如果没有掌握数据结构与算法，就说明没有真正掌握程序设计的能力，也就是不没有真正的学会编程。 从编程的角度来看，数据结构与算法几乎是最朴素的基础知识了，这一关，...
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法——线性表（顺序表篇）
小田是个程序员的博客欢迎你的到来呀~
06-11 6610
线性表且最简单的一种数据结构， 一个线性表是n个数据元素的有限序列 。本篇文章主要详细解读了线性表的基本概念，以及线性表中顺序表的重点知识。详细分析了顺序表的基本操作，图文结合，易于理解。............
Java数据结构与算法——单向链表
胜天半子祁同伟
03-11 5848
Java数据结构与算法——单向链表
Java版数据结构与算法——线性表
qq_41530937的博客
12-20 244
五、线性表 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列 前驱元素： 若A元素在B元素的前面，则称A为B的前驱元素 后继元素： 若B元素在A元素的后面，则称B为A的后继元素 线性表的特征： 第一个数据元素没有前驱，这个数据元素被称为头结点； 最后一个数据元素没有后继，这个数据元素被称为尾结点； 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继。 如果把线性表用数学语言来定义，则可以表示为(a1,…ai-1,ai,ai+1,…an
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 1万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构与算法——双向链表
qq_45767014的博客
05-27 225
前言     为了面试，时隔一年不得不重新复习数据结构与算法，这次重新复习很有收获，以前在上课总有不清晰的知识，通过这次手写一遍和敲一遍代码，以前不清晰的知识都变得清晰了，果然学编程还是得多敲代码，多敲代码，多敲代码，也要多总结，多总结，多总结。 学习资源 视频 黑马程序员  数据结构与算法 双向链表     双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点
数据结构与算法——串
小田是个程序员的博客欢迎你的到来呀~
08-03 2014
本篇文章比较全面的讲解了数据结构中串这一节的详细内容，因其与线性表类似的结构，所以有些点并没有重复提起，但是关于串的知识点，小伙伴们要多花时间去细读文章，串是编程中处理字符串比较重要的数据结构。一如既往希望我的文章能给各位小伙伴们带来帮助，数据结构与算法专栏也在持续更细中！！！...
数据结构与算法—— 单向链表
qq_45767014的博客
05-27 201
前言     为了面试，时隔一年不得不重新复习数据结构与算法，这次重新复习很有收获，以前在上课总有不清晰的知识，通过这次手写一遍和敲一遍代码，以前不清晰的知识都变得清晰了，果然学编程还是得多敲代码，多敲代码多敲代码，也要多总结，多总结，多总结 学习资源 视频 黑马程序员  数据结构于算法 单向链表     单向链表是链表的一种，它由多个结点组成，每个结点都由一个数据域和一个指针域组成，数据域用来存储数据，指针域用来指向其后继结点。链表的头结点的数据域不存储数据，指针域指向第一个真正存储数据的结点
数组、链表、堆栈和队列、线性表和顺序表 数组和链表.pdf
04-18
逻辑结构有线性和非线性之分，而物理结构则是描述数据在计算机中存储方式的学科。 数组是最基本的数据结构，很多语言都内置支持数组。数组是使用一块连续的内存空间保存数据，保存的数据的个数在分配内存的时候就是...
数据结构文档.docx
03-23
该文档属于数据结构的一部分，其中包含数据结构绪论、算法、线性表、链表，可以为程序员系小白提供0基础学习资料，
《数据结构与算法》课后习题答案(课件).pdf
10-31
"数据结构与算法"课后习题答案 《数据结构与算法》课后习题答案是一份关于数据结构和算法的习题答案文档。该文档涵盖了多个方面的知识点，包括线性表、顺序存储结构、链式存储结构、单链表、静态链表、算法设计等。...
计算机软件技术基础-算法与数据结构-2-数据结构.pptx
06-24
计算机软件技术基础–算法与数据结构–数据结构 数据结构是计算机科学中的一门基础学科，它研究的是数据的组织、存储和操作的方法和技术。数据结构是一个非常重要的概念，因为它能够影响到程序的性能、可读性和可...
java技术专家面试指南80问【java学习+面试宝典】（七）
最新发布
fengbeely的博客
06-15 1077
索引是一种数据结构,可以帮助我们快速的进行数据的查找。在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是 内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。1）计算机体系结构是指那些能够被程序员看到的计算机的属性。如指令集、数据类型等；2）计算机组成是指如何实现计算机体系结构所体现出来的属性；3）以乘法指令为例，计算机是否有乘法指令，属于体系结构的问题。乘法指令是采用专用的乘法器，还是使用加法器和移位器构成，属于计算机组成的问题。1.mycat的全局id方案。
人工智能（AI）的基础核心技术
qqk808的博客
06-12 403
人工智能（AI）的基础核心技术
某文旅集团定岗定编项目成功案例纪实
weixin_47375858的博客
06-13 1064
但是与此同时，目前的整体人数较多，存在冗员现象，并且原先由村民转化而来的员工，文化素质相对比较低，和目前业务发展不匹配，存在明显的忙闲不均、工作效率不高等问题。项目组建议优化配套的考核激励机制，集团可以鼓励员工承担多岗位职责，并针对工作量的不同给予相应的激励，有助于激发员工的工作热情，也能够提高员工在工作中的投入和责任感。针对该集团现有人员能力素质相对低，无法适应转型发展的问题，建议加强培训，增加人员一专多能的能力和专业能力，从而承担更多职责，提高工作饱和度。
(精品推荐）培训机构xx教育大型市场活动策划方案
qq253476994的博客
06-13 722
为使本次活动圆满完成，严防各类事故的发生，把不安全因素消灭在萌芽状态，成立组织机构：现场总指挥1人，联络协调员1人,安全工作人员7人。工作人员均配统一服装.宽胶布3个、双面胶2个、矿泉水3箱/天，共9箱、小推车、2盒圆珠笔、小喇叭、剪刀、裁纸刀、绳子、观众凳子、桌签、电视播放的DVD。熟悉场地做到心中有数，各安全工作人员实行岗位负责制，分工明确，职责明了、责任到人，工作人员已到现场实地的检查场地，熟悉疏散路线；1. 市场活动执行的意义：市场策划对市场活动的成功占30%的影响，市场活动执行占70%。
数据结构与算法-线性表
09-13
数据结构与算法-线性表是一种用于存储数据的数据结构，它可以按照一定的逻辑顺序来存储和访问数据。线性表的定义是一个有限个相同类型的数据元素的集合，每个数据元素都有一个唯一的前驱和后继。线性表可以用顺序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值