二叉树的遍历--递归+非递归(两种)

最新推荐文章于 2024-11-05 03:09:53 发布
最新推荐文章于 2024-11-05 03:09:53 发布
阅读量85 收藏
点赞数
文章标签： c/c++ 数据结构与算法

      二叉树的非递归遍历

         二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中，前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一点。

一.前序遍历

   前序遍历按照“根结点-左孩子-右孩子”的顺序进行访问。

   1.递归实现

void preOrder1(BinTree *root)     //递归前序遍历 
{
    if(root!=NULL)
    {
        cout<<root->data<<" ";
        preOrder1(root->lchild);
        preOrder1(root->rchild);
    }
}

   2.非递归实现

    根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下：

     对于任一结点P：

     1)访问结点P，并将结点P入栈;

     2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;

     3)直到P为NULL并且栈为空，则遍历结束。

void preOrder2(BinTree *root)     //非递归前序遍历 
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            cout<<p->data<<" ";
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->rchild;
        }
    }
}

- 另一种实现

class Solution {
public:
vector<int> preorderTraversal(TreeNode *root) {
    if (root==NULL) {
        return vector<int>();
    }
    vector<int> result;
    stack<TreeNode *> treeStack;
    treeStack.push(root);
    while (!treeStack.empty()) {
        TreeNode *temp = treeStack.top();
        result.push_back(temp->val);
        treeStack.pop();
        if (temp->right!=NULL) {  //或者先压右孩子，再压左孩子
            treeStack.push(temp->right);
        }
        if (temp->left!=NULL) {
            treeStack.push(temp->left);
        }
    }
    return result;
}
};

二.中序遍历

    中序遍历按照“左孩子-根结点-右孩子”的顺序进行访问。

    1.递归实现

void inOrder1(BinTree *root)      //递归中序遍历
{
    if(root!=NULL)
    {
        inOrder1(root->lchild);
        cout<<root->data<<" ";
        inOrder1(root->rchild);
    }
}

   2.非递归实现

    根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：

   对于任一结点P，

  1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；

  2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；

  3)直到P为NULL并且栈为空则遍历结束

void inOrder2(BinTree *root)      //非递归中序遍历
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            cout<<p->data<<" ";
            s.pop();
            p=p->rchild;
        }
    }    
}

三.后序遍历

      后序遍历按照“左孩子-右孩子-根结点”的顺序进行访问。

      1.递归实现

void postOrder1(BinTree *root)    //递归后序遍历
{
    if(root!=NULL)
    {
        postOrder1(root->lchild);
        postOrder1(root->rchild);
        cout<<root->data<<" ";
    }    
}

      2.非递归实现

       后序遍历的非递归实现是三种遍历方式中最难的一种。因为在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子前访问才能访问根结点，这就为流程的控制带来了难题。下面介绍两种思路。

      第一种思路：对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问，因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是否是第一次出现在栈顶。

void postOrder2(BinTree *root)    //非递归后序遍历
{
    stack<BTNode*> s;
    BinTree *p=root;
    BTNode *temp;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)              //沿左子树一直往下搜索，直至出现没有左子树的结点 
        {
            BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
            btn->btnode=p;
            btn->isFirst=true;
            s.push(btn);
            p=p->lchild;
        }
        if(!s.empty())
        {
            temp=s.top();
            s.pop();
            if(temp->isFirst==true)     //表示是第一次出现在栈顶 
             {
                temp->isFirst=false;
                s.push(temp);
                p=temp->btnode->rchild;    
            }
            else                        //第二次出现在栈顶 
             {
                cout<<temp->btnode->data<<" ";
                p=NULL;
            }
        }
    }    
}

//postorder traversal
//* 核心思想是用栈做辅助空间，先从根往左一直入栈，直到为空，然后判断栈顶元素的右孩子，如果不为空且未被访问过，
//* 则从它开始重复左孩子入栈的过程；否则说明此时栈顶为要访问的节点（因为左右孩子都是要么为空要么已访问过了），
//* 出栈然后访问即可，接下来再判断栈顶元素的右孩子...直到栈空。

vector<int> postorderTraversal(TreeNode* root) {
    vector<int> nodes;
    stack<TreeNode*> toVisit;
    TreeNode* curNode = root;
    TreeNode* lastNode = NULL;
    while (curNode || !toVisit.empty()) {
        if (curNode) { //一直压左孩子
            toVisit.push(curNode);
            curNode = curNode -> left;
        }
        else {
            TreeNode* topNode = toVisit.top();
            if (topNode -> right && lastNode != topNode -> right) //右孩子非空且未被访问过
                curNode = topNode -> right;
            else {
                nodes.push_back(topNode -> val);
                lastNode = topNode;
                toVisit.pop();
            }
        }
    }
    return nodes;
}

第二种思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

void postOrder3(BinTree *root)     //非递归后序遍历
{
    stack<BinTree*> s;
    BinTree *cur;                      //当前结点 
    BinTree *pre=NULL;                 //前一次访问的结点 
    s.push(root);
    while(!s.empty())
    {
        cur=s.top();
        if((cur->lchild==NULL&&cur->rchild==NULL)||
           (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
        {
            cout<<cur->data<<" ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过 
              s.pop();
            pre=cur; 
        }
        else
        {
            if(cur->rchild!=NULL)
                s.push(cur->rchild);
            if(cur->lchild!=NULL)    
                s.push(cur->lchild);
        }
    }    
}

 四.整个程序完整的代码

/*!
* \file 二叉树的遍历.cpp
*
* \author ranjiewen
* \date 2017/03/26 18:38
*
*
*/

#include <stdio.h>
#include <stdlib.h>

typedef struct TNode *position;
typedef position BinTree;
typedef int ElementType;

typedef struct TNode
{
    ElementType Data;
    BinTree Left;
    BinTree Right;
}BinTreeNode;

typedef struct Node 
{
    BinTree bin;
    bool isfirst;
}BTNode;
//先序、中序和后序遍历过程：遍历过程中经过结点的路线一样，只是访问各结点的时机不同;同一节点有三次遇到的机会，三种遍历对应三个时机访问节点

#include <iostream>
#include <stack>
using namespace std;

//先序遍历
void PreOrderTraversal(BinTree BT)
{
    if (BT)
    {
        printf("%5d", BT->Data);
        PreOrderTraversal(BT->Left);
        PreOrderTraversal(BT->Right);
    }
    return;
}

//先序非递归实现
void PreOrderTraversal_(BinTree BT)
{
    BinTree T = BT;
    stack<BinTree> s; //创建并初始化堆栈
    while (T || !s.empty()) //树不为空或者栈不为空，继续循环
    {
        while (T) //一直向左并将沿途节点压入堆栈中
        {
            s.push(T);
            printf("%5d", T->Data);//第一次遇见节点的时候访问
            T = T->Left;
        }
        if (!s.empty())
        {
            T = s.top(); //先记录，在出栈
            //printf("%d", T->Data);
            s.pop();
            T = T->Right; //转向右子树
        }
    }
    return;
}

//中序遍历
void InOrderTraversal(BinTree BT)
{
    if (BT)
    {
        InOrderTraversal(BT->Left);
        printf("%5d", BT->Data);
        InOrderTraversal(BT->Right);
    }
    return;
}

//中序非递归实现
void InOrderTraversal_(BinTree BT)
{
    BinTree T = BT;
    stack<BinTree> s; //创建并初始化堆栈
    while (T || !s.empty()) //树不为空或者栈不为空，继续循环
    {
        while (T) //一直向左并将沿途节点压入堆栈中
        {
            s.push(T);
            T = T->Left;
        }
        if (!s.empty())
        {
            T = s.top(); //先记录，在出栈
            printf("%5d", T->Data);  //第二次遇见节点的时候访问 //第三次呢？？？
            s.pop();
            T = T->Right; //转向右子树
        }
    }
    return;
}


//后序遍历
void PostOrderTraversal(BinTree BT)
{
    if (BT)
    {
        PostOrderTraversal(BT->Left);
        PostOrderTraversal(BT->Right);
        printf("%5d", BT->Data);
    }
    return;
}

//后序遍历的非递归实现
//每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它

void PostOrderTraversal_1(BinTree BT)
{
    stack<BTNode*> S;
    BinTree p = BT;
    BTNode *temp;
    while (p!=NULL||!S.empty())
    {
        while (p!=NULL) //沿左子树一直往下搜索，直至出现没有左子树的节点
        {
            BTNode* btn = (BTNode*)malloc(sizeof(BTNode)); //把每经过的节点都标记一遍 //感觉有点浪费空间
            btn->bin = p;
            btn->isfirst = true;
            S.push(btn);       
            p = p->Left;
        }
        if (!S.empty())
        {
            temp = S.top();
            S.pop();
            if (temp->isfirst == true) //第一次在栈顶位置
            {
                temp->isfirst = false;
                S.push(temp);
                p = temp->bin->Right; //不出栈，对其右子树进行相同的操作
            }
            else
            {
                printf("%5d", temp->bin->Data);  //第二次出现在栈顶；出栈
                p = NULL;
            }
        }
    }
}

//要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，
//则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。
//若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，
//左孩子和右孩子都在根结点前面被访问。

void PostOrderTraversal_2(BinTree BT)
{
    stack<BinTree> S;
    BinTree cur;
    BinTree pre = NULL; 
    S.push(BT);
    while (!S.empty())
    {
        cur = S.top();
        if ((cur->Left == NULL&&cur->Right == NULL) || (pre != NULL && (pre == cur->Left||pre==cur->Right)))
        {
            printf("%5d", cur->Data); //如果当前结点没有孩子结点或者孩子节点都已被访问过 
            S.pop();
            pre = cur;
        }
        else
        {
            if (cur->Right != NULL) //将P的右孩子和左孩子依次入栈
            {
                S.push(cur->Right);
            }
            if (cur->Left!=NULL)
            {
                S.push(cur->Left);
            }
        }
    }
}

#include <queue>
//层次遍历

//二叉树遍历的核心问题： 二维结构的线性化
// 从结点访问其左、右儿子结点
// 访问左儿子后，右儿子结点怎么办？
// 需要一个存储结构保存暂时不访问的结点
// 存储结构：堆栈、队列  (用堆实现就是存储其父节点)

//队列实现： 遍历从根结点开始，首先将根结点入队，然后开始执行循环：结点出队、访问该结点、其左右儿子入队

//层序基本过程：先根结点入队，然后
//     从队列中取出一个元素；
//       访问该元素所指结点；
//       若该元素所指结点的左、右孩子结点非空，则将其左、右孩子的指针顺序入队。

void LevelOrderTraversal(BinTree BT)  //层次输出叶子节点可借助此思路
{
    queue<BinTree> Q;
    BinTree T;
    if (!BT)
    {
        return;
    }
    Q.push(BT);
    while (!Q.empty())
    {
        T = Q.front();
        Q.pop();
        printf("%5d", T->Data);
        if (T->Left)
        {
            Q.push(T->Left);
        }
        if (T->Right)
        {
            Q.push(T->Right);
        }
    }
}

//遍历二叉树的应用
//输出二叉树中的叶子节点,前中后序遍历改编都可以
void PreOrderPrintLeaves(BinTree BT)
{
    if (BT)
    {
        if (!BT->Left&&!BT->Right)
        {
            printf("%5d", BT->Data);
        }
        PreOrderPrintLeaves(BT->Left);
        PreOrderPrintLeaves(BT->Right);
    }
}

//二叉树的高度，要知道左右子树高度才行，所以有后序遍历方法
int PostOrderGetHeight(BinTree BT)
{
    int LH, RH, MaxH;
    if (BT)
    {
        LH = PostOrderGetHeight(BT->Left);
        RH = PostOrderGetHeight(BT->Right);
        MaxH = (LH > RH) ? LH + 1 : RH + 1;
        return MaxH;
    }
    else
    {
        return 0;
    }
}

//二元运算表达式树及其遍历
//中缀表达式会受到运算优先级的影响；要正确得到：需要遍历操作符前后加上括号

//有中序遍历的两种遍历序列才能确定一个二叉树

//先序和中序遍历序列来确定一棵二叉树
//〖 分析〗
// 根据先序遍历序列第一个结点确定根结点；
// 根据根结点在中序遍历序列中分割出左右两个子序列
// 对左子树和右子树分别递归使用相同的方法继续分解

void CreateBinTree(char* s, BinTree& root)
{
    int i;
    bool isRight = false;
    stack<BinTree> s1; //存放节点
    stack<char> s2;  //存放分隔符
    BinTree p, temp;
    root->Data = s[0];
    root->Left = NULL;
    root->Right = NULL;
    s1.push(root);
    i = 1;
    while (i<strlen(s))
    {
        if (s[i]=='(')
        {
            s2.push(s[i]);
            isRight = false;
        }
        else if (s[i]==',')
        {
            isRight = true;
        }else if (s[i]==')')
        {
            s1.pop();
            s2.pop();
        }
        else if (isalpha(s[i]))
        {
            p = (BinTree)malloc(sizeof(struct TNode));
            p->Data = s[i];
            p->Left = p->Right = NULL;
            temp = s1.top();
            if (isRight==true)
            {
                temp->Right = p;
                printf("%c的右孩子是%c\n", temp->Data, s[i]);
            }
            else
            {
                temp->Left = p;
                printf("%c的左孩子是%c\n", temp->Data, s[i]);
            }
            if (s[i+1]=='(')
            {
                s1.push(p);
            }
        }
        i++;
    }
}

void display(BinTree root)        //显示树形结构 
{
    if (root != NULL)
    {
        cout << root->Data;
        if (root->Left != NULL)
        {
            cout << '(';
            display(root->Left);
        }
        if (root->Right != NULL)
        {
            cout << ',';
            display(root->Right);
            cout << ')';
        }
    }
}


int main()
{
    char s[100];
    while (scanf("%s",s)==1)
    {
        BinTree root = (BinTree)malloc(sizeof(BinTreeNode));
        CreateBinTree(s,root);
        display(root);

        cout << endl;
        PreOrderTraversal(root);
        cout << endl;
        PreOrderTraversal_(root);
        cout << endl;
        InOrderTraversal(root);
        cout << endl;
        InOrderTraversal_(root);
        cout << endl;
        PostOrderTraversal(root);
        cout << endl;
        PostOrderTraversal_1(root);
        cout << endl;
        PostOrderTraversal_2(root);
        cout << endl;
        LevelOrderTraversal(root);
        cout << endl;
    }
    return 0;
}

测试结果：

另外感觉C/C++分类也总结了很多东西：http://www.cnblogs.com/dolphin0520/category/291771.html

 

 
weixin_33674976
关注
C++-二叉树递归遍历与非递归遍历实现
席木木的博客
10-24 3700
-二叉树递归遍历与非递归遍历实现引言0 有关线性表结点定义-LinkNode1 栈的链式存储结构实现-LinkedStack2 队列的链式存储结构实现-LinkedQueue3 二叉树的链式存储结构实现3.1 树的结点定义-TreeNode3.2 二叉树定义3.3 前中后序遍历-递归算法实现3.4 前中后序遍历-非递归算法实现3.5 层序遍历算法实现4 代码测试5 测试结果 引言     二叉树的遍历方法有：前序遍历、中序遍历、后序遍历、层序遍历，其中前中后序遍历又有
数据结构二叉树的递归遍历算法与非递归遍历算法
m0_65818274的博客
12-20 531
c/c++ 数据结构 二叉树 二叉树的递归遍历算法与非递归遍历
数据结构—树与二叉树(Part Ⅳ)—二叉树的遍历(递归&非递归)
Miss Z的博客
08-28 1037
数据结构-树与二叉树(第七章)的整理笔记，若有错误，欢迎指正。 树、森林
C++ 二叉树非递归遍历(别贪心，一次循环访问一个节点，前序遍历2例外)
风从北边来的博客
10-28 491
前序遍历方法1： void preOrder1(BiNode * rootN) { if (rootN != nullptr) { stack&lt;BiNode*&gt; nodeSta; nodeSta.push(rootN); BiNode* curNode; while(!nodeSta.empty()) { curNode = nodeSta.top()...
二叉树遍历-递归与非递归遍历
雪的期许
08-14 1236
二叉树的遍历原则 先序遍历：①访问当前结点，②遍历左子树，③遍历右子树 中序遍历：①遍历左子树，②访问当前结点，③遍历右子树 后序遍历：①遍历左子树，②遍历右子树，③访问当前结点 递归遍历 递归写法易懂，按照遍历原则递归即可，详见代码21~41行 非递归遍历 非递归先序和中序遍历套路相似，后序遍历比较麻烦，因为先序和中序都是在右子树之前就输出了根结点，而后序必须记住根结点，等待右子树...
二叉树的遍历--递归、非递归、按层次遍历
汘荨的博客
11-23 1049
二叉树是一种树形结构，其特点是每个结点至多只有两棵子树( 即二叉树中不存在度大于2的结点)，并且二叉树的子树有左右之分，其。将该结点的右孩子和左孩子依次进栈，因为我们进行的是先序遍历，根据栈的后进先出规则，左孩子后进的，则会先被弹出栈。然后继续将‘2’出队打印，并将‘2’的左孩子右孩子入队，此时队列中有‘8’，‘1’，‘4’；二叉树的遍历有很多方法，例如递归的先序、中序、后序遍历，非递归遍历，按层次遍历等。然后将根结点出队打印，并将根结点的左孩子右孩子入队，此时队列中有‘2’，‘8’；
二叉树的遍历--递归与非递归
Juicewyh的博客
11-16 3744
    对于二叉树而言，有三种遍历方式：前序，中序，后序。由于树本身就是递归定义的，所以递归地去遍历二叉树，不仅容易理解，而且代码简洁。我们知道，递归与栈有关，那我们能否用栈来以非递归的方式实现二叉树的遍历呢？答案是肯定的，不过代码相较递归方式肯定会复杂一些。     递归是一个调用自身的特殊函数，需要编译器来维护一个栈。那么，我们先了解一下函数与栈的关系。 函数与栈     当程序执行到某...
二叉树遍历的非递归算法
热门推荐
m0_63223213的博客
08-05 1万+
非递归的算法主要采用的是循环出栈入栈来实现对二叉树的遍历，下面是过程分析
二叉树遍历非递归算法
qq_57484399的博客
12-09 4934
•三种遍历​ • 先序遍历: 根节点–>左子树–>右子树​ • 中序遍历: 左子树–>根节点–>右子树​ • 后序遍历: 左子树–>右子树–>根节点•两类算法​ • 递归算法（具体看我上一篇文章）​ ♥直观,易读​ ♥效率低下​ • 非递归算法​ ♥ 如果一个算法可以使用递归或循环来进行完成，在不影响代码阅读的情况下，可以使用循环，来降低复杂度。下面介绍二叉树的遍历，把用。
二叉树的遍历的递归与非递归算法
cx330的博客
04-08 1137
看了以上三种方式遍历二叉树的例子，应该就能明白三种遍历方式的本质与区别，其实我们可以看出，无论以何种方式，我们只要把握好访问的顺序，并且将每一个根结点下的子树都看成一个新树，再按照某种遍历方式访问这个这个新树即可！例子：中缀表达式转后缀表达式；（前缀表达式：波兰表达式；后缀表达式：逆波兰表达式）前缀表达式：-+a*bc/de（也就是以先序遍历访问上述二叉树的顺序）中缀表达式：a+b*c-d/e（也就是以中序遍历访问上述二叉树的顺序）
二叉树遍历C语言(递归-非递归)六种算法-综合文档
05-22
二叉树遍历C语言(递归-非递归)六种算法 一、设计思想 在计算机科学中，二叉树是一种常用的数据结构。它由节点和边组成，每个节点都含有一个值和两个孩子节点，分别是左孩子和右孩子。二叉树的遍历是指从树的根节点...
二叉树遍历C语言(递归-非递归)六种算法.rar-综合文档
05-11
在C语言中，我们可以使用递归和非递归两种方法实现这一过程。以下是对标题和描述中提到的六种算法的详细说明： 1. 前序遍历（Preorder Traversal）： 前序遍历的顺序是根节点 -> 左子树 -> 右子树。在递归实现中，...
二叉树遍历的流程图(递归+非递归+前中后序)
11-05
总的来说，二叉树遍历是理解数据结构和算法的基础，而掌握递归和非递归方法则能帮助我们更高效地处理树形数据。通过深入学习和实践，我们可以更好地运用这些技巧到实际的编程问题中，例如搜索、排序和树的构造等。
PyQt5实战——多脚本集合包，UI以及工程布局（二）
LyricalRover的博客
11-01 892
本文主要讲述了作者的UI页面以及工程文件的布局，提前规划好UI页面的布局有利于后续各组件的摆放以及是否要限制组件的大小，设计好工程文件的布局有利于后期维护工程以及减少开发工作量，一些重复性的代码可封装起来，作者介绍了自己工程布局的思想
DFS求解迷宫最长移动路线
最新发布
安祝老师的博客
11-05 816
来源：十四届蓝桥杯STEMA考试Python真题试卷第二套第五题。本文给出了C++实现代码，介绍了 STL 中容器`vector`，`pair`，`unordered_set` 的应用，供信奥选手参考。**迷宫类问题**适合用**DFS算法**解决，本文最后总结了DFS算法的两种常见实现方式——**递归实现、栈实现**，应用场景——**迷宫类问题、图的连通性、树的遍历、拓朴排序、排列组合**，以及主要优缺点。
Windows上如何使用CMake构建项目
weixin_73622063的博客
10-31 696
在windows平台上使用cmake构建项目
B2023 空格分隔输出
ljb_java888的博客
11-02 345
读入一个字符，一个整数，一个单精度浮点数，一个双精度浮点数，然后按顺序输出它们，并且要求在他们之间用一个空格分隔。这个程序是用C++编写的，它的主要功能是从用户那里读取一个字符、一个整数、一个浮点数和一个双精度浮点数，并将它们格式化输出。总体来说，这个程序的功能是读取并打印一个字符、一个整数、一个单精度浮点数和一个双精度浮点数。：这几行声明了四个变量，分别用于存储一个字符、一个整数、一个单精度浮点数和一个双精度浮点数。：这是一个包含了许多标准C++库的头文件，通常用于竞争编程中以减少代码的书写量。
汇川技术 - 嵌入式软件工程师 - 面经（1）
lc_guo的博客
11-04 35
0705（投递） -> 0705（测评） -> 0729（一面）-> ❌
二叉树遍历算法详解：递归与非递归实现
"二叉树遍历C语言(递归-非递归)六种算法" 二叉树遍历是数据结构中一个重要的概念，它主要用于遍历或搜索二叉树的所有节点。在这个文档中，作者详细介绍了使用C语言实现二叉树的先序、中序和后序遍历的递归和非递归...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值