二叉树四种遍历方式的速度差异

最新推荐文章于 2022-01-08 19:31:34 发布
原创 最新推荐文章于 2022-01-08 19:31:34 发布 · 3.5k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#二叉树 #面试题 #数据结构与算法

本文探讨了在二叉树中求节点数值之和的问题，分析了先序、中序、后序和层次遍历四种方法，并通过递归和非递归方式实现。实测结果显示，在大规模二叉树中，递归遍历通常更快，其中中序遍历的效率相对较高，而后序遍历和层次遍历较慢。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

同学阿里三面面试官的一道面试题是：二叉树每个节点都保存一个整数，想要求所有节点数值之和，哪种遍历方式最快？

首先定义二叉树

struct Tree
{
    int val;
    Tree *left;
    Tree *right;
    Tree(){val = 0;left = NULL;right = NULL;};
};

Tree* constructTree(vector<int> &vect, int i)
{
    if(i >= vect.size())
        return NULL;
    Tree *root = new Tree();
    root->val = vect[i];
    root->left = constructTree(vect, 2*i+1);
    root->right = constructTree(vect, 2*i+2);
}

void releaseTree(Tree *root)
{
    if(root == NULL)
        return;
    release(root->left);
    release(root->right);
    delete root;
}

二叉树有四种遍历方式，先序遍历、中序遍历、后序遍历、层次遍历。分别利用这些遍历方式进行二叉树所有元素求和：

一、 递归方式

层次遍历只能通过非递归的方式实现，下面只给出先序遍历、中序遍历、后续遍历的三种递归实现方式。

//递归的先序遍历求和
void frontTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
        return;
    sum += root->val;
    frontTraverseSum(root->left, sum);
    frontTraverseSum(root->right, sum);
}

//递归的中序遍历求和
void middleTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
        return;
    middleTraverseSum(root->left, sum);
    sum += root->val;
    middleTraverseSum(root->right, sum);
}

//递归的后续遍历求和
void backTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
        return;
    backTraverseSum(root->left, sum);
    backTraverseSum(root->right, sum);
    sum += root->val;
}

二、 非递归方式

//非递归的先序遍历求和,并使用count统计入栈次数
void preTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *p = root;
    int count = 0;
    while(p != NULL || !st.empty())    //当出栈到root的时候会出现栈为空的中间状态，所以p不为空的条件不能省略
    {
        while(p != NULL)
        {
            sum += p->val;
            st.push(p);
            count++;
            p = p->left;
        }
        if(!st.empty())
        {
            p = st.top();
            st.pop();
            p = p->right;
        }
    }
    cout << "pre st.push count: " << count << endl;
}

//非递归的中序遍历求和
void inTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *p = root;
    int count = 0;
    while(p != NULL || !st.empty())
    {
        while(p != NULL)
        {
            st.push(p);
            count++;
            p = p->left;
        }
        if(!st.empty())
        {
            p = st.top();
            st.pop();
            sum += p->val;
            p = p->right;
        }
    }
    cout << "in st.push count: " << count << endl;
}

//非递归的后序遍历求和, 这个比先序遍历和中序遍历复杂，需要判断出栈条件：左右孩子均为空或者左右孩子被访问过
void postTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *cur = root;
    Tree *pre = NULL;
    st.push(root);
    int count = 1;
    while(!st.empty())
    {
        cur = st.top();
        if((cur->left == NULL && cur->right == NULL) || (pre != NULL && (pre == cur->left || pre == cur->right)))
        {
            sum += cur->val;
            st.pop();
            pre = cur;
        } else {
            if(cur->right)
            {
                st.push(cur->right);
                count++;
            }
            if(cur->left)
            {
                st.push(cur->left);
                count++;
            }
        }
    }   
    cout << "post st.push count: " << count << endl;
}

//只能非递归的层次遍历
void levelTraverseSum(Tree*root, int &sum)
{
    queue<Tree*> qu;
    Tree *p = root;
    qu.push(root);
    while(!qu.empty())
    {
        p = qu.front();
        sum += p->val;
        qu.pop();
        if(p->left)
            qu.push(p->left);
        if(p->right)
            qu.push(p->right);
    }
}

三、 测试每种遍历方式的时间

全都采用相同的模板：

void test(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    traverseSum(root, sum);
    clock_t end = clock();
    cout << "time: " << end - beg << endl;
    cout << "sum: " << sum << endl;
}

int main()
{
    vector<int> vect;
    for(int i = 0; i < 7000000; i++)
    {
        vect.push(i);
    }
    Tree *root;
    root = construct(vect, 0);
    test();
    releaseTree(root);
    return 0;
}

四、 运行结论

在规模小的二叉树上没有太大差异，对于大的二叉树，递归遍历都快于非递归遍历，但是每次运行的结果都有差异，一般来讲中序遍历是执行比较快的，后序遍历和层次遍历最慢：

一次运行结果：

7000000
front time: 50000
front sum: 1503043616
middle time: 40000
middle sum: 1503043616
back time: 40000
back sum: 1503043616
level time: 510000
level sum: 1503043616
pre st.push count: 7000000
pre time: 470000
pre sum: 1503043616
in st.push count: 7000000
in time: 460000
in sum: 1503043616
post st.push count: 7000000
post time: 530000
post sum: 1503043616

重复运行一次结果：

7000000
front time: 50000
front sum: 1503043616
middle time: 40000
middle sum: 1503043616
back time: 50000
back sum: 1503043616
level time: 500000
level sum: 1503043616
pre st.push count: 7000000
pre time: 480000
pre sum: 1503043616
in st.push count: 7000000
in time: 450000
in sum: 1503043616
post st.push count: 7000000
post time: 540000
post sum: 1503043616

五、 完整代码

#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <ctime>
using namespace std;

struct Tree
{
    int val;
    Tree *left;
    Tree *right;
    Tree(){val = 0; left = NULL; right = NULL;};
};

void frontTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
    return;
    sum += root->val;
    frontTraverseSum(root->left, sum);
    frontTraverseSum(root->right, sum);
}

void middleTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
    return;
    middleTraverseSum(root->left, sum);
    sum += root->val;
    middleTraverseSum(root->right, sum);
}

void backTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
    return;
    backTraverseSum(root->left, sum);
    backTraverseSum(root->right, sum);
    sum += root->val;
}

void test1(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    frontTraverseSum(root, sum);
    clock_t end = clock();
    cout << "front time: " << end - beg << endl;
    cout << "front sum: " << sum << endl;
}

void test2(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    middleTraverseSum(root, sum);
    clock_t end = clock();
    cout << "middle time: " << end - beg << endl;
    cout << "middle sum: " << sum << endl;
}

void test3(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    backTraverseSum(root, sum);
    clock_t end = clock();
    cout << "back time: " << end - beg << endl;
    cout << "back sum: " << sum << endl;
}

Tree* constructTree(vector<int> &vect, int k)
{
    if(k >= vect.size())
        return NULL;
    Tree *root = new Tree();
    root->val = vect[k];
    //cout << root->val << " ";
    root->left = constructTree(vect, 2*k+1);
    root->right = constructTree(vect, 2*k+2);
    return root;
}

void levelTraverseSum(Tree *root, int &sum)
{
    queue<Tree*> qu;
    qu.push(root);
    while(!qu.empty())
    {
    Tree *father = qu.front();
    qu.pop();
    sum += father->val;
    if(father->left)
        qu.push(father->left);
    if(father->right)
        qu.push(father->right);
    }
}

void test4(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    levelTraverseSum(root, sum);
    clock_t end = clock();
    cout << "level time: " << end - beg << endl;
    cout << "level sum: " << sum << endl;
}

void levelTraverse(Tree *root)
{
    queue<Tree*> qu;
    qu.push(root);
    while(!qu.empty())
    {
    Tree *father = qu.front();
    qu.pop();
    cout << father->val << " ";
    if(father->left)
        qu.push(father->left);
    if(father->right)
        qu.push(father->right);
    }
    cout << endl;
}

void releaseTree(Tree *root)
{
    if(root == NULL)
    return;
    releaseTree(root->left);
    releaseTree(root->right);
    delete root;
}

void preTraverse(Tree *root)
{
    stack<Tree*> st;
    Tree *p = root;
    while(p != NULL || !st.empty())
    {
    while(p != NULL)
    {
        cout << p->val << " ";
        st.push(p);
        p = p->left;
    }
    if(!st.empty())
    {
        p = st.top();
        st.pop();
        p = p->right;
    }
    }
    cout << endl;
}

void preTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *p = root;
    int count = 0;
    while(p != NULL || !st.empty())
    {
    while(p != NULL)
    {
        sum += p->val;
        st.push(p);
        count++;
        p = p->left;
    }
    if(!st.empty())
    {
        p = st.top();
        st.pop();
        p = p->right;
    }
    }
    cout << "pre st.push count: " << count << endl;
}

void test5(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    preTraverseSum(root, sum);
    clock_t end = clock();
    cout << "pre time: " << end - beg << endl;
    cout << "pre sum: " << sum << endl;
}

void inTraverse(Tree *root)
{
    stack<Tree*> st;
    Tree *p = root;
    while(p != NULL || !st.empty())
    {
    while(p != NULL)
    {
        st.push(p);
        p = p->left;
    }
    if(!st.empty())
    {
        p = st.top();
        cout << p->val << " ";
        st.pop();
        p = p->right;
    }
    }
    cout << endl;
}

void inTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *p = root;
    int count = 0;
    while(p != NULL || !st.empty())
    {
    while(p != NULL)
    {
        st.push(p);
        count++;
        p = p->left;
    }
    if(!st.empty())
    {
        p = st.top();
        sum += p->val;
        st.pop();
        p = p->right;
    }
    }
    cout << "in st.push count: " << count << endl;
}

void test6(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    inTraverseSum(root, sum);
    clock_t end = clock();
    cout << "in time: " << end - beg << endl;
    cout << "in sum: " << sum << endl;
}

void postTraverse(Tree *root)
{
    stack<Tree*> st;
    Tree *cur = root;
    Tree *p = NULL;
    st.push(root);
    while(!st.empty())
    {
    cur = st.top();
    if((cur->left == NULL && cur->right == NULL) || (p != NULL &&(p == cur->left || p == cur->right)))
    {
        cout << cur->val << " ";
        st.pop();
        p = cur;
    } else {
        if(cur->right)
        st.push(cur->right);
        if(cur->left)
        st.push(cur->left);
    }
    } 
    cout << endl;
}

void postTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *cur = root;
    Tree *p = NULL;
    st.push(root);
    int count = 1;
    while(!st.empty())
    {
    cur = st.top();
    if((cur->left == NULL && cur->right == NULL) || (p != NULL && (p == cur->left || p == cur->right)))
    {
        sum += cur->val;
        st.pop();
        p = cur;
    } else {
        if(cur->right)
        {
        st.push(cur->right);
        count++;
        }
        if(cur->left)
        {
        st.push(cur->left);
        count++;
        }
    }
    }
    cout << "post st.push count: " << count << endl;
}

void test7(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    postTraverseSum(root, sum);
    clock_t end = clock();
    cout << "post time: " << end - beg << endl;
    cout << "post sum: " << sum << endl;
}

int main()
{
    vector<int> vect;
    for(int i = 0; i < 7000000; i++)
    {
    vect.push_back(i);
    }
    cout << vect.size() << endl;
    Tree *root;
    root = constructTree(vect, 0);
/*    cout << "levelTraverse: ";
    levelTraverse(root);
    cout << "preTraverse: ";
    preTraverse(root);
    cout << "inTraverse: ";
    inTraverse(root);
    cout << "postTraverse: ";
    postTraverse(root); */
    test1(root);
    test2(root);
    test3(root);
    test4(root);
    test5(root);
    test6(root);
    test7(root);
    releaseTree(root);
    return 0;
}
12、线程二叉树：提升遍历效率的特殊二叉树表示法
u5v6w7的博客
05-17 11
本文深入介绍了线程二叉树的基本概念、结构特点以及其在遍历效率上的显著优势。内容涵盖了线程二叉树的创建、遍历方式（中序、前序、后序）、插入和删除操作、应用场景以及性能优化方法。同时，文章还通过实际案例展示了线程二叉树在高效遍历、内存优化和简化代码方面的强大功能，并探讨了其未来发展方向，包括多线程环境优化、分布式系统应用及与其他新型数据结构的结合潜力。
数据结构复习——二叉树类型及遍历方式
qq_32352367的博客
06-05 725
一、常见的二叉树 1. 完全二叉树   若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。 2. 满二叉树   除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树 3. 平衡二叉树   任意节点的子树的高度差都小于等于1 4. 二叉搜索树   它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所
遍历二叉树的超强算法（Morris遍历）
weixin_44726516的博客
12-22 258
题目 给定一棵二叉树的头节点head，完成二叉树的先序、中序、后序遍历。如果二叉树的节点为N，则要求时间复杂度为O（N），额外空间复杂度为O（1）。 Morris遍历的的介绍 Morris遍历的二叉树遍历算法的超强进阶算法，该算法可以将非递归遍历中的空间复杂度降为O（1）。从而能够实现时间复杂度为O（N），空间复杂度为O（1）的精妙算法。普通的递归于非递归的解法，其中都使用了栈的结构，递归方法使用了函数栈，非递归的方法则是自己手动维护了一个栈。两者的额外空间都与树的高度相关，空间复杂度为O(h),h为二叉树
二叉树遍历算法效率分析
麦兜的猪栏
02-13 1719
l 在先序遍历中，每个结点只经过一次，中序遍历中，有左、右孩子的结点要经过两次（先去中序遍历它的左子树，从左子树返回时才访问它），而后序中，有左、右孩子的结点要经过三次。 l 三种遍历算法的时间复杂度都是O(n)。 l 所需辅助空间为栈空间，栈的容量为树的高度，最多不超过n，所以空间复杂度也为O(n)。...
速度学会二叉树的遍历
Aroma
04-02 248
数据结构—二叉树的遍历 先序遍历（DLR）：先遍历根节点，再遍历左子树，最后遍历右子树—>点击查看 中序遍历（LDR）：先遍历左子树，再遍历根节点，最后遍历右子树—>点击查看 后序遍历（LRD）：先遍历左子树，再遍历右子树，最后遍历根节点—>点击查看 据下图进行解答 先序遍历（DLR） a 、一定先访问根节点A，之后是左子树B、右子树C b 、再DLR遍历根节点、...
二叉树的三种遍历方式：递归、栈、循环 分类： C/C++ ...
weixin_30445169的博客
06-21 174
三种方法中，递归最为简单，栈次之，循环最为麻烦。递归的深度如果太大则会导致栈溢出；栈的方式需要额外的辅助空间；循环编程最麻烦。 首先是递归： //递归方法 void midPrint_r(TreeNode* root) {//中序遍历 if(root==NULL) return; if(root->left) midPrin...
面试高频必问-二叉树
qq_25913607的博客
05-13 458
二叉树 1、为什么需要树这种数据结构 数组存储方式的分析 优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。 缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 操作示意图： 链式存储方式的分析 优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，删除效率也很好)。 缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历) 操作示意图： 树存储方式的分析 能提高数据存储，读取的效率,比
一文弄懂二叉树的三种遍历方式
qq3164069700的博客
01-08 501
俗话说：学如逆水行舟,不进则退;心似平原走马,易放难收。这句话对程序员而言，体会更深。这行已经越来越卷了，时刻准备着，。 二叉树，在面试中，已是必备的开胃菜。而在二叉树相关的面试题目中，遍历更是常考题目。本文将从二叉树的遍历角度入手，从递归和非递归角度来分析和讲解二叉树的遍历。 遍历 ❝ 二叉树的遍历是指从根节点出发，按照某种次序依次访问二叉树中的所有节点，使每个节点被且仅被访问一次。 ❞ 二叉树的遍历，有「先序遍历」、「中序遍历」以及「后续遍历」三种。 图一 上面三种遍历方式中的
二叉树的三种遍历方式及其分析
harrycomeon的博客
03-21 939
二叉树的三种遍历方式及其分析 1，查找的两种方式 2，静态查找的方式： A 顺序查找-建立哨兵 遇到哨兵时循环退出 时间复杂度为O(n)。运气好第一个是，运气不好最后一个是，平均时间复杂度是O(N/2)。 B 二分查找（Binary Search） 前提：数组中有序存放 对于大数量的查找来说，二分查找的效率会高很多，比如有100万根电线杆，需要找出其中故障的电线杆，那么利用顺序查找平均需要50万次，而利用二分查找平均只需要 log⁡21000000 \log_2 1000000 log2
二叉树（二）、二叉树的迭代遍历
qq_42138662的博客
06-18 756
递归的本质是将调用函数压入栈中，既然递归可以实现二叉树的遍历，那么迭代也可以实现二叉树的遍历。 一、使用迭代实现二叉树遍历的难点 我们在访问二叉树的时候，一定是先访问根节点，然后访问两个孩子节点；并且只能通过根访问孩子；不能通过孩子访问根。 而三种不同的方法遍历二叉树的差异实际上是什么时候对根结点进行处理（将根节点压入结果中） 在二叉树中，每一个节点都可以视作其他节点的根节点，最后一行可以视作两个孩子均为空 在递归方法中，我们通过控制递归调用和对节点处理的顺序，可以控制根结点处理的时机。但在循环遍历中，我
二叉树的遍历
qq_42451178的博客
07-12 124
思路： 遍历二叉树使用递归的方式是比较简单、清晰的，但是这种方法会导致性能的下降，这是因为每次在调用函数时需要为当前函数保存现场，为新调用的函数申请空间，同时如果我们忘记设置递归结束条件还会引起内存栈的溢出。 这里讲述的方法是使用迭代的方法实现递归的工作流程。 首先递归的本质实际上是压栈，即在又一次调用自身之前，向栈中压入当前函数的状态。 我们可以建立辅助栈模拟压栈，对于二叉树的遍历顺序而言，我们要考虑结点入栈的顺序，因为栈先进后出的工作特点，所以向栈中压入结点的顺序直接影响到了我们的访问顺序。 而且注意
快速掌握二叉树的7种遍历方式哦！！！
SSimeng的博客
06-29 638
二叉树的7总遍历1. 树节点结构的定义2. 树的创建3. 树的深度优先遍历3.1 树的前序遍历【根左右】（递归和非递归）3.2 树的中序遍历【左根右】（递归和非递归）3.3 树的后序遍历【左右根】（递归和非递归）4. 树的广度优先遍历（层序遍历） 1. 树节点结构的定义 树是由一个个节点组成的结构，有个特殊的结点是根节点，而每个结点由自己的左孩子结点和右孩子结点组成。 树的结构图： 接下来是对树中节点的定义： /** * 树节点结构的定义 * @author Simeng * */ publi
遍历二叉树
杨森源的博客
05-31 4018
1.  二叉树的遍历         遍历定义  ——顺着某一条搜索路径巡访二叉树中的结点，使得 每个结点均被访问一次，而且仅被访问一次。         “访问”的含义可以很广，如：输出结点的信息等。          遍历用途——查找具有某种特征的结点；对树中全部结点逐一进行某种处理。遍历是二叉树一切运算的基础和核心。 遍历规则 二叉树由根、左子树、右子树构成，定义为D、 L
树的前序遍历、中序遍历、后序遍历怎样写更快？
Sai_BAN的博客
05-12 320
比如这个数，就非常典型 前序直接一列一列斜下来。 中序一列一列斜上去 后序两个一行的写。
二叉树的遍历方式及优化
@另维
03-31 588
1、二叉树的前序遍历 分析 1、空树---->直接返回’ 2、非空：将根结点入栈循环进行以下操作： A.取栈顶元素—> cur peek() B.遍历该元素 (因为取得栈顶元素始终是左子树，所i。。) C.删除栈顶元素 D.如果cur的右子树存在，将右子树入栈 E.如果cur的左子树存在，将左子树入栈 方式一： 借助栈： public class TreeNode { in...
递归法和非递归法遍历二叉树、层次遍历
wmy0217_的博客
02-04 1835
递归法遍历二叉树 遍历二叉树是指按某条搜索路径巡访树中的每个结点，使得每个结点均被访问一次，而且仅被访问一次 访问的含义很广，可以是对结点做各种处理，包括输出结点的信息，对结点进行运算和修改等 先序遍历 先序遍历二叉树的操作定义如下： 若二叉树为空，则空操作；否则 1、访问根结点 2、先序遍历左子树 3、先序遍历右子树 【算法描述】 Status PreOrderTraverse(BiTr...
二叉树及其遍历
tianshangyuqin的博客
05-21 371
1.概念： 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看 起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合 Ti (1 <= i <= m) 又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继 树是递归定义的。 一棵二叉树是结点的一
二叉树几种遍历方式
K-Darker的专栏
05-03 667
一、基本概念 每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。 性质： 1、非空二叉树的第n层上至多有2^(n-1)个元素。 2、深度为h的二叉树至多有2^h-1个结点。 满二叉树：所有终端都在同一层次，且非终端结点的度数为2。 在满二叉树中若其深度为h，则其所包含的结点数必为2^h-1。 完全二叉树：除了最大的层次即成为一颗满
二叉树遍历递归与非递归实现
weixin_44748812的博客
11-25 189
递归实现： /*样例：3 4 6 0 0 7 8 0 0 0 0 前序：3 4 6 7 8 中序：6 4 8 7 3 后序：6 8 7 4 3*/ #include <iostream> using namespace std; typedef class TreeNode BinTree; class TreeNode { public: TreeNode(); ...
二叉树的深度遍历和广度优先遍历
最新发布
01-19
对于一棵给定的二叉树，这种遍历方式会先访问根节点，然后依次遍历左子树和右子树[^1]。 在具体实现上，可以采用递归的方式完成这一过程： ```cpp void DFS(TreeNode* root) { if (!root) return; cout ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值