35.树与二叉树练习（1）（王道第5章综合练习）

news2024/9/29 15:22:46

【所用的树，队列，栈的基本操作详见上一节代码】

试题1（王道5.3.3节第3题）：

编写后序遍历二叉树的非递归算法。

参考：34.二叉链树的C语言实现_北京地铁1号线的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/qq_54708219/article/details/133581706

试题2（王道5.3.3节第4题）：

给出二叉树自下而上，从右到左的层次遍历算法。

这道题很显然就是层次遍历算法调个个，加个栈即可实现：

//层次遍历（自下而上，从右到左）
void LevelOrder2(BiTree T){
    Queue q;
    InitQueue(q);
    Sqstack S;
    InitStack(S);
    BiTree p = T;
    InsertQueue(q, p);
    while(!IsQueueEmpty(q)){
        p = DeleteQueue(q, p);
        InsertSqstack(S, p);
        if(p->lchild!=NULL)
            InsertQueue(q, p->lchild);
        if(p->rchild!=NULL)
            InsertQueue(q, p->rchild);
    }
    while(S.top != -1){
        p = DeleteSqstack(S, p);
        printf("%c", p->data);
    }
}

输出：

输入二叉树的前序序列，#代表空子树:
ABD##E##C##
二叉树创建成功！
二叉树的层次遍历序列是：ABCDE
二叉树的层次遍历（自下而上，自右向左）序列是：EDCBA

试题3（王道5.3.3节第5题）：

设计非递归算法求二叉树的高度。

此题采用层次遍历，附设一个指针a：

//利用层次遍历实现非递归计算树的深度
int LevelOrderDepth(BiTree T){
    int Depth = 0;
    if(!T)
        return Depth;
    else{
        Queue q;
        InitQueue(q);
        BiTree p = T;
        InsertQueue(q, p);
        Depth = 1;
        int a = q.rear;  //指针a指向队尾，也就是这一层最后一个元素
        while(!IsQueueEmpty(q)){
            if(q.front==a){  //这个时候说明这一层出完了，此时rear就是下一行的末尾结点
                a = q.rear;
                Depth = Depth + 1;
            }
            p = DeleteQueue(q, p);
            if(p->lchild!=NULL)
            InsertQueue(q, p->lchild);
            if(p->rchild!=NULL)
            InsertQueue(q, p->rchild);
        }
        return Depth;
    }
}

输出：

输入二叉树的前序序列，#代表空子树:
ABD##E##C##
二叉树创建成功！
二叉树的深度是（非递归算法）：3

试题4（王道5.3.3节第6题）：

设一棵二叉树中各结点的值互不相同，其先序遍历序列和中序遍历序列分别存放在两个数组A和B中，试编写算法建立该二叉树的二叉链表。

仍需要采用递归操作，这里要想办法根据前序序列找到根结点，然后在中序序列找根结点，从而确定哪些结点属于左子树，哪些结点属于右子树。

//由先序序列和中序序列建立二叉树
BiTree CreateBiTreeviaOrders(char a[],char b[],int x1,int y1,int x2,int y2){
    //x1,y1工作在前序序列中，x2,y2工作在中序序列中
    BiTree T;
    T = (BiTree)malloc(sizeof(BiTNode));
    T->data = a[x1];  //前序序列的第一个结点就是根结点
    int llen, rlen;
    for (int i = x2; i <= y2; i++){  //在中序序列找根结点
        if(b[i] == a[x1]){
            llen = i - x2;  //左子树的序列长度（结点个数）
            rlen = y2 - i;  //右子树的序列长度（结点个数）
        }
    }
    if (llen == 0)
        T->lchild = NULL;
    else
        T->lchild = CreateBiTreeviaOrders(a, b, x1 + 1, x1 + llen, x2, x2 + llen - 1);
    if (rlen == 0)
        T->rchild = NULL;
    else
        T->rchild = CreateBiTreeviaOrders(a, b, y1 - rlen + 1, y1, y2 - rlen + 1, y2);
    return T;
}

int main(){
    BiTree T;
    char a[6] = {'A', 'B', 'C', 'D', 'E', 'F'};  //先序序列
    char b[6] = {'C', 'B', 'A', 'E', 'D', 'F'};  //中序序列
    T = CreateBiTreeviaOrders(a, b, 0, 5, 0, 5);  //初始必须是0和数组长度减一
    printf("该二叉树的后序遍历序列是：");
    PostOrderTraverse(T);  //输出后序序列进行验证
    return 0;
}

这里以王道5.3.3节单选15题进行验证，输出结果就是A选项。

该二叉树的后序遍历序列是：CBEFDA

试题5（王道5.3.3节第7题）：

二叉树按二叉链表存储，写一个判别给定二叉树是否是完全二叉树的算法。

此题的思路是借助层次遍历和队列，当队列中输出空结点的时候，如果此时队列还有非空结点说明不是完全二叉树。注意这里输入和验证的都是扩展二叉树，所以去掉了层次遍历中的结点非空判断。

//判断是否是完全二叉树
bool IfCompleteTree(BiTree T){
    Queue q;
    InitQueue(q);
    BiTree p = T;
    if(!p)
        return true;
    InsertQueue(q, p);
    while(!IsQueueEmpty(q)){
        p = DeleteQueue(q, p);
        if(p!=NULL){
            InsertQueue(q, p->lchild);
            InsertQueue(q, p->rchild);
        }
        else{
            int a = q.front;
            while(a!=q.rear){
                if(q.data[a]!=NULL)
                    return false;
                a = (a + 1) % MAXSIZE;
            }
            return true;
        }   
    }
}

int main(){
    BiTree T;
    printf("输入二叉树的前序序列，#代表空子树:\n");
    CreateBiTree(T);
    printf("二叉树创建成功！\n");
    printf("该二叉树是否是完全二叉树？%d", IfCompleteTree(T));
    return 0;
}

输出：

输入二叉树的前序序列，#代表空子树:
ABD##E##C##
二叉树创建成功！
该二叉树是否是完全二叉树？1

输入二叉树的前序序列，#代表空子树:
AB##CD##E##
二叉树创建成功！
该二叉树是否是完全二叉树？0

试题6（王道5.3.3节第8题）：

设二叉树采用二叉链表存储结构，设计算法计算给定二叉树的双分支结点个数。

递归算法：

//判断是否是完全二叉树
int TwobranchNodes(BiTree T){
    if(T==NULL)
        return 0;
    else if(T->lchild!=NULL&&T->rchild!=NULL)
        return TwobranchNodes(T->lchild) + TwobranchNodes(T->rchild) + 1;
    else
        return TwobranchNodes(T->lchild) + TwobranchNodes(T->rchild);
}

非递归算法（层次遍历逐个结点检查）：

//判断是否是完全二叉树
int TwobranchNodes(BiTree T){
    int a = 0;
    Queue q;
    InitQueue(q);
    BiTree p = T;
    InsertQueue(q, p);
    while(!IsQueueEmpty(q)){
        p = DeleteQueue(q, p);
        if(p->lchild!=NULL && p->rchild!=NULL)
            a = a + 1;
        if(p->lchild!=NULL)
            InsertQueue(q, p->lchild);
        if(p->rchild!=NULL)
            InsertQueue(q, p->rchild);
    }
    return a;
}

试题7（王道5.3.3节第9题）：

设树B是一棵采用链式结构存储的二叉树，编写一个把树B中所有结点的左右子树进行交换的函数。

此题同题6一样也可以用递归或层次遍历的方法，这里给出非递归的方法：

//把二叉树的左右子树交换
int ChangeTwobranch(BiTree &T){
    Queue q;
    InitQueue(q);
    BiTree p = T;
    BiTree r;
    InsertQueue(q, p);
    while(!IsQueueEmpty(q)){
        p = DeleteQueue(q, p);
        if(p->lchild!=NULL || p->rchild!=NULL){
            r = p->lchild;
            p->lchild = p->rchild;
            p->rchild = r;
        }
        if (p->lchild != NULL)
            InsertQueue(q, p->lchild);
        if(p->rchild!=NULL)
            InsertQueue(q, p->rchild);
    }
    return 0;
}

输出：

输入二叉树的前序序列，#代表空子树:
ABD##E##C##
二叉树创建成功！
该二叉树的层次遍历序列是：ACBED

试题8（王道5.3.3节第10题）：

假设二叉树采用二叉链存储结构存储，设计算法求先序遍历序列中第k个结点的值。

这里使用一个计数器即可：

//输出前序遍历的第x个元素
void PreOrderx(BiTree T,int x){
    int a = 0;
    BiTree p = T; //p是遍历指针
    Sqstack S;
    InitStack(S);
    while(p != NULL|| !IsStackEmpty(S)){
        if(p){
            a = a + 1;
            if(a == x){
                printf("第%d个元素是：%c", x, p->data);
                break;
            }  
            InsertSqstack(S, p);
            p = p->lchild;
        }
        else{
            p = DeleteSqstack(S, p);
            p = p->rchild;
        }
    }
}

当然也可以采用递归，注意这里的计数器必须写在全局变量里，否则每次调用递归都会从零开始：

//输出前序遍历的第x个元素
int a = 0;  //计数器
void PreOrderx(BiTree T,int x){
    if (T!=NULL){
        a = a + 1;
        if(a==x)
            printf("前序遍历序列的第%d个元素是：%c", x, T->data);
        PreOrderx(T->lchild,x);
		PreOrderx(T->rchild,x);
	}
}

int main(){
    BiTree T;
    printf("输入二叉树的前序序列，#代表空子树:\n");
    CreateBiTree(T);
    printf("二叉树创建成功！\n");
    PreOrderx(T, 3);
    return 0;
}

输出：

输入二叉树的前序序列，#代表空子树:
ABD##E##C##
二叉树创建成功！
前序遍历序列的第3个元素是：D

试题9（王道5.3.3节第11题）：

已知二叉树以二叉链表存储，编写算法完成：对于树中的每个值为x的结点，删去以它为根的子树，并释放相应空间。

仍然是与层次遍历结合：

//这个函数用来删除树T
void Free(BiTree &T){
    if(T!=NULL){
        Free(T->lchild);
        Free(T->rchild);
        free(T);
    }
}

//对值为x的结点，删除以它为根的子树
void Freex(BiTree &T,char x){
    Queue q;
    InitQueue(q);
    BiTree p = T;
    InsertQueue(q, p);
    while(!IsQueueEmpty(q)){
        p = DeleteQueue(q, p);
        if(p->data == x){
            Free(p->lchild);  //这样写保留了当前结点
            Free(p->rchild);
            p->lchild = NULL;
            p->rchild = NULL;
        }
        if(p->lchild!=NULL)
            InsertQueue(q, p->lchild);
        if(p->rchild!=NULL)
            InsertQueue(q, p->rchild);
    }
}

int main(){
    BiTree T;
    printf("输入二叉树的前序序列，#代表空子树:\n");
    CreateBiTree(T);
    printf("二叉树创建成功！\n");
    printf("当前二叉树的层次遍历序列是：");
    LevelOrder(T);
    printf("\n");
    Freex(T, 'B');  //删除以B为根结点的树
    printf("当前二叉树的层次遍历序列是：");
    LevelOrder(T);
    printf("\n");
    return 0;
}

输出：

输入二叉树的前序序列，#代表空子树:
ABD##E##C##
二叉树创建成功！
当前二叉树的层次遍历序列是：ABCDE
当前二叉树的层次遍历序列是：ABC

输入二叉树的前序序列，#代表空子树:
ABD###CE##F##
二叉树创建成功！
当前二叉树的层次遍历序列是：ABCDEF
当前二叉树的层次遍历序列是：ABCEF

试题10（王道数据结构5.3.3节第12题）：

编写算法打印值为x的结点的所有祖先，假设值为x的结点不多于一个。

此题的算法十分典型：它用的是非递归后序遍历算法，这种算法需要借助栈来实现，当访问到值为x的结点的时候，栈中所有元素就是该结点的祖先，依次打印输出即可。有关非递归后序遍历算法的代码在上一节。

//寻找给定结点的所有祖先结点，采用后续遍历的非递归算法
void FindParents(BiTree T,char x){
    Sqstack S;
    InitStack(S);
    BiTree p = T;
    BiTree r = NULL;  //r用来记录访问结点的前一个结点
    while(p||!IsStackEmpty(S)){
        if(p){
            InsertSqstack(S, p);
            p = p->lchild;
        }
        else{
            p = S.data[S.top];  //读栈顶元素（但不出栈）
            if(p->rchild&&p->rchild!=r){
                p = p->rchild;
            }
            else{
                p = DeleteSqstack(S, p);
                if(p->data == x){
                    printf("%c", p->data);
                    break;
                }
                r = p;
                p = NULL;
            }
        }
    }
    while(!IsStackEmpty(S)){  //这个时候栈里的元素全部是结点的祖先
        p = DeleteSqstack(S, p);
        printf("%c", p->data);
    }
}

int main(){
    BiTree T;
    printf("输入二叉树的前序序列，#代表空子树:\n");
    CreateBiTree(T);
    printf("二叉树创建成功！\n");
    printf("当前二叉树的层次遍历序列是：");
    LevelOrder(T);
    printf("\n");
    printf("当前二叉树中结点E的祖先结点是：");
    FindParents(T, 'E');
    return 0;
}

输出：

输入二叉树的前序序列，#代表空子树:
ABD##E##C##
二叉树创建成功！
当前二叉树的层次遍历序列是：ABCDE
当前二叉树中结点E的祖先结点是：EBA

试题11（王道数据结构5.3.3节第13题）：

给出二叉链树中两个结点的指针p和q，试编写算法求解p和q的公共祖先结点r。

此题和上一题很像，分别求出p和q的祖先然后比较即可。

//寻找给定结点的所有祖先结点，采用后续遍历的非递归算法，和上一题不同的是，本题以栈的形式返回
Sqstack FindParents(BiTree T,char x){
    Sqstack S;
    InitStack(S);
    BiTree p = T;
    BiTree r = NULL;  //r用来记录访问结点的前一个结点
    while(p||!IsStackEmpty(S)){
        if(p){
            InsertSqstack(S, p);
            p = p->lchild;
        }
        else{
            p = S.data[S.top];  //读栈顶元素（但不出栈）
            if(p->rchild&&p->rchild!=r){
                p = p->rchild;
            }
            else{
                p = S.data[S.top];
                if(p->data == x){
                    break;
                }
                p = DeleteSqstack(S, p);
                r = p;
                p = NULL;
            }
        }
    }
    return S;
}
//有了两个栈我们就可以遍历然后找到祖先结点了
//注意这里最差也能返回整棵二叉树的根结点，或者返回其中一个结点时，代表一个结点就是另一个结点的祖先
BiTree FindSameParents(BiTree T,char a,char b){
    Sqstack S1 = FindParents(T, a);
    Sqstack S2 = FindParents(T, b);
    int same = -1;  //same用来遍历两个栈，并指向最后一个相同的祖先结点
    while(S1.data[same+1] == S2.data[same+1]){
        same = same + 1;
    }
    printf("%c", S1.data[same]->data);
    return S1.data[same];
}

int main(){
    BiTree T;
    printf("输入二叉树的前序序列，#代表空子树:\n");
    CreateBiTree(T);
    printf("二叉树创建成功！\n");
    printf("当前二叉树的层次遍历序列是：");
    LevelOrder(T);
    printf("\n");
    printf("当前二叉树中结点E，F的祖先结点是：");
    FindSameParents(T, 'E', 'F');  //求E,F的祖先结点
    return 0;
}

输出：

输入二叉树的前序序列，#代表空子树:
ABD###CE##F##
二叉树创建成功！
当前二叉树的层次遍历序列是：ABCDEF
当前二叉树中结点E，F的祖先结点是：C

试题12（王道数据结构5.3.3节第14题）：

假设二叉树采用二叉链表存储，设计一个算法求非空二叉树的宽度（也就是结点数最多的那一层的结点个数）。

此题仍然可以利用层次遍历把每层的结点数输出，存在一个数组里面然后找出最大值：

//求非空二叉树的宽度，借助层次遍历把每层的结点数都求出来
int LevelOrderWidth(BiTree T){
    Queue q;
    InitQueue(q);
    BiTree p = T;
    InsertQueue(q, p);
    int a = q.front;  //a指针指向这一层的第一个结点
    int b = q.rear;  //b指针指向这一层的第一个结点
    int num = 1;     //输出这一层的结点个数
    int numarray[10];  //把各层的结点个数存在一个数组里
    int depth = 0;  //深度，实际深度是depth+1，因为numarray数组下标从0开始
    numarray[depth] = num;
    while(!IsQueueEmpty(q)){
        if(q.front == b){  //说明这一层出完了
            a = q.front;  //a指向下一层第一个结点
            b = q.rear;  //b指向下一层最后一个结点
            num = (b - a > 0) ? (b - a) : (b - a + MAXSIZE);  //循环队列三目运算符判断
            depth = depth + 1;
            numarray[depth] = num;
        }
        p = DeleteQueue(q, p);
        if(p->lchild!=NULL)
            InsertQueue(q, p->lchild);
        if(p->rchild!=NULL)
            InsertQueue(q, p->rchild);
    }
    //到此numarray存储了每层的结点数，接下来找其中的最大值输出
    num = 1;
    for (int i = 0; i <= depth;i++){
        printf("%d", numarray[i]);
        if(numarray[i] > num)
            num = numarray[i];
    }
    return num;
}

int main(){
    BiTree T;
    printf("输入二叉树的前序序列，#代表空子树:\n");
    CreateBiTree(T);
    printf("二叉树创建成功！\n");
    printf("当前二叉树的层次遍历序列是：");
    LevelOrder(T);
    printf("\n");
    printf("各层的结点数是：");
    printf("二叉树的宽度是：%d",LevelOrderWidth(T));
    return 0;
}

输出：

输入二叉树的前序序列，#代表空子树:
ABDF##G##E##CH###
二叉树创建成功！
当前二叉树的层次遍历序列是：ABCDEHFG
各层的结点数是：1232二叉树的宽度是：3

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1077692.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【【萌新的SOC学习之重新起航SOC】】

【【萌新的SOC学习之重新起航SOC】】

萌新的SOC学习之重新起航SOC ZYNQ PL 部分等价于 Xilinx 7 系列 FPGA PS端&#xff1a;Zynq 实际上是一个以处理器为核心的系统&#xff0c;PL 部分可以看作是它的一个外设。 我们可以通过使用AXI(Advanced eXtensible Interface)接口的方式调用 IP 核&#xff0c;系统通过 AX…
阅读更多...
四维曲面如何画？matlab

四维曲面如何画？matlab

clc; clear all [theta,phi]meshgrid(linspace(0,pi,50),linspace(0,2*pi,50)); zcos(theta); xsin(theta).*cos(phi); ysin(theta).*sin(phi); f-1*((x.*y).2(y.*z).2(z.*x).^2); surf(sin(theta).*cos(phi).*f,sin(theta).*sin(phi).*f,cos(theta).*f,f) 结果
阅读更多...
第九天！玩转langchain！回调处理器！一篇学会日志+监控+流式传输！9/10

第九天！玩转langchain！回调处理器！一篇学会日志+监控+流式传输！9/10

原文&#xff1a;第九天&#xff01;玩转langchain&#xff01;回调处理器&#xff01;一篇学会日志监控流式传输&#xff01;9/10 - 知乎 在第九篇&#xff01;跟着雄哥学langchain中的回调处理器&#xff01; 时间飞快呀~已经第九课了&#xff0c;在更新的这10天时间&#x…
阅读更多...
电脑出现msvcp110.dll丢失的解决方法，快速解决msvcp110.dll丢失

电脑出现msvcp110.dll丢失的解决方法，快速解决msvcp110.dll丢失

电脑中经常会出现msvcp110.dll文件丢失的情况&#xff0c;所以如果电脑中缺失msvcp110.dll文件会让大家很苦恼&#xff0c;那么msvcp110.dll丢失有什么解决办法呢&#xff1f;今天就给大家介绍几种msvcp110.dll丢失的解决办法。 一.msvcp110.dll常出现的问题 1.当您尝试打开某…
阅读更多...
Springcloud笔记（2）-Eureka服务注册

Springcloud笔记（2）-Eureka服务注册

Eureka服务注册 服务注册&#xff0c;发现。 在Spring Cloud框架中&#xff0c;Eureka的核心作用是服务的注册和发现&#xff0c;并实现服务治理。 Eureka包含两个组件&#xff1a;Eureka Server和Eureka Client。 Eureka Server提供服务注册服务&#xff0c;各个节点启动后…
阅读更多...
Spring AOP的失效场景

Spring AOP的失效场景

首先&#xff0c;Spring的AOP其实是通过动态代理实现的&#xff0c;所以&#xff0c;想要让AOP生效&#xff0c;前提必须是动态代理生效&#xff0c;并且可以调用到代理对象的方法什么情况下会不走代理对象的调用呢&#xff1f;首先就是类内部的调用&#xff0c;比如一些私有方…
阅读更多...
中国人民大学与加拿大女王大学金融硕士——不忘初心，点燃梦想之火

中国人民大学与加拿大女王大学金融硕士——不忘初心，点燃梦想之火

人类所具有的种种力量中&#xff0c;最神奇的莫过于梦想的力量。梦想使人生更有意义&#xff0c;是人类的先锋&#xff0c;是前进的引路人。有梦想&#xff0c;才会有希望&#xff0c;才会激发我们内在的潜能&#xff0c;努力去求得光明的前途。让我们点燃梦想之火&#xff0c;…
阅读更多...
Linux系统切换用户后只显示$问题解决

Linux系统切换用户后只显示$问题解决

问题描述&#xff1a; unbantu操作系统切换为es用户后没有tab键没有补全功能 问题分析 创建用户的时候未指定shell类型&#xff0c;默认的shell为/bin/sh&#xff0c;而不是/bin/bash。 cat /etc/passwd查询结果 es:x:1001:1001::/home/es:/bin/sh解决方案 把对应用户的…
阅读更多...
【Mysql实现递归树查询】

【Mysql实现递归树查询】

Mysql8实现递归查询 递归执行分析demo数据查询demo数据扩展字段扩展 大家好! 在我们日常工作中&#xff0c;经常会遇到一些问题,它们的一些解决方案通常会用到递归这一强大的技术手段。递归不仅能帮助我们更高效的解决问题,还可以使代码更简介、更易于理解, 今天我来给大家分享…
阅读更多...
Can 通信-协议

Can 通信-协议

概述 CAN 是 Controller Area Network 的缩写&#xff08;以下称为 CAN&#xff09;&#xff0c;是 ISO国际标准化的串行通信协议。 在当前的汽车产业中&#xff0c;出于对安全性、舒适性、方便性、低公害、低成本的要求&#xff0c;各种各样的电子控制系统 被开发了出来。由于…
阅读更多...
Spring中shutdown hook作用

Spring中shutdown hook作用

在Spring框架中&#xff0c;Shutdown Hook&#xff08;关闭钩子&#xff09;是一种机制&#xff0c;用于在应用程序关闭时执行一些清理操作Spring会向JVM注册一个shutdown hook&#xff0c;在接收到关闭通知的时候&#xff0c;进行bean的销毁&#xff0c;容器的销毁处理等操作在…
阅读更多...
代码随想录算法训练营第23期day17| 110.平衡二叉树、257. 二叉树的所有路径、404.左叶子之和

代码随想录算法训练营第23期day17| 110.平衡二叉树、257. 二叉树的所有路径、404.左叶子之和

目录 一、&#xff08;leetcode 110&#xff09;平衡二叉树 二、&#xff08;leetcode 257&#xff09;二叉树的所有路径 三、&#xff08;leetcode 404&#xff09;左叶子之和 一、&#xff08;leetcode 110&#xff09;平衡二叉树 力扣题目链接 状态&#xff1a;已AC 求深…
阅读更多...
【Qt】三种方式实现抽奖小游戏

【Qt】三种方式实现抽奖小游戏

简介 本文章是基本Qt与C实现一个抽奖小游戏&#xff0c;用到的知识点在此前发布的几篇文章。 下面是跳转链接&#xff1a; 【Qt控件之QLabel】用法及技巧链接&#xff1a; https://blog.csdn.net/MrHHHHHH/article/details/133691441?spm1001.2014.3001.5501 【Qt控件之QPus…
阅读更多...
C++ 类和对象(一)

C++ 类和对象(一)

1.面向过程和面向对象初步认识 C语言是面向过程的&#xff0c;关注的是过程&#xff0c;分析出求解问题的步骤&#xff0c;通过函数调用逐步解决问题。 C是基于面向对象的&#xff0c;关注的是对象&#xff0c;将一件事情拆分成不同的对象&#xff0c;靠对象之间的交互完 成。 …
阅读更多...
启山智软/商城源码

启山智软/商城源码

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 启山智软一、五种商业模式赋能1.S2B2C供应链商城2.B2B2C多商户商城3.B2C单商户商城4.O2O外卖配送5.社区团购 二、过硬的编程实力1.前端2.后端 总结 启山智软 想要了…
阅读更多...
【【萌新的SOC学习之AXI接口简介】】

【【萌新的SOC学习之AXI接口简介】】

萌新的SOC学习之AXI接口简介 AXI总线的初步介绍 AXI 总线是 ARM AMBA 一部分 &#xff08;高级可扩展接口&#xff09; AMBA(高级微控制器总线架构&#xff09; &#xff1a;开放的片内互联的总线标准&#xff0c;能再多主机设计中实现多个控制器和外围设备之间的连接和管理。…
阅读更多...
配置Hive使用Spark执行引擎

配置Hive使用Spark执行引擎

配置Hive使用Spark执行引擎 Hive引擎概述兼容问题安装SparkSpark配置Hive配置HDFS上传Spark的jar包执行测试速度对比 Hive引擎 概述 在Hive中&#xff0c;可以通过配置来指定使用不同的执行引擎。Hive执行引擎包括&#xff1a;默认MR、tez、spark MapReduce引擎&#xff1a; 早…
阅读更多...
利用excel表格进行分包和组包

利用excel表格进行分包和组包

实际使用中&#xff0c;我们可能希望修改某几个数据之后&#xff0c;最终的数据包能够自动发动数据&#xff0c;类似于在给结构体变量修改数据&#xff0c;自动生成完整的结构体&#xff1b; excel语法 1&#xff1a;拆分数据 LEFT(A4,2) – 取A4单元格左边的两个数据 RIGHT(A4…
阅读更多...
4.02 用户中心-上传头像功能开发

4.02 用户中心-上传头像功能开发

详细内容请看下面地址&#xff1a; 地址&#xff1a;http://www.gxcode.top/code
阅读更多...
【JavaScript】浅拷贝与深拷贝

【JavaScript】浅拷贝与深拷贝

引言 浅拷贝、深拷贝是对引用类型而言的。 引用类型的变量对应一个栈区地址&#xff0c;这个栈区地址处存储的值是存放的真正的数据的堆区地址。 基本数据类型的变量也对应一个栈区地址&#xff0c;但是该地址存储的是其真正的值。 let a b发生了什么&#xff1f; let obj…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023