深信服面经---云计算方向(附问题知识点解析)

这篇具有很好参考价值的文章主要介绍了深信服面经---云计算方向(附问题知识点解析)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、一面问题概览

1、先做一下的自我介绍。
2、是否了解go语言?
3、项目中成就感最大的是哪个?
4、协议头引入之后,包的大小增加了多少(根据项目问的)?
5、redis缓存问题,如何建立缓存(根据项目问的)?
6、cache中间件更新机制是怎么样的(根据项目问的)?
7、为什么更新数据的时候不是用写的方式而是使用删除的方式(根据项目问的)?
8、redis缓存热点数据,具体在什么场景下会产生脏数据?
9、在CRUD中,你的后台服务是先处理数据库还是先处理缓存(redis)?这四个操作分别是怎么处理的?
10、缓存方案中,先删除缓存数据,再更新数据库,最后再同步(写),这种方式在高并发下会产生什么问题 ?数据一致性会不会有问题?(或者说同时出现并发读和并发写的情况,会发生什么?)
11、还知道其他的缓存更新模式吗?
12、内存泄漏怎么检测?
13、如果一个服务的句柄(文件句柄或socket句柄)一直增加没有下降,怎么分析?是什么问题?
14、系统下调大句柄数量的命令是什么?ulimit。
15、socket句柄比较多,怎么分析和解决?这种现象在什么情况下是正常的?在什么场景下是不正常的?
16、服务非常多,接口也非常多,现在不知道在内存或socket句柄在何处泄漏的,怎么分析?
17、什么是零拷贝?
18、哪些技术可以做到零拷贝?
19、什么是Direct IO?
20、操作系统上,说一下协程、线程、进程三者的关系?在资源上面有什么差别?
21、父子进程在资源上有什么区别?(可以从fork的写时复制来说明)
22、C++中map数据结构,底层为什么不使用高度平衡二叉树来做?(https://blog.csdn.net/weixin_61207303/article/details/123402294)
23、对windows上的程序开发是怎么理解的?
24、window开发客户端最头疼的问题是什么?
25、windows用户界面库有哪些?(qt、duilibUI)
26、消息队列存在的价值是什么?主要解决什么问题?
27、引入消息队列会带来什么问题?
28、说一下消息队列的优缺点

二、实操相关

1、面向google编程,面向stack overflow编程,画出流程图。

1)Google不到代码怎么办?
2)如果google到的代码最后验证不是想要或合适的(验证失败),怎么办?

2、算法题,给一个数组root[]={6,3,5,3,6,7,8,-1,-1,5,6},构建二叉树,然后中序遍历输出二叉树。

小结:

  1. 回答方式有待提升,需要拓展讲述技术,切忌一问一答(应该就问的知识点进行扩展讲述)。
  2. 回答需清晰贯通,尽量避免停顿。
  3. 语速平和,逻辑要清晰。

三、复盘对问题答案进行整理(查漏补缺)

3.1、go语言简单了解

大厂后端高并发程序 / 服务基本都有引入golang语言来开发,所以需要了解一下golang语言。

golang为高并发而生,由google在2009年正式发布,golang从语言级别支持并发,通过轻量协程goroutine实现程序并发运行。
golang语言是google推出的具有强类型,原生支持并发,且具有垃圾回收(GC)功能的编译型语言。Go 语言语法与 C 相近,但功能上有:内存安全,GC(垃圾回收),结构形态及 CSP-style 并发计算。

golang的轻量主要体现在:

  1. 上下文切换代价小。goroutine上下文切换只涉及三个寄存器(计数寄存器PC、堆栈指针寄存器SP、数据寄存器DX)的值修改,而对比线程的上下文切换则需要涉及模式切换(从用户态切换到内核态)、以及 超过16 个寄存器的刷新。
  2. 内存占用少。线程栈空间是2M,goroutine的栈空间最小只有2K。

Golang 程序中可以轻松支持10w 级别的 Goroutine 运行,而线程数量达到 1k 时,内存占用就已经达到 2G。

go调度器模型通常称为G-P-M模型,它包括四个重要结构:G、P、M、Sched。go程序通过调度器来调度goroutine在内核线程上的执行,但是G(goroutine)并不直接绑定OS线程M(Machine)运行,而是由goroutine scheduler中的P(processor,逻辑处理器)来作为获取内核线程资源的中介。
Go 调度器中有两个不同的运行队列:全局运行队列(GRQ)和本地运行队列(LRQ);每个 P 都有一个 LRQ,用于管理分配给在 P 的上下文中执行的 Goroutines,这些 Goroutine 轮流被和 P 绑定的 M 进行上下文切换。GRQ 适用于尚未分配给 P 的 Goroutines。
深信服面经---云计算方向(附问题知识点解析)

(1)G:Goroutine,每个 Goroutine 对应一个 G 结构体,G 存储 Goroutine 的运行堆栈、状态以及任务函数,可重用。G 并非执行体,每个 G 需要绑定到 P 才能被调度执行
(2)P: Processor,表示逻辑处理器,对 G 来说,P 相当于 CPU 核,G 只有绑定到 P 才能被调度。对 M 来说,P 提供了相关的执行环境(Context),如内存分配状态,任务队列等。P 的数量决定了系统内最大可并行的 G 的数量(前提:物理 CPU 核数 >= P 的数量)。P 的数量由用户设置的 GoMAXPROCS 决定,但是不论 GoMAXPROCS 设置为多大,P 的数量最大为 256。
(3)M: Machine,OS 内核线程抽象,代表着真正执行计算的资源,在绑定有效的 P 后,进入 schedule 循环;而 schedule 循环的机制大致是从 Global 队列、P 的 Local 队列以及 wait 队列中获取。M 的数量是不定的,由 Go Runtime 调整,为了防止创建过多 OS 线程导致系统调度不过来,目前默认最大限制为 10000 个。M 并不保留 G 状态,这是 G 可以跨 M 调度的基础。
(4)Sched:Go 调度器,它维护有存储 M 和 G 的队列以及调度器的一些状态信息等。调度器循环的机制大致是从各种队列、P 的本地队列中获取 G,切换到 G 的执行栈上并执行 G 的函数,调用 Go exit 做清理工作并回到 M,如此反复。

Go 程序可以利用少量的内核级线程来支撑大量 Goroutine 的并发。多个 Goroutine 通过用户级别的上下文切换来共享内核线程 M 的计算资源,但对于操作系统来说并没有线程上下文切换产生的性能损耗。

为了更加充分利用线程的计算资源,Go 调度器采取了以下几种调度策略:
(1)任务窃取(work-stealing)。当每个 P 之间的 G 任务不均衡时,调度器允许从 GRQ,或者其他 P 的 LRQ 中获取 G 执行。

(2)减少阻塞。在 Go 里面阻塞主要分为一下 4 种场景:

  1. 由于原子、互斥量或通道操作调用导致 Goroutine 阻塞,调度器将把当前阻塞的 Goroutine 切换出去,重新调度 LRQ 上的其他 Goroutine。
  2. 由于网络请求和 IO 操作导致 Goroutine 阻塞,Go 程序提供了网络轮询器(NetPoller)来处理网络请求和 IO 操作的问题,其后台实现 IO 多路复用。通过使用 NetPoller 进行网络系统调用,调度器可以防止 Goroutine 在进行这些系统调用时阻塞 M。这可以让 M 执行 P 的 LRQ 中其他的 Goroutines,而不需要创建新的 M;有助于减少操作系统上的调度负载。实现了 goroutine-per-connection 简单的网络编程模式(但是大量的 Goroutine 也会带来额外的问题,比如栈内存增加和调度器负担加重)。
    深信服面经---云计算方向(附问题知识点解析)
    深信服面经---云计算方向(附问题知识点解析)
    深信服面经---云计算方向(附问题知识点解析)
  3. 当调用一些系统方法的时候,如果系统方法调用的时候发生阻塞,这种情况下,网络轮询器(NetPoller)无法使用,而进行系统调用的 Goroutine 将阻塞当前 M。调度器将 M1 与 P 分离,同时也将 G1 带走。然后调度器引入新的 M2 来服务 P。此时,可以从 LRQ 中选择 G2 并在 M2 上进行上下文切换。阻塞的系统调用完成后,G1 可以移回 LRQ 并再次由 P 执行。如果这种情况再次发生,M1 将被放在旁边以备将来重复使用。
    深信服面经---云计算方向(附问题知识点解析)
    深信服面经---云计算方向(附问题知识点解析)
  4. 如果在 Goroutine 去执行一个 sleep 操作,导致 M 被阻塞了。Go 程序后台有一个监控线程 sysmon,它监控那些长时间运行的 G 任务然后设置可以强占的标识符,别的 Goroutine 就可以抢先进来执行。只要下次这个 Goroutine 进行函数调用,那么就会被强占,同时也会保护现场,然后重新放入 P 的本地队列里面等待下次执行。

3.2、项目中成就感最大或挑战最大的地方

没有有挑战的项目可以考虑项目用到的技术栈有哪些风险,然后针对存在的风险,给出一套完美的解决方案。
有好项目的可以从系统设计的层面上讲述。

比如我的项目中,要设计开发一个局域网内高效的后台服务器程序,最大的成就是设计了一个高效网络传输协议,为集中式并发提供高效应答(或者,最大的挑战是如何设计出一个高效的网络模型和通信协议,实现高并发应答),项目中,客户端只知道服务端开放的端口,第一个版本中为了保证数据的可靠性,主要使用TCP传输数据,但是因为不知道服务器的IP,所以先使用UDP发送广播来探寻服务器,获得服务器IP后转为TCP来传输数据;后来经过验证,传输的数据大部分都比较小,而且在局域网内UDP丢失数据的概率极低,因此转为UDP为主进行应答,因为UDP 具有较好的实时性,工作效率比 TCP 高,应答效率和数据传输效率提高了一倍。

这个过程,不仅仅体现出你排查解决问题的能力,另一方面也突出你的沉淀和自我思考能力。

3.3、项目问题—协议头引入之后,包的大小增加了多少

在我的项目中,引入了这样的协议头:

 1 byte    1 byte                        6 bytes
+--------+--------+-----------------------------------------------------+
| opcode | pl_len |        src_ip                                       |
+-----------------------------------------------------------------------+
|                          src_ip                                       |
+-----------------+-----------------------------------------------------+
|    src_ip       |       src_mac                                       |
+-----------------+-----------------+-----------------------------------+
|    src_mac      |       src_port  |             des_ip                |
+-----------------------------------------------------------------------+
|                          des_ip                                       |
+-----------------------------------+-----------------------------------+
|    des_ip                         |            des_mac                |
+-----------------------------------+-----------------+-----------------+
|    des_mac                        |      des_port   |     preload     |
+-----------------------------------------------------------------------+
|                              ...                                      |
|                            preload                                    |
|                              ...                                      |
+-----------------------------------------------------------------------+

7*8-2=54字节,所以最大多出了54字节,最少22字节(只有头、MAC地址以及端口)其中有一个字节包含了可能存在的分片预留位。

3.4、如何建立缓存

采用redis nosql数据库作为Mysql数据库的缓存,在查找的时候,首先查找redis缓存,如果找到则返回结果;如果在redis中没有找到,那么查找Mysql数据库,找到的话则返回结果并且更新redis;如果没有找到则返回空。对于写入的情况,直接写入mysql数据库,mysql数据库通过触发器及UDF机制自动把变更的内容更新到redis中。

3.5、cache中间件更新机制

同步方案可以有:
(1)伪装从数据库。比如阿里开源的canal方案、kafka、go-mysql-transfer等。
(2)MySQL的触发器+udf。udf全称User-defined function,是MySQL提供的一种可扩展代码。UDF不具备事务,不能回滚;而且效率较低。

3.6、redis缓存的写策略

以MySQL为主,保证缓存不可用,整个系统依然要保持正常工作;mysql 不可用的话,系统停摆,停止对外提供服务。
(1)从安全优先方面考虑;先删除缓存,再写 mysql,后面数据同步交由 go-mysql-transfer 等中间件处理。先删除缓存,为了避免其他服务读取旧的数据;也是告知系统这个数据已经不是最新,建议从 mysql 获取数据。
(2)从效率优先方面考虑;先写缓存,并设置过期时间(如 200ms),再写mysql,后面数据同步交由其他中间件处理。这里设置的过期时间是预估时间,大致上是 mysql 到缓存同步的时间。在写的过程中如果 mysql 停止服务,或数据没写入 mysql,则200 ms 内提供了脏数据服务;但仅仅只有 200ms 的数据错乱,即效率优先的写策略也有安全性的问题,但只会影响200ms。

3.7、redis缓存热点数据,在什么场景下会产生脏数据

所谓产生脏数据,就是主数据库与缓存数据库的数据不一致,这种情况一般在效率优先的写策略中会产生,但因为设置了过期时间,所以只会影响一定时间。

3.8、在CRUD中如果操作主数据库和缓存数据库

(1)C,创建一条数据:从安全优先考虑,先写入MySQL,然后通过中间件go-mysql-transfer更新缓存数据库redis;从效率优先考虑,先写入redis并设置过期时间,再写入mysql。
(2)R,查询数据:先查询redis,如果有则直接返回,如果没有再访问mysql查询,mysql中也没有就返回空,mysql中有就返回数据,并通过中间键更新redis缓存。
(3)U,更新数据:先删除redis的数据,再写数据库,然后通过中间件go-mysql-transfer更新缓存数据库redis。
(4)D,删除数据:先删除redis的数据,再删除mysql的数据。

3.9、内存泄漏怎么检测?

debug版本,通过VLD库或CRT库分析内存泄漏,但是服务器有很多问题需要在线上并发压力情况下才出现,因此讨论Debug版调试方法意义不大。

对于release版本:
(1)静态方式检测。使用cppcheck、BEAM等工具检测代码文件是否有内存泄漏隐患。
(2)入侵式检测。实现内存泄漏检测组件,嵌入代码中,比如hook住分配内存的函数、mtrace追踪内存分配、对象计数方式;C++还可以重载内存分配和释放函数 new 和 delete。这种方式的缺点是要修改原代码,而且对于第三方库、STL容器、脚本泄漏等因无法修改代码而无法定位。
(3)已经上线的服务器程序,可以使用Valgrind、AddressSanitizer等工具定位到具体的内存泄漏位置。

3.10、socket句柄比较多,怎么分析和解决?

(1)查看当前socket使用状态。

# 方法一
cat /proc/net/sockstat
# 方法二
ss -s

(2)如果是FIN_WAIT和TIME_WAIT的,可以调整fin超时时间或者其他内核参数来解决。
(3)如果是出现大量CLOSING状态,基本上业务上要处理的逻辑过多,导致一直在CLOSING状态;可以使用异步,将网络层和业务层分离,单独处理。

3.11、什么是零拷贝?

零拷贝技术就是绕过用户态,用户缓存区不参与数据拷贝;避免了内核态和用户态的冗余数据拷贝,减少上下文切换。
linux系统提供两个零拷贝接口:mmap和sendfile:

  1. mmap通过DMA将磁盘数据拷贝到内核缓冲区,接着操作系统会把这段内核缓冲区与应用程序共享,这样就不用将内核缓冲区的数据拷贝到用户缓冲区,应用程序调用send或者write时,系统直接将内核缓冲区的内容拷贝到socket缓冲区,然后发送出去。使用mmap至少减少了一次数据拷贝,但是仍然会有用户空间和内核空间的上下文切换。
  2. sendfile的数据传输只发生在内核态,应用程序调用sendfile,系统会将数据拷贝到page cache,然后拷贝到socket buffer,再通过网卡发送出去。这种发送不仅减少了数据拷贝的次数,还减少了上下文切换。如果网卡支持SG-DMA,还可以再去除 Socket 缓冲区的拷贝,这样一共只有 2 次内存拷贝。

此外,还有一个direct io技术,绕过内核缓冲区,在用户空间和磁盘之间传输数据,减少内核缓冲区和用户数据的复制次数。降低了文件读写所带来的CPU负载能力和内存带宽的占用率。

深信服面经---云计算方向(附问题知识点解析)

3.12、协程、线程、进程三者的关系和区别

进程:是一个运行程序,有自己独立的内存空间,是系统资源分配的最小单位。进程比较重量,占据独立的内存,所以上下文进程间的切换开销(栈、寄存器、虚拟内存、文件句柄等)比较大,但相对比较稳定安全。
线程:是一个轻量级的进程,一个进程至少包含一个线程,同一个进程中的线程组共享内存空间,是操作系统调度执行的最小单位。线程间通信主要通过共享内存,上下文切换很快,资源开销较少,但相⽐进程不够稳定容易丢失数据。
协程:一个用户态的轻量级线程,协程的调度完全由应用程序控制。协程拥有自己的寄存器上下文和栈。协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来的时候,恢复先前保存的寄存器上下文和栈,直接操作栈则基本没有内核切换的开销,可以不加锁的访问全局变量,所以上下文的切换非常快。
深信服面经---云计算方向(附问题知识点解析)

3.13、父子进程在资源上有什么区别?

父进程通过fork创建子进程,刚开始时两者都没有对内存作出改动,父子进程共享内存资源。内核fork()时并不复制整个进程地址空间,而是让父子进程共享一个地址空间,只有在需要写入时,数据才会被复制,从而使各个进程拥有各自的拷贝数据。也就是说,只有在需要写入的时候才复制资源,在此之前,以只读方式共享。
深信服面经---云计算方向(附问题知识点解析)

3.14、C++中map数据结构,底层为什么不使用高度平衡二叉树?

最常见的两种自平衡树算法是红黑树和AVL树。为了在插入/更新后平衡树,两种算法都使用旋转的概念,其中树的节点被旋转以实现重新平衡。

AVL的左右子树高度差不能超过1,每次进行插入或删除操作时几乎都需要通过旋转操作保持平衡,在频繁插入或删除的场景中,频繁的旋转操作使得AVL的性能大打折扣。
红黑树的红黑规则只需要保证黑色节点高度一样(黑高),通过牺牲严格的平衡,换取插入、删除时少量的旋转操作,整体性能优于AVL。红黑树插入的不平衡,不超过两次旋转就可以解决;删除时的不平衡,不超过三次旋转就能解决。

虽然在这两种算法中,插入/删除操作都是 O ( l o g 2 n ) O(log_2^n) O(log2n),但在红黑树重新平衡旋转的情况下是 O(1) 操作,而在 AVL 的情况下,这是一个 O ( l o g 2 n ) O(log_2^n) O(log2n)操作,这使得红黑树在重新平衡阶段的这一方面更有效,这也是它更常用的可能原因之一。

3.15、消息队列存在的价值

消息队列的优点:

  1. 解耦:允许独立的扩展或修改队列两边的处理过程。
  2. 可恢复性:即使一个处理消息的进程挂掉,加入队列中的消息仍然可以在系统恢复后被处理。
  3. 缓冲:有助于解决生产消息和消费消息的处理速度不一致的情况。
  4. 灵活性和峰值处理能力:不会因为突发的超负荷的请求而完全崩溃,消息队列能够使关键组件顶住突发的访问压力。
  5. 异步通信:消息队列允许用户把消息放入队列但不立即处理它。

3.16、引入消息队列会带来什么问题?

  1. 消息队列会降低系统的可用性。
  2. 会提高系统复杂度。
  3. 需要考虑一致性问题。

四、面向stack overflow编程

五、算法题

给一个数组root[]={6,3,5,3,6,7,8,-1,-1,5,6},构建二叉树,然后中序遍历输出二叉树。文章来源地址https://www.toymoban.com/news/detail-451046.html


#include <vector>
#include <string>
#include <queue>
#include <iostream>
using namespace std;

//二叉树结点结构
struct TreeNode {
        int val;
        TreeNode* left;
        TreeNode* right;
        TreeNode() :val(0), left(nullptr), right(nullptr) {}
        TreeNode(int x) :val(x), left(nullptr), right(nullptr) {}
        TreeNode(int x, TreeNode* left, TreeNode* right) :val(x), left(left), right(right) {}
};

TreeNode* createBinaryTree(vector<int> nodes) {
        int len = nodes.size();

        if (len == 0) {
                return NULL;
        }

        if (nodes[0] == -1) {
                return nullptr;
        }

        TreeNode* root;
        //建立结点队列并将根节点入队
        queue<TreeNode*> nodesQue;
        root = new TreeNode(nodes[0]);
        nodesQue.push(root);

        //loc遍历数组,每次取两个结点
        for (int loc = 1; loc < len; loc = loc + 2) {
                //获取结点并出队
                TreeNode* node = nodesQue.front();
                nodesQue.pop();

                //获取队头结点的左右结点
                int left = nodes[loc];
                int right = nodes[loc + 1];

                //赋予左右结点
                if (left == -1) {
                        node->left = nullptr;
                }
                else {
                        node->left = new TreeNode(left);
                        nodesQue.push(node->left);
                }

                if (right == -1) {
                        node->right = nullptr;
                }
                else {
                        node->right = new TreeNode(right);
                        nodesQue.push(node->right);
                }
        }
        return root;
}

void dfs(TreeNode* root)
{
        if(root==nullptr)
        {
                cout<<"null"<<endl;
                return;
        }
        cout<<root->val<<endl;
        dfs(root->left);
        dfs(root->right);
}

int main()
{
        vector<int> root={6,3,5,3,6,7,8,-1,-1,5,6};
        TreeNode* cur= createBinaryTree(root);
        dfs(cur);
        return 0;
}

总结

  1. 从 Go 调度器架构层面上介绍了 G-P-M 模型,通过该模型怎样实现少量内核线程支撑大量 Goroutine 的并发运行。以及通过 NetPoller、sysmon 等帮助 Go 程序减少线程阻塞,充分利用已有的计算资源,从而最大限度提高 Go 程序的运行效率。
  2. 消息队列带来的好处:解耦、削峰、异步,提高系统响应速度和稳定性。

参考

  1. 腾讯技术
  2. MySQL缓存策略
  3. Go语言详解
  4. DMA,Direct IO和零拷贝
  5. C++ SLT map和unorder_map底层原理

到了这里,关于深信服面经---云计算方向(附问题知识点解析)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 计算机网络知识点整理

    1. 五层协议 应用层 :通过应用进程间的交互来完成特定网络应用。HTTP、DNS 、SMTP等协议。数据单位为报文。 传输层 :负责向两台主机中进程的通信提供数据传输服务。TCP(面向连接,可靠传输,单位为报文段)、UDP协议(无连接,尽最大努力传输,单位是用户数据报)。

    2023年04月08日
    浏览(85)
  • 计算机二级知识点整理

    翻到了之前准备计算机二级的笔记,现在给大家分享出来。 计算机把完成一条指令所花费的时间称为一个指令周期 结构化程序设计强调的是程序的易读性 boolean类型不能转为其他基本类型数据 表达式是由运算符和运算对象构成的,#不是运算符 a的ASCII码是97,以此类推 理论上

    2024年02月08日
    浏览(42)
  • 计算机基础知识点汇总

    1、指令是指示计算机执行某种操作的命令,包括操作码和地址码两部分。 2、目前常见的指令系统有复杂指令系统(CISC)和精简指令系统(RISC)。 3、计算机的工作过程:取指令、分析指令、执行指令。 4、未配置任何软件的计算机叫裸机,注意不是指安装过操作系统的计算

    2024年02月10日
    浏览(49)
  • 计算机网络期末复习(知识点)

    目录 第一章 概述 1.1计算机网络的概念 1.2计算机网络的组成 1.3计算机网络的功能 1.4计算机网络的性能指标 1.5计算机网络的体系结构 第二章 物理层 1.基本概念 2.常见的数字数据编码 3.传输介质 4.物理层中的设备 第三章 数据链路层 1.数据链路层的功能 2.组帧 3.差错控制 4.流

    2024年02月03日
    浏览(59)
  • 考研复试-计算机网络速记知识点

    更新,本人已经一志愿拟录取,希望这些资料对大家有用! 考研复试面试背诵专用,公司面试也可以用,包含框架与口诀,整理了多个大🐮资料(408和各种GUIDE指北),点赞上岸!持续更新! 写这个的初衷:现在考研复试绝大部分改为线上面试,面试内容多为概念,所以背

    2023年04月12日
    浏览(41)
  • Python计算机二级知识点整理

    1.  一个完整的二叉树包括根节点,左子树和右子树,不同的遍历方式的区别就是访问的顺序的不同,前序遍历是首先访问根节点然后再访问左子树和右子树,中序遍历是访问根节点在访问左子树和右子树之间,后序遍历是先访问左子树和右子树再访问根节点。 2.结构化程序

    2024年02月09日
    浏览(46)
  • 计算机网络期末考试知识点汇总

    1.体系结构 2.各层功能(精简版) 如图 不归零制 :正电平代表1,负电平代表0。 归零制 :正脉冲代表1,负脉冲代表0。 曼彻斯特编码 :位周期中心的向上跳变代表0,位周期中心的向下跳变代表1。 但也可反过来定义。 差分曼彻斯特编码 :在每- -位的中心处始终都有跳变。位开始

    2024年02月08日
    浏览(77)
  • 计算机网络期末总复习知识点

    互联网的2个重要基本特点: 连通性(connectivity)和资源共享(sharing) 。 端系统之间的两种通信方式: 客户/服务器方式(Client/Server方式、C/S方式)、对等方式(Peer to Peer方式、P2P方式) 。 客户/服务器方式:进程之间服务和被服务的关系。客户是服务的请求方,服务器是

    2024年02月06日
    浏览(62)
  • ACP云计算工程师考试知识点

    ECS 安全组 伸缩组 SLB VPC OSS RDS CDN DNS DTS 云安全 云监控 一、ECS实例 ECS组件:在ECS中,是由CPU、内存、磁盘(ECS中没有硬盘概念)、网络配置、操作系统构成 ECS使用限制:①不支持安装虚拟化软件和二次虚拟化;②不支持声卡应用;③不支持直接加载外接硬件设备 ECS状态:分

    2024年02月13日
    浏览(47)
  • MATLAB知识点:median :计算中位数

    ​讲解视频:可以在bilibili搜索《MATLAB教程新手入门篇——数学建模清风主讲》。​ MATLAB教程新手入门篇(数学建模清风主讲,适合零基础同学观看)_哔哩哔哩_bilibili 节选自第3章 3.4.1节 中位数又称中值,我们将数据按从小到大的顺序排列,在排列后的数据中居于中间位置的

    2024年04月11日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包