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

最新推荐文章于 2024-06-27 14:53:43 发布
最新推荐文章于 2024-06-27 14:53:43 发布
阅读量551 收藏 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
    评论
专栏目录
数据结构核心原理与算法应用
06-15
“程序设计 = 算法 + 数据结构”，编程者如果没有掌握数据结构与算法，就说明没有真正掌握程序设计的能力，也就是不没有真正的学会编程。 从编程的角度来看，数据结构与算法几乎是最朴素的基础知识了，这一关，...
Java数据结构和算法详细笔记
07-09
线性结构是数据结构的一种，它的特点是数据元素之间存在一对一的线性关系。在Java中，线性结构主要包括以下几种类型： 1. **数组**：是最基本的线性结构，它是一个有序的元素集合，每个元素都有自己的索引。在Java...
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法——线性表（顺序表篇）
小田是个程序员的博客欢迎你的到来呀~
06-11 6653
线性表且最简单的一种数据结构， 一个线性表是n个数据元素的有限序列 。本篇文章主要详细解读了线性表的基本概念，以及线性表中顺序表的重点知识。详细分析了顺序表的基本操作，图文结合，易于理解。............
Java数据结构与算法——单向链表
胜天半子祁同伟
03-11 5851
Java数据结构与算法——单向链表
Java版数据结构与算法——线性表
qq_41530937的博客
12-20 247
五、线性表 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列 前驱元素： 若A元素在B元素的前面，则称A为B的前驱元素 后继元素： 若B元素在A元素的后面，则称B为A的后继元素 线性表的特征： 第一个数据元素没有前驱，这个数据元素被称为头结点； 最后一个数据元素没有后继，这个数据元素被称为尾结点； 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继。 如果把线性表用数学语言来定义，则可以表示为(a1,…ai-1,ai,ai+1,…an
数组、链表、堆栈和队列、线性表和顺序表 数组和链表.pdf
04-18
逻辑结构有线性和非线性之分，而物理结构则是描述数据在计算机中存储方式的学科。 数组是最基本的数据结构，很多语言都内置支持数组。数组是使用一块连续的内存空间保存数据，保存的数据的个数在分配内存的时候就是...
《数据结构与算法》课后习题答案(课件).pdf
10-31
"数据结构与算法"课后习题答案 《数据结构与算法》课后习题答案是一份关于数据结构和算法的习题答案文档。该文档涵盖了多个方面的知识点，包括线性表、顺序存储结构、链式存储结构、单链表、静态链表、算法设计等。...
常用算法以及数据结构
11-24
数据结构和算法是编程的核心，它们是构建程序的基石。数据结构主要关注如何在内存中组织和存储数据，以便高效地访问和操作。算法则涉及如何处理这些数据，执行特定的任务。"算法+数据结构=程序"这一观点强调了两者在...
【热】查询大数据信用风险等级要注意什么?去哪里比较好？
SEOsys的博客
06-22 646
市面上提供大数据信用报告查询的地方比较多，但是素质也是参差不齐的，细心的朋友会发现，只要搜索一下大数据信用查询，会出现很多信息，也能通过这些入口进行查询，但是在选择之前一定要考虑到自己适用的版本，特别是只有一个单一的查询页面，没有人工客服的网页一定不要选择。因为投广告的服务商，一般为了走量，没有售后服务。之前有一个网友找到我解读报告，搜索了相关的关键词进来的，但是被网页里的广告混淆了视线，选错了，选了某下信用，获取了报告，但是找不到人解读，后来我们也为她免费提供了报告解读服务。
武汉星起航：挂牌上海股权中心，资本赋能共绘跨境电商繁荣新图景
m0_74145751的博客
06-22 484
同时，公司的品牌效应也将助力其在亚马逊市场上树立更加专业的形象，提升客户的信任度和忠诚度。这一里程碑式的举措不仅彰显了公司的雄厚实力，更为其在亚马逊市场的发展带来了诸多优势。武汉星起航的成功挂牌标志着其发展的新起点，凭借资本市场的强大支持，公司必将持续强化自身实力，扩大市场影响力，为客户提供卓越服务。展望未来，武汉星起航将继续引领行业创新，为亚马逊市场的繁荣贡献源源不断的动力，共同书写跨境电商的新辉煌篇章。这不仅为公司带来了更为充足的资金流，也为其在亚马逊市场的持续投入和快速发展提供了坚实的保障。
大数据智能风控：模型、平台与业务实践
Why_does_it_work的博客
06-24 4344
商业银行作为金融中介机构，经营的本质是对风险的运营和管理。金融科技的高速发展和国家政策的扶持，驱动商业银行向数字化、信息化、智能化的更高阶段发展。在此背景下，商业银行更应抓住数字化转型机遇，建立覆盖风险识别、计量、分析、处置全流程的智能风控体系，全面提升银行风险防控能力。传统的风控体系中定性风险管理占主体，以主观规则及客户评级为主，存在数据获取维度窄、定量分析能力偏弱、难以精确化用户特征等缺点。在数字化转型的背景下，传统的风险管控模式在风险管控时效性、模型有效性、监控范围等多个方面的短板日益凸显。
大数据处理的坚实基石：Scala不可变数据结构的作用
liuxin33445566的博客
06-22 426
Scala的不可变数据结构为大数据处理提供了坚实的基础。它们在确保数据处理一致性、提高容错性、优化性能、简化并行处理以及支持函数式编程范式方面发挥着重要作用。随着大数据技术的不断发展，Scala及其不可变数据结构将继续在大数据处理领域扮演关键角色。本文深入探讨了Scala中不可变数据结构的概念、优势以及在大数据处理中的应用。通过理解不可变数据结构如何确保数据处理的一致性、提高容错性、优化性能和简化并行处理，读者可以更好地利用Scala进行高效的大数据处理。
Altera不同系列的型号命名规则
caozhaokun的博客
06-23 277
Altera芯片型号：10AX07H4F34I3SG。
「五度易链」企业大数据API接口开放平台上线啦！
【五度易链】
06-21 388
“五度易链”企业大数据API接口开放平台现已正式上线，旨在为广大企业、开发者及个人提供标准、安全、高效、便捷的企业数据API接口服务，帮您更轻松地构建应用、扩展功能，并基于用户应用场景提供专属接口定制服务，助力企业提升研发效率，创造更高的商业价值。
教程：Spring Boot中集成Elasticsearch的步骤
最新发布
weixin_44627014的博客
06-27 177
Id在这个例子中，我们定义了一个简单的Book类，使用了@Document注解来指定索引名称和文档类型，@Id注解表示文档的唯一标识。通过本文的教程，我们学习了如何在Spring Boot应用中集成Elasticsearch，并通过实例代码展示了基本的数据操作和搜索功能。
利用大数据技术优化电商返利系统的效率
技术研究中心
06-23 414
通过大数据技术的应用，我们可以在数据采集、存储、处理和分析等各个环节提升电商返利系统的效率和性能。大数据技术不仅能够帮助我们优化返利规则，提高系统的响应速度，还能为用户提供更好的体验。希望本文对大家在实际项目中有所帮助。
转--Hadoop集群部署案例
shjita的博客
06-22 920
三台虚拟机的最低配置为1核1G + 20G。若是按照《[选修]基于OpenEuler的Docker容器安装使用教程》创建的Docker容器环境，或者从一道云科技发展有限公司提供的百度盘链接下载的VMWare镜像直接导入的Docker容器环境，直接移步到“步骤一”开始。当然你也可以使用你的虚拟机默认的网段来配置三台虚拟机的固定IP，只是需要注意后续步骤中的IP都要和你配置的IP相匹配。，使用SCP命令将Windows工作机上的Hadoop包复制到master虚拟机的/root/software/路径下。
数据结构各种算法的经解分析1
08-03
线性表就是一个典型的线性结构，而非线性结构则指数据逻辑结构中不满足线性结构定义的结构。 在数据结构的各种算法中，我们也讨论了一些重要的概念和技术。例如，我们学习了算法的时间复杂度和空间复杂度，这两个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值