二叉树的四种遍历方式

已于 2022-07-26 21:31:03 修改
阅读量9.2k 收藏 29
点赞数 6
分类专栏： 二叉树遍历 文章标签： 数据结构 c++ 二叉树
于 2022-02-16 15:56:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42127177/article/details/122965212
版权

概要

树本身是一种简单化的图 ；
DFS对应前中后序遍历，BFS对应层序遍历

二叉树结构

  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) {}
 };

1-中序遍历

二叉树的中序遍历就是首先遍历左子树，然后访问当前节点，最后遍历右子树。对于下面的二叉树，中序遍历结果如下：
在这里插入图片描述
直观来看，二叉树的中序遍历就是将节点投影到一条水平的坐标上。如图：
在这里插入图片描述

方法一：递归

这是思路最简单的方法，容易想到并且容易实现。递归的终止条件是当前节点是否为空。首先递归调用遍历左子树，然后访问当前节点，最后递归调用右子树。代码如下：

//recursive
class Solution1 {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ret;
        if(root==NULL)return ret;
        inorderHelper(ret,root);
        return ret;
    }
private:
    void inorderHelper(vector<int>& ret,TreeNode* root)
    {
        if(root==NULL)return;
        inorderHelper(ret,root->left);
        ret.push_back(root->val);
        inorderHelper(ret,root->right);
    }
};
  1. 时间复杂度：O(n)，其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
  2. 空间复杂度：O(n)。空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n) 的级别。

方法二：迭代

在迭代方法中，从根节点开始找二叉树的最左节点，将走过的节点保存在一个栈中，找到最左节点后访问，对于每个节点来说，它都是以自己为根的子树的根节点，访问完之后就可以转到右儿子上了。代码如下：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        while (root != nullptr || !stk.empty()) {
            while (root != nullptr) {
                stk.push(root);  //要在循环之后执行push(root)
                root = root->left;
            }
            root = stk.top();
            stk.pop();
            res.push_back(root->val);
            root = root->right;
        }
        return res;
    }
};

时间复杂度和空间复杂度同递归。
非递归的空间复杂度和二叉树的深度和高度有关

方法三：Morris 中序遍历

Morris 遍历算法是另一种遍历二叉树的方法，它能将非递归的中序遍历空间复杂度降为 O(1)。

Morris 遍历算法整体步骤如下（假设当前遍历到的节点为 x）：

如果 x 无左孩子，先将 x 的值加入答案数组，再访问 x 的右孩子，即 x=x.right。
如果 x 有左孩子，则找到 x 左子树上最右的节点（即左子树中序遍历的最后一个节点，x 在中序遍历中的前驱节点），我们记为 predecessor。根据 predecessor 的右孩子是否为空，进行如下操作。
如果predecessor 的右孩子为空，则将其右孩子指向 x，然后访问 x 的左孩子，即 x=x.left。
如果predecessor 的右孩子不为空，则此时其右孩子指向 x，说明我们已经遍历完 x 的左子树，我们将predecessor 的右孩子置空，将 x 的值加入答案数组，然后访问 x 的右孩子，即 x=x.right。
重复上述操作，直至访问完整棵树。

在这里插入图片描述

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        TreeNode *predecessor = nullptr;

        while (root != nullptr) {
            if (root->left != nullptr) {
                // predecessor 节点就是当前 root 节点向左走一步，然后一直向右走至无法走为止
                predecessor = root->left;
                while (predecessor->right != nullptr && predecessor->right != root) {
                    predecessor = predecessor->right;
                }
                
                // 让 predecessor 的右指针指向 root，继续遍历左子树
                if (predecessor->right == nullptr) {
                    predecessor->right = root;
                    root = root->left;
                }
                // 说明左子树已经访问完了，我们需要断开链接
                else {
                    res.push_back(root->val);
                    predecessor->right = nullptr;
                    root = root->right;
                }
            }
            // 如果没有左孩子，则直接访问右孩子
            else {
                res.push_back(root->val);
                root = root->right;
            }
        }
        return res;
    }
};
  1. 时间复杂度：O(n)，其中 nn 为二叉搜索树的节点个数。Morris 遍历中每个节点会被访问两次，因此总时间复杂度为 O(2n)=O(n)。
  2. 空间复杂度：O(1)。

2-先序遍历

方法一：递归

调整下访问顺序即可。代码如下：

//recursion
class Solution1 {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        preHelper(ret,root);
        return ret;
    }
private:
    void preHelper(vector<int>& ret,TreeNode* root)
    {
        if(root==NULL)return;
        ret.push_back(root->val);
        preHelper(ret,root->left);
        preHelper(ret,root->right);
    }
};

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        l=[]
        def dfs(root:Optional[TreeNode])->List[int]:
            if not root:
                return None
            l.append(root.val)
            dfs(root.left)
            dfs(root.right)
            return l
        dfs(root)
        return l

方法二：迭代

迭代法使用一个栈来保存当前不需要访问的节点。从根节点开始，访问当前节点，按照先右儿子后左儿子的顺序将当前节点的两个儿子压栈。当栈为空时说明遍历完毕。代码如下：

//iterative
class Solution2 {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        stack<TreeNode*> st;
        if(root==NULL)return ret;
        st.push(root);
        while(!st.empty())
        {
            TreeNode *curr=st.top();
            st.pop();
            if(curr->right)st.push(curr->right);
            if(curr->left)st.push(curr->left);
            ret.push_back(curr->val);
        }
        return ret;
    }
};

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res=list()
        stk=[]
        if not root:
            return res
        stk.append(root)
        while stk:
            node=stk.pop()
            if node.right:
                stk.append(node.right)
            if node.left:
                stk.append(node.left)
            res.append(node.val)
        return res
  1. 时间复杂度 O(N) ： 其中 N 为二叉树的节点数量，建立二叉树镜像需要遍历树的所有节点，占用 O(N) 时间。
  2. 空间复杂度 O(N) ：最差情况下，栈 stack 最多同时存储 (N+1)/2个节点(N最差的情况下只能为奇数)，占用 O(N) 额外空间。

方法三：Morris 先序遍历

前序遍历和中序遍历的Morris方法基本一样，不同之处在访问的顺序。代码如下：

//Morris
class Solution3 {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        if(root==NULL)return ret;
        TreeNode *curr=root;
        TreeNode *pre;
        while(curr)
        {
            if(curr->left==NULL)
            {
                ret.push_back(curr->val);
                curr=curr->right;
            }
            else
            {
                pre=curr->left;
                while(pre->right&&pre->right!=curr)
                    pre=pre->right;
                if(pre->right==NULL)
                {
                    ret.push_back(curr->val);
                    pre->right=curr;
                    curr=curr->left;
                }
                else
                {
                    pre->right=NULL;
                    curr=curr->right;
                }
            }
        }
        return ret;
    }
};

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res = list()
        if not root:
            return res
        
        p1 = root
        while p1:
            p2 = p1.left
            if p2:
                while p2.right and p2.right != p1:
                    p2 = p2.right
                if not p2.right:
                    res.append(p1.val)
                    p2.right = p1
                    p1 = p1.left
                    continue
                else:
                    p2.right = None
            else:
                res.append(p1.val)
            p1 = p1.right
        return res

3-层序遍历

二叉树的层序遍历：一般基于队列的实现

首先将二叉树的根节点push到队列中。
判断队列不为空就输出队头元素。
判断当前对头节点是否有孩子节点，有则push到队列中。
循环操作，直到队列为空。

方法一：迭代

vector<int> levelOrder(TreeNode* Tree) //层序遍历_队列实现
{
	vector<int>res;
    queue < TreeNode* > q;
    if (Tree != NULL)
        q.push(Tree);   //根节点进队列
    while (q.empty() == false)  //队列不为空
    {
        TreeNode* node=q.front();
        res.push_back(node->val); 
 
        if (node->left != NULL)   //如果有左孩子，入队
            q.push(node->left);   
 
        if (node->right != NULL)   //如果有右孩子，入队
            q.push(node->right);
        q.pop();  //已经遍历过的节点出队列
    }
    return res;
}
  1. 时间复杂度：O（N）,N 为二叉树的节点数量，即 BFS 需循环 N 次。
  2. 空间复杂度：O（N）,最差情况下，即当树为平衡二叉树时，最多有 N/2 个树节点同时在 queue 中，使用O(N) 大小的额外空间。

方法二a：分行进行层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        vector<int> level_data;
        if(root==NULL)
            return res;
        queue<TreeNode*> q;
        q.push(root);
        q.push(NULL);
        while(!q.empty())
        {
            TreeNode* temp=q.front();
            q.pop();
            if(temp)
            {
                level_data.push_back(temp->val);
                if(temp->left)
                    q.push(temp->left);
                if(temp->right)
                    q.push(temp->right);
            }
            else
            {
                if(!level_data.empty())
                {
                    q.push(NULL);
                    res.push_back(level_data);
                    level_data.clear();
                }
            }
        }
        return res;
    }
};

方法三： leetcode形式

可以归纳出这样的循环不变式：第 i 次迭代前，队列中的所有元素就是第 i 层的所有元素，并且按照从左向右的顺序排列。证明它的三条性质（你也可以把它理解成数学归纳法）：

初始化：i=1 的时候，队列里面只有 root，是唯一的层数为 1 的元素，因为只有一个元素，所以也显然满足「从左向右排列」；
保持：如果 i=k 时性质成立，即第 k 轮中出队sk ​ 的元素是第 k层的所有元素，并且顺序从左到右。因为对树进行广度优先搜索的时候由低 k 层的点拓展出的点一定也只能是 k+1 层的点，并且 k+1 层的点只能由第 k 层的点拓展到，所以由这 sk ​个点能拓展到下一层所有的 sk+1 ​个点。又因为队列的先进先出（FIFO）特性，既然第 k 层的点的出队顺序是从左向右，那么第 k+1层也一定是从左向右。至此，我们已经可以通过数学归纳法证明循环不变式的正确性。
终止：因为该循环不变式是正确的，所以按照这个方法迭代之后每次迭代得到的也就是当前层的层次遍历结果。至此，我们证明了算法是正确的。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector <vector <int>> ret;
        if (!root) {
            return ret;
        }
        queue <TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            int currentLevelSize = q.size();
            ret.push_back(vector <int> ());
            for (int i = 1; i <= currentLevelSize; ++i) {
                auto node = q.front(); q.pop();
                ret.back().push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }  
        return ret;
    }
};
  1. 时间复杂度：每个点进队出队各一次，故渐进时间复杂度为 O(n)，树上所有节点的个数为n。
  2. 空间复杂度：队列中元素的个数不超过 n 个，故渐进空间复杂度为O(n)，满二叉树的时候队列元素是最多的。

二叉树的层序遍历II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>>ret;
        if(!root)
            return ret;
        queue<TreeNode*>q;
        q.push(root);
        while(!q.empty())
        {
            int currentLevelSize=q.size();
            ret.push_back(vector<int>());
            for(int i=1;i<=currentLevelSize;++i)
            {
                auto node=q.front();q.pop();
                ret.back().push_back(node->val);
                if(node->left)q.push(node->left);
                if(node->right)q.push(node->right);
            }
        }
        reverse(ret.begin(),ret.end());
        return ret;
    }
};
  1. 时间复杂度：O（n）
  2. 空间复杂度：O（n）

扩展：之字形打印二叉树

利用两个栈

//按之字形打印
	void Print(TreeNode *root)
	{
		if (root == NULL)
			return;
		stack<TreeNode*>levels[2];
		int current = 0, next = 1;
		levels[current].push(root);
		while (!levels[0].empty() || !levels[1].empty())
		{
			TreeNode*node = levels[current].top();
			levels[current].pop();
			printf("%d", node->val);
			if (current == 0)
			{
				if (node->left != nullptr)
					levels[next].push(node->left);
				if (node->right != nullptr)
					levels[next].push(node->right);
			}
			else
			{
				if (node->right != nullptr)
					levels[next].push(node->right);
				if (node->left != nullptr)
					levels[next].push(node->left);
			}

			if (levels[current].empty())
			{
				cout << endl;
				current = 1 - current;
				next = 1 - next;
			}
		}
	}
  1. 时间复杂度：每个点进栈出栈各一次，故渐进时间复杂度为 O(n)，树上所有节点的个数为n。
  2. 空间复杂度：栈中元素的个数不超过 n 个，故渐进空间复杂度为O(n)，满二叉树的时候栈的元素是最多的。

二叉树的锯齿形层序遍历

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>>vec;
        if(root==NULL)
            return vec;
        stack<TreeNode*>levels[2];
        int current=0,next=1;
        levels[current].push(root);
        vec.push_back(vector<int>());
        while(!levels[current].empty()||!levels[next].empty())
        {
            TreeNode *pNode=levels[current].top();
            levels[current].pop();
            if(pNode==NULL)
                continue;
                
            vec.back().push_back(pNode->val);
            if(current==0)
            {
                if(pNode->left)
                    levels[next].push(pNode->left);
                if(pNode->right)
                    levels[next].push(pNode->right);               
            }
            else
            {
               if(pNode->right)
                    levels[next].push(pNode->right);
                if(pNode->left)
                    levels[next].push(pNode->left);     
            }
            if(levels[current].empty())
            {
               vec.push_back(vector<int>());
                current=1-current;
                next=1-next;
            }
           
        }
        vec.pop_back();
         return vec;
    }
};

4-后序遍历

方法一：递归

//recursion
class Solution1 {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        postHelper(ret,root);
        return ret;
    }
private:
    void postHelper(vector<int>& ret,TreeNode* root)
    {
        if(root==NULL)return;
        postHelper(ret,root->left);
        postHelper(ret,root->right);
        ret.push_back(root->val);
    }
};
  1. 时间复杂度：O（N）
  2. 空间复杂度：O（N）

方法二：迭代

迭代法使用一个栈来保存当前不需要访问的节点。不过，不同于中序遍历与前序遍历，在后序遍历中每一个节点需要一个标志位，来标识当前节点的左右子树是否被访问。因为在后序遍历中，只有一个节点的左右子树被访问后它才能被访问。因此，压入栈中的数据类型需要是一个pair<TreeNode*,int>，其中用1来表示当前节点的左右子树正被访问，当再次访问到此节点时可以访问此节点；用0表示当前节点的左右子树未被访问，再次访问到此节点时需要首先访问此节点的左右子树。

//iteration
class Solution1 {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        if(root==NULL)return ret;
        stack<pair<TreeNode*,int>> st;
        st.push(make_pair(root,0));
        while(!st.empty())
        {
            TreeNode *curr=st.top().first;
            if(st.top().second==1)
            {
                ret.push_back(curr->val);
                st.pop();
            }
            else
            {
                st.top().second=1;
                if(curr->right)st.push(make_pair(curr->right,0));
                if(curr->left)st.push(make_pair(curr->left,0));
            }
        }
        return ret;
    }
};
  1. 时间复杂度：O（N），每个节点需访问两次
  2. 空间复杂度：O（N）

方法三：迭代法

这种方法就是按照根、右、左的顺序访问，然后将结果取反即可。后序遍历的顺序是左、右、根。这种方法就可以在前序遍历的基础上修改即可。代码如下：

class Solution3 {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        if(root==NULL)return ret;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty())
        {
            TreeNode *curr=st.top();
            st.pop();
            if(curr->left)st.push(curr->left);
            if(curr->right)st.push(curr->right);
            ret.push_back(curr->val);
        }
        reverse(ret.begin(),ret.end());
        return ret;
    }
};
  1. 时间复杂度：O（N），按照根、右、左的顺序遍历时，每个节点被访问一次，将结果取反时，每个节点也被访问一次，所以每个节点需访问两次
  2. 空间复杂度：O（N）

Morris方法

后序遍历的Morris方法思路比较难。但整体上还是一样的，对原来的二叉树的修改也是一样的，不同的是访问的顺序。而在后序遍历中，访问时比较麻烦。下面是整个算法的工作过程;

首先建立一个临时节点dump，令其左儿子是root。并且还需要一个子过程，就是倒序输出某两个节点之间路径上的各个节点。
步骤：
当前节点设置为临时节点dump。
（1）如果当前节点的左儿子为空，则将其右儿子作为当前节点；
（2）如果当前节点的左儿子非空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点；
a) 如果前驱节点的右孩子为空，将它的右儿子设置为当前节点。当前节点更新为当前节点的左儿子；
b) 如果前驱节点的右儿子为当前节点，将它的右孩子重新设为空。倒序输出从当前节点的左儿子到该前驱节点这条路径上的所有节点。当前节点更新为当前节点的右儿子；
（3）重复以上（1）（2）直到当前节点为空。

代码如下：

//morris
class Solution4 {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        TreeNode *dump=new TreeNode(0);
        dump->left=root;
        TreeNode *curr=dump;
        TreeNode *pre;
        while(curr)
        {
            if(curr->left==NULL)
            {
                curr=curr->right;
            }
            else
            {
                pre=curr->left;
                while(pre->right&&pre->right!=curr)
                    pre=pre->right;
                if(pre->right==NULL)
                {
                    pre->right=curr;
                    curr=curr->left;
                }
                else
                {
                    reverseAddNodes(curr->left,pre,ret);
                    pre->right=NULL;
                    curr=curr->right;
                }
            }
        }
        return ret;
    }
private:
    void reverseAddNodes(TreeNode *begin,TreeNode *end,vector<int>& ret)
    {
        reverseNodes(begin,end);
        TreeNode *curr=end;
        while(true)
        {
            ret.push_back(curr->val);
            if(curr==begin)break;
            curr=curr->right;
        }
        reverseNodes(end,begin);
    }
    void reverseNodes(TreeNode *begin,TreeNode *end)
    {
        TreeNode *pre=begin;
        TreeNode *curr=pre->right;
        TreeNode *post;
        while(pre!=end)
        {
            post=curr->right;
            curr->right=pre;
            pre=curr;
            curr=post;
        }
    }
};
  1. 时间复杂度：O（N）
  2. 空间复杂度：O（1）
Emperorist
关注
  • 6
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树各种遍历算法的C++实现
05-19
包括了二叉树的各种递归与非递归的遍历算法 还可对二叉树所有结点求和
二叉树的遍历
qq_39715645的博客
04-03 146
二叉树的遍历 说一下四个非递归遍历的思路。 先序的非递归遍历最好理解，先将根节点节点入栈，进入循环，将栈顶元素出栈，输出节点数据，然后将出栈节点右孩子入栈，再压入左孩子，这样的顺序入站之后栈顶节点就是上一个节点的左孩子。重复这个过程直到栈空遍历完成。 中序的非递归遍利用一个栈保存上一个节点，首先左子树一路走到底，遇到叶子节点之后栈顶元素弹出，然后将将弹出的节点的右子树入栈。 后序遍历用了两个栈，我...
全网最简单的二叉树遍历方法详解（一学就会）
weixin_45393946的博客
07-31 3421
方法学自UP主小黑课堂计算机二级的讲解视频 https://www.bilibili.com/video/BV16b411h7PH?from=search&seid=3192671096942049668 视频讲解的比我叙述的清楚，可以观看原视频 深度优先的二叉树遍历方法有三 前序法：访问根结点→左子树→右子树 口诀：根左右 中序法：访问左子树→根结点→右子树 口诀：左根右 后序法：访问左子树→右子树→ 根结点 口诀：左右根 之前一直没能理解遍历的方法，简单的会做复杂的就不会了，例如下图的
浙大数据结构笔记-二叉树的遍历
qq_24041595的博客
10-01 331
二叉树 链表式存储结构 二叉树结构 typedef struct TreeNode *BinTree; typedef BinTree Position; struct TreeNode { ElementType Data; BinTree Left; BinTree Right; }; 堆栈结构 typedef struct StackNode *Stack; struct Stack...
二叉树的四种遍历算法（结构体数组）
m0_65129892的博客
01-06 1465
二叉树的遍历，使用结构体数组
数据结构--二叉树遍历(详细过程)
热门推荐
m0_56283131的博客
04-21 3万+
详细到啰嗦的程度，完全0基础都可完成。
详解二叉树的遍历
supermouse的博客
02-16 1万+
概述 二叉树的遍历是一个很常见的问题。二叉树的遍历方式主要有：先序遍历、中序遍历、后序遍历、层次遍历。先序、中序、后序其实指的是父节点被访问的次序。若在遍历过程中，父节点先于它的子节点被访问，就是先序遍历；父节点被访问的次序位于左右孩子节点之间，就是中序遍历；访问完左右孩子节点之后再访问父节点，就是后序遍历。不论是先序遍历、中序遍历还是后序遍历，左右孩子节点的相对访问次序是不变的，总是先访问左孩子...
一文弄懂二叉树的三种遍历方式
高性能架构探索
08-31 2万+
关注公众号:高性能架构探索。后台回复【资料】，可以免费领取 俗话说：学如逆水行舟,不进则退;心似平原走马,易放难收。这句话对程序员而言，体会更深。这行已经越来越卷了，时刻准备着，????。 二叉树，在面试中，已是必备的开胃菜。而在二叉树相关的面试题目中，遍历更是常考题目。本文将从二叉树的遍历角度入手，从递归和非递归角度来分析和讲解二叉树的遍历。 遍历 二叉树的遍历是指从根节点出发，按照某种次序依次访问二叉树中的所有节点，使每个节点被且仅被访问一次。 二叉树的遍历，有先序遍历、中序遍历以
数据结构|二叉树的三种遍历方式，你掌握了几种？
我的主页
04-15 1万+
本期讲解二叉树的三种遍历方式：前序遍历、中序遍历、后序遍历的详细讲解，图文并茂通俗易懂。
二叉树的五种遍历方式
weixin_47382783的博客
03-29 1万+
目录 1、前序遍历 （1）递归实现前序遍历 （2）非递归实现前序遍历 2、中序遍历 （1）递归实现中序遍历 （2）非递归实现中序遍历 3、后序遍历 （1）递归实现后序遍历 （2）非递归实现后序遍历 4、层序遍历 二叉树是一种重要的数据结构，其遍历方式分为：深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即就是层次遍历。如下图： class TreeNode{ int val; TreeNode left; TreeNode ..
二叉树的四种遍历方式.docx
04-24
二叉树遍历问题
C语言二叉树的三种遍历方式的实现及原理
12-31
二叉树遍历分为三种：前序、中序、后序，其中序遍历最为重要。为啥叫这个名字？是根据根节点的顺序命名的。 比如上图正常的一个满节点，A：根节点、B：左节点、C：右节点，前序顺序是ABC（根节点排最先，然后同级先...
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；...ABCDEFG【选做内容】采用非递归算法实现二叉树遍历。
二叉树的四种种遍历方式.docx
08-18
用C++实现二叉树的前序遍历、中序遍历、后续遍历、层次遍历。分别采用递归的方法和迭代的方法，对入门级数据结构和算法学习大有裨益。不同的方法相互比对，更容易加深理解。
二叉树建立及遍历算法实现
06-03
建立二叉树，实现二叉树的先序、中序、后序的递归遍历算法，输出遍历结果。 实现二叉树的先序、中序、后序和层次遍历的非递归算法，输出遍历结果。
数据结构——树和二叉树的基本概念
最新发布
qq_67693066的博客
04-24 1073
数据结构——树和二叉树的基本概念
数据结构中的栈和队列（附实际案例代码）
JAZJD的博客
04-23 792
栈（Stack）和队列（Queue）
数据结构——堆
2301_76613753的博客
04-20 1562
之前我们了解到了一种非线性的数据结构——树，今天我们来学习二叉树的顺序结构——堆的实现，来了解堆这种数据结构。一、堆的概念及结构如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足： <=且 <=( >=且 >= ) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。堆的性质：堆中某个节点的值总是不大于或不小于其父节点的值；堆总是一棵完全二叉树。
数据结构面试常见问题：什么是二叉树？如何进行二叉树的遍历？
万猫学社
04-21 879
二叉树是一种特殊的数据结构，它的每个元素都有零个、一个或两个子元素。这些元素被称为节点，每个节点都有一个值，以及两个指向其子节点的链接。这种结构就像一个家族树，每个节点都有一个父节点（除了顶部的根节点），以及左右两个子节点。在实际项目中，我们经常会用到二叉树这种数据结构，它在数据存储、搜索等方面都有着广泛的应用。接下来，我们将深入探讨二叉树的结构，包括节点、父节点、子节点、叶节点、根节点等概念。在本文中，我们介绍了二叉树的基本结构，以及前序遍历、中序遍历和后序遍历的实现方式。
二叉树三种遍历的本质是什么
05-19
二叉树三种遍历指的是先序遍历、中序遍历和后序遍历。它们的本质是针对树的节点遍历顺序不同而导致的不同遍历结果。 先序遍历：按照“根节点-左子树-右子树”的顺序遍历整棵树，即先访问根节点，再访问左子树，最后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值