Binary Tree 非递归遍历模板小结(经典!)

c++模板实现二叉树,线索化,线索化遍历,非递归遍历及一些基本操作 c++模板类实现二叉树一些基本操作:前中后 遍历 及其 非递归遍历。  二叉树线索化, 及线索化后采用非递归方式遍历。  层序遍历。  叶子结点个数, k层节点个数, 二叉树深度, 查找元素等。 两个头文件, 一个是线索化有关, 另一个是别的操作 BinaryTree: #ifndef BINARY_TREE_H_ #define BINARY_TREE_H_ //树 阅读详情

Binary Tree的遍历可分为preorder, inorder, postorder和in-level order四种。前3种可用递归或非递归(基于stack,后进先出),第4种通常用BFS,基于queue(先进先出),也可以用DFS,基于stack。注意这里是Binary Tree,不需要是Binary Search Tree。

preorder遍历非递归模板:
遍历顺序为根、左、右
思路:

  1. 如果根节点非空,将根节点加入到栈中。
  2. 如果栈不空,弹出栈顶节点,将其值加加入到数组中。
    2.1 如果该节点的右子树不为空,将右子节点加入栈中。
    2.2 如果左子节点不为空,将左子节点加入栈中。
  3. 重复第二步,直到栈空。
    代码如下://最终参考版
/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: A Tree
     * @return: Preorder in ArrayList which contains node values.
     */
    vector<int> preorderTraversal(TreeNode * root) {
        if (!root) return {};
        vector<int> result;
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty()) {
            TreeNode* temp = s.top();
            s.pop();
            result.push_back(temp->val);

            if (temp->right) s.push(temp->right);
            if (temp->left) s.push(temp->left);
        }  
        return result;
    }
};

in-order非递归模板:(非常重要!!!)
遍历顺序为左、根、右

思路
1. 从根节点开始,开始把左节点挨个压栈,直至最左端的叶节点。
2. 若stack不为空,对node=stack.top(),存入结果。
若node无右节点,则pop,并看node在stack前一个位置(也就是新的stack.top)是不是node的父节点,并且node是它的右节点);若是,也将其pop()。

//注意:根据in-order的特点,如果某个节点无右节点,或者右节点已经访问过,说明这就是根了,应该pop。
若node有右节点,则将其压栈,并将其左节点挨个压栈,直至其左子树的最左端的叶节点。
//注意:根据in-order的特点,如果某个节点还有右节点没访问,那就要先访问右节点,即要先将其压栈。
3. 重复2,直到stack空。

举例如下:
第一个while循环沿着左节点压栈,s={6,5,3,2}, 2是栈顶。
第二个while循环
先将node=s.top()的存入结果(2),然后看node是否有右节点,这里没有,所以pop()。
然后新的node=s.top()存入结果(3),这里因为3有右节点4(这里3不能pop,否则4返回就找不到3了),所以将节点4压栈,s={6,5,3,4}。
然后新的node=s.top()存入结果(4),这里4没有右节点,所以4 pop,然后我们看到4是3的右节点,所以3 pop。然后后面的循环会处理5,6,…。
第三个while循环本质上和第一个while循环一样。
这里写图片描述

代码如下(参考自九章)://最终参考版
首先访问左子树,将左子树存入栈中,每次将栈顶元素存入结果,如果右子树为空,取出栈顶元素,如果当前元素为栈顶元素右子树,一直弹出至当前元素不为栈顶元素右子树(此处说明访问右子树,根节点已经被访问过,弹出即可)。如果节点右子树不为空,访问右子树,继续循环遍历左子树,存入栈中。

    vector<int> inorderTraversal(TreeNode * root) {
         
        vector<int> result;
        stack<TreeNode *> s;
        if (!root) return result;

        while(root) {
            s.push(root);
            root=root->left;
        }

        while(!s.empty()) {
            TreeNode* node=s.top();
            result.push_back(node->val);
            
            if (!node->right) {
                s.pop();
                while(!s.empty() && (s.top()->right==node)) {
                    node=s.top();
                    s.pop();
                }
            } else {
                node = node->right;
                while(node) {
                    s.push(node);
                    node=node->left;
                }
            }
        }
         
        return result;
    }

又看了一下代码,之前的解释不是很清楚。现在重新解释一下,上面的if(node->right)这个分支好理解,就是如果当前节点有右节点,那就找到右子树的最左边的节点,并沿途挨个压栈。
难点在于if(!node->right)这个分支,为什么有下面这行代码呢? 因为如果没有之前的if(node->right)处理,也就是s.top()没有右子树的话,那就直接s.pop()就可以了,但之前因为s.top()有右节点,进行了if(node->right)的处理,所以s.top()这个节点要推迟到现在才能s.pop()。为啥不能去掉(s.top()->right==node)呢?因为s.top()这个节点和node不一样,node没有右节点,s.top()不一定没有。如果把s.top()不管三七二十一都pop()掉,那么s.top()的右节点就断了,以后也找不到了。

                while(!s.empty() && (s.top()->right==node)) {
                    node=s.top();
                    s.pop();
                }

简化版:
事实上每次stack的top push到res里后就可以从stack里面删掉了,不需要留着。注意下面的这个代码可以用于求二叉树的next iterator,但是不能用于求previous iterator。因为栈里面有些信息已经被删掉了。而上面那个版本不光可以求next iterator,也可以求previous iterator(把代码里面的left 和right互换就可以)。

class Solution {
public:
    /**
     * @param root: A Tree
     * @return: Inorder in ArrayList which contains node values.
     */
    vector<int> inorderTraversal(TreeNode *root) {
        if (!root) return {};
        vector<int> res;
        stack<TreeNode *> stk;

        while (root) {
            stk.push(root);
            root = root->left;
        }

        while (!stk.empty()) {
            TreeNode *node = stk.top();
            res.push_back(node->val);
            stk.pop();
            if (node->right) {
                node = node->right;
                while (node) {
                    stk.push(node);
                    node = node->left;
                }

            }

        }
        return res;
    }
};

post-order非递归模板
遍历顺序为左、右、根

  1. 如果根节点非空,将根节点加入到栈中。
  2. 如果栈不空,取栈顶元素(暂时不弹出),
    i. 如果(左子树已访问过或者左子树为空),且(右子树已访问过或右子树为空),则弹出栈顶节点,将其值加入数组,
    ii. 如果左子树不为空,切未访问过,则将左子节点加入栈中,并标左子树已访问过。
    iii. 如果右子树不为空,切未访问过,则将右子节点加入栈中,并标右子树已访问过。
  3. 重复2,直到栈空。

代码如下:

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: A Tree
     * @return: Postorder in ArrayList which contains node values.
     */
    vector<int> postorderTraversal(TreeNode * root) {
        vector<int> result;
        stack<TreeNode *> s;
        
        TreeNode * current = root, * lastVisited = NULL;
        
        if (!root) return vector<int>();
        
        s.push(root);
        
        while(!s.empty()) {
            current = s.top();
            if (!lastVisited || current == lastVisited->left || current == lastVisited->right) {
                if (current->left) {
                    s.push(current->left);
                } else if (current->right) { //note! the else is needed here!!!
                    s.push(current->right);
                }
            } else if (current->left == lastVisited) {
                if (current->right) {
                    s.push(current->right);
                }
            } else {
                result.push_back(current->val);
                s.pop();
            }   
            
            lastVisited = current;
        }
        
        return result;
    }
};

下面这个版本更好。//最终参考版
使用栈进行二叉树后序遍历,首先对左子树进行遍历压入栈中,直至左子树为空,然后访问右子树。故每个节点会被访问两次,当节点被第二次访问时,即curr->right=lastvisit时,该节点出栈。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        vector<int> result;
        stack<TreeNode *> myStack;
        
        TreeNode *current = root, *lastVisited = NULL;
        while (current != NULL || !myStack.empty()) {
            while (current != NULL) {
                myStack.push(current);
                current = current->left;
            }
            current = myStack.top(); 
            if (current->right == NULL || current->right == lastVisited) {
                myStack.pop();
                result.push_back(current->val);
                lastVisited = current;
                current = NULL;
            } else {
                current = current->right;
            }
        }
        return result;
    }
};

上面的几种解法还是没有统一风格,下面是链接
https://www.jianshu.com/p/49c8cfd07410
给出的更统一的模板。非常好。

//更简单的非递归前序遍历
void preorderTraversalNew(TreeNode *root, vector<int> &path)
{
    stack< pair<TreeNode *, bool> > s;
    s.push(make_pair(root, false));
    bool visited;
    while(!s.empty())
    {
        root = s.top().first;
        visited = s.top().second;
        s.pop();
        if(root == NULL)
            continue;
        if(visited)
        {
            path.push_back(root->val);
        }
        else
        {
            s.push(make_pair(root->right, false));
            s.push(make_pair(root->left, false));
            s.push(make_pair(root, true));
        }
    }
}
//更简单的非递归中序遍历
void inorderTraversalNew(TreeNode *root, vector<int> &path)
{
    stack< pair<TreeNode *, bool> > s;
    s.push(make_pair(root, false));
    bool visited;
    while(!s.empty())
    {
        root = s.top().first;
        visited = s.top().second;
        s.pop();
        if(root == NULL)
            continue;
        if(visited)
        {
            path.push_back(root->val);
        }
        else
        {
            s.push(make_pair(root->right, false));
            s.push(make_pair(root, true));
            s.push(make_pair(root->left, false));
        }
    }
}

//更简单的非递归后序遍历
void postorderTraversalNew(TreeNode *root, vector<int> &path)
{
    stack< pair<TreeNode *, bool> > s;
    s.push(make_pair(root, false));
    bool visited;
    while(!s.empty())
    {
        root = s.top().first;
        visited = s.top().second;
        s.pop();
        if(root == NULL)
            continue;
        if(visited)
        {
            path.push_back(root->val);
        }
        else
        {
            s.push(make_pair(root, true));
            s.push(make_pair(root->right, false));
            s.push(make_pair(root->left, false));
        }
    }
}

in-level order 非递归版
思路: 用queue。
一开始将root放入queue中,然后进入while(!queue.empty()),若queue不为空,则按queue中有多少元素(queue.size()),不断取queue.front(),将其值存入结果,再将其左右节点push进queue。周而往复,直到queue空。
代码如下:

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: A Tree
     * @return: Level order a list of lists of integer
     */
    vector<vector<int>> levelOrder(TreeNode * root) {
        vector<vector<int> > result;
        if (!root) return result;
        
        queue<TreeNode *> q;
        q.push(root);
        
        while(!q.empty()) {
            vector<int> vec;
            int size=q.size();
            for (int i=0; i<size; ++i) {
                TreeNode* node=q.front();
                q.pop();   
                vec.push_back(node->val);
                if (node->left) 
                    q.push(node->left);
                if (node->right)
                    q.push(node->right);
 
            }
            result.push_back(vec);
        } 
        return result; 
    }
};

另外还有二叉树Zigzag遍历,见
https://blog.youkuaiyun.com/roufoo/article/details/103946959

还有二叉树按vertical order遍历,见
https://blog.youkuaiyun.com/roufoo/article/details/103943335

还有二叉树Morris遍历

再来一个二叉树非递归模板,即直接用一个stack模拟系统调用,context存储系统调用中应该保留的信息。这里采用vector而不是stack做栈是因为希望修改stack.top()。

前序遍历


/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */

struct Context {
    TreeNode* node;
    int step;
    Context(TreeNode* _node = NULL, int _step = 0) : node(_node), step(_step) {}
};

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<Context> s;
        s.push_back(Context(root, 0));
        vector<int> res;
        while (!s.empty()) {
            if (s.back().node == NULL) {
                //root为空,直接返回
                s.pop_back();
            } else if (s.back().step == 0) {
                s.back().step = 1;
                res.push_back(s.back().node->val);
                //if (s.back().step == 0) s.pop_back();
            } else if (s.back().step == 1) {
                s.back().step = 2;
                s.push_back(Context(s.back().node->left, 0));
            } else if (s.back().step == 2) {
                s.back().step = 3;
                s.push_back(Context(s.back().node->right, 0));
            } else if (s.back().step == 3) {
                //表示当前栈顶的左右子节点都处理完了,这是为了跟step==0做区分,step==0是当前栈顶还没开始处理左右字节点的情况。
                s.pop_back();
            }
        }
        return res;  
    }
};

中序遍历:

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */

struct Context {
    TreeNode* node;
    int step;
    Context(TreeNode* _node = NULL, int _step = 0) : node(_node), step(_step) {}
};

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
     vector<Context> s;
        s.push_back(Context(root, 0));
        vector<int> res;
        while (!s.empty()) {
            if (s.back().node == NULL) {
                //root为空,直接返回
                s.pop_back();
            } else if (s.back().step == 0) {
                s.back().step = 1;
                s.push_back(Context(s.back().node->left, 0));
                //if (s.back().step == 0) s.pop_back();
            } else if (s.back().step == 1) {
                s.back().step = 2;
                res.push_back(s.back().node->val);
            } else if (s.back().step == 2) {
                s.back().step = 3;
                s.push_back(Context(s.back().node->right, 0));
            } else {
                //表示当前栈顶的左右子节点都处理完了,这是为了跟step==0做区分,step==0是当前栈顶还没开始处理左右字节点的情况。
                s.pop_back();
            }
        }
        return res;      
    }
};

后序遍历:

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */

struct Context {
    TreeNode* node;
    int step;
    Context(TreeNode* _node = NULL, int _step = 0) : node(_node), step(_step) {}
};

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<Context> s;
        s.push_back(Context(root, 0));
        vector<int> res;
        while (!s.empty()) {
            if (s.back().node == NULL) {
                //root为空,直接返回
                s.pop_back();
            } else if (s.back().step == 0) {
                s.back().step = 1;
                s.push_back(Context(s.back().node->left, 0));
            } else if (s.back().step == 1) {
                s.back().step = 2;
                s.push_back(Context(s.back().node->right, 0));
            } else {
                res.push_back(s.back().node->val);
                s.pop_back();
            }
        }
        return res;  
    }
};

注意后序遍历中,根节点最后处理,可以顺便弹栈,所以它不用加step=3的情况。为了便于和前序和中序统一版本,也可以加step=3的情况,结果一样。

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */

struct Context {
    TreeNode* node;
    int step;
    Context(TreeNode* _node = NULL, int _step = 0) : node(_node), step(_step) {}
};

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<Context> s;
        s.push_back(Context(root, 0));
        vector<int> res;
        while (!s.empty()) {
            if (s.back().node == NULL) {
                //root为空,直接返回
                s.pop_back();
            } else if (s.back().step == 0) {
                s.back().step = 1;
                s.push_back(Context(s.back().node->left, 0));
            } else if (s.back().step == 1) {
                s.back().step = 2;
                s.push_back(Context(s.back().node->right, 0));
            } else if (s.back().step == 2) {
                s.back().step = 3;
                res.push_back(s.back().node->val);
            } else {
                s.pop_back();
            }
        }
        return res;  
    }
};

附加一个最好的中序遍历非递归模板,非常简洁。

class Solution {
public:
    /**
     * @param root: A Tree
     * @return: Inorder in ArrayList which contains node values.
     */
    vector<int> inorderTraversal(TreeNode *root) {
        stack<TreeNode *> stk;
        vector<int> res;
        while (root || !stk.empty()) {
            while (root) {
               stk.push(root);
               root = root->left;
            }
            root = stk.top();
            stk.pop();
            res.push_back(root->val);
            root = root->right;
        }
        return res;
    }
};

/////////
个人新总结:

  1. 前序遍历就是自上向下,后序遍历就是自下而上。
    中序遍历其实用得不多,因为如果分叉数不是2的话就不好用中序。
  2. Quick Sort类似于前序遍历,Merge Sort 类似于后序遍历。

准备采用这个模板了。前中后序遍历都可以用。

前序遍历:

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if (!root) return {};
        visited = new TreeNode(-1);
        vector<int> res;
        goLeft(root, res);
        while (!stk.empty()) {
            TreeNode *topNode = stk.top();
            
            if ((!topNode->left || topNode->left == visited) && topNode->right != visited) {
                //inorder here
                goLeft(topNode->right, res);
            }

            if (!topNode->right || topNode->right == visited) {

                stk.pop();
                visited = topNode;
            }
        }
        return res;
    }
private:
    void goLeft(TreeNode *root, vector<int> &res) {
        while (root) {
            //preorder here
            res.push_back(root->val);
            stk.push(root);
            root = root->left;
        }
        return;
    }
    stack<TreeNode *> stk;
    TreeNode *visited;
};

中序遍历:

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        TreeNode *visited = new TreeNode(-1);  //注意:这里不能用visited = NULL,不然跟后面的topNode->left == visited 或 topNode->right == visited搞混。
        pushLeft(root);
        while (!stk.empty()) {
            TreeNode *topNode = stk.top();
            if ((!topNode->left || topNode->left == visited) && (topNode->right != visited)) {
                //左子树遍历完,右子树还没有遍历。中序代码放这里
                res.push_back(topNode->val);
                pushLeft(topNode->right);
          }
            if (!topNode->right || topNode->right == visited) {
                //左子树和右子树都遍历完了。后序代码放这里
                visited = topNode;
                stk.pop();
            }
        }
        return res;
    }
private:
    stack<TreeNode *> stk;
    void pushLeft(TreeNode *root) {
        while (root) {
        //左子树还没有遍历。前序代码放这里
            stk.push(root);
            root = root->left;
        }
    }
};

后续遍历:

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if (!root) return {};
        vector<int> res;
        visited = new TreeNode(-1);
        goLeft(root, res);
        while (!stk.empty()) {
            TreeNode *topNode = stk.top();

            if ((!topNode->left || topNode->left == visited) && topNode->right != visited) {
                //inorder here
                goLeft(topNode->right, res);
            }

            if (!topNode->right || topNode->right == visited) {
                //postorder here
                res.push_back(topNode->val);
                stk.pop();
                visited = topNode;
            }
        }
        return res;
    }
private:
    void goLeft(TreeNode *root, vector<int> &res) { //注意goLeft结束后,root值不变。goLeft的作用仅仅是把一系列left的节点压栈。
        while (root) {
            //preorder here
            stk.push(root);
            root = root->left;
        }
        return;
    }
    TreeNode *visited;
    stack<TreeNode *> stk;
};

从零开始:PLUMED与GROMACS整合安装全攻略 本文详细介绍了如何从零开始整合安装PLUMED与GROMACS,包括系统环境检查、MPI配置、PLUMED编译安装、GROMACS补丁应用及常见问题解决方案。通过本教程,研究人员可以快速完成分子动力学模拟工具的整合安装,实现增强采样和自由能计算功能。 阅读详情

相关推荐

别再为EPI形变头疼了!FSL的topup+eddy实战保姆级教程(含AP/PA数据采集要点)

本文详细介绍了如何使用FSL的topup和eddy工具解决EPI形变问题,包括数据采集要点、参数设置和实战操作步骤。通过AP/PA双编码数据和精确的形变场估计,有效矫正MRI图像中的几何畸变,提升弥散数据质量。特别适合需要处理高场强MRI数据的研究人员和技术人员。

weixin_28725949的博客 403

数据结构--二叉树构造模板

包含四个头文件,需要哪个函数直接抄上就可以的 头文件:binary_tree: #pragma once #pragma once #include<iostream> #include"lk_ queue.h" #include"lk_stack.h" #include"node.h" using namespace std; template <class ElemType> struct BinTreeNode { // 数据成员: ElemType data; .

m0_53252742的博客 4009

浙政钉(专有钉钉)门户免登(超详细)

钉钉家族 介绍浙政钉门户免登之前,首先搞清楚几个软件的关系,软件分别是:钉钉,专有钉钉,浙政钉 钉钉 是阿里巴巴集团专为中小企业打造的沟通和协同的多端平台。 专有钉钉 原名 政务钉钉,有更开放的设计能力、集成能力、更结构化协同产品、更定制化开发平台。支持专有化部署,数据落本地,更安全、客户可对该产品持牌运营、结构化编排,协助构建本地应用中心、提供移动应用全面安全保障体系。 浙政钉 为规范浙政钉整体架构体系,按照统分结合原则,由省政府办公厅统一设计整体工作界面和系统框架,统筹指导全省统建应用建设,各单

一缕南风的博客 2万+

二叉树的先序(preorder),中序(inorder),后序(postorder)的遍历(python)

本篇文章主要是总结二叉树的三种遍历方式,和相关leetcode算法题的解法。 跟线性的数据结构(矩阵,列表,队列,栈···)不同,树的遍历可以有不同的遍历方式。 先序遍历 遍历过程如下: 访问根节点, 访问当前节点的左子树, 访问当前节点的右子树。 先序遍历的应用场景主要是对树进行复制。对于上面的树,先序遍历的顺序是1 2 4 5 3. 简单的用递归实现一下: def printPreord...

15plus的博客 3万+

UE 动态获取 资源缩略图 下载到本地或返回图片信息

UE 动态加载资源缩略图 返回图片信息或保存到本地

qq_46080252的博客 1939

Adobe软件非正版弹窗终极解决方案:PS/Ai/PR/AE禁用提示一键清除指南

本文提供了Adobe软件非正版弹窗的终极解决方案,包括PS、Ai、PR、AE等软件的禁用提示一键清除指南。通过专业清理工具和手动修改系统文件的方法,帮助用户彻底解决Adobe弹窗问题,提升使用体验。适用于Windows和Mac系统用户,操作简单高效。

weixin_30872337的博客 5510

二叉树的遍历总结 Binary Tree Preorder, Inorder and Postorder Traversal

6-2 二叉树的递归遍历 Binary Tree Preorder, Inorder and Postorder Traversal 递归算法:执行一个函数时又去调用本身(内存中是重新执行这个函数,与去执行另一个函数一样),保存信息栈,然后去执行本身的新函数,以此类推,实质是栈的实现。 二叉树中的递归算法 二叉树的先序遍历 二叉树的中序遍历 二叉树的后序遍历 题目: LeetCode 144....

KAIKAI_ING的博客 610

Comsol实战:铌酸锂x切与z切参数设置全攻略(附电场强度归一化技巧)

本文详细介绍了在Comsol Multiphysics中设置铌酸锂x切与z切晶体参数的全流程,包括晶体取向定义、电光系数配置及关键光学参数计算。重点讲解了电场强度归一化这一实用技巧,帮助用户提升仿真分析效率,为设计电光调制器等集成光子器件提供精准的仿真基础。

year5的博客 584

直观理解三种遍历:preorder / inorder / postorder

在构造二叉树的题里,最常见的三种遍历是 preorder(先序)、inorder(中序)和 postorder(后序)。它们本质上都是 DFS,只是“在什么时候访问根节点”不一样:preorder 是根在前,inorder 是根在中间,postorder 是根在最后。具体来说:一个很容易产生的误区是:“postorder 是不是就是 preorder 反过来?”答案是否定的。只有在非常特殊的结构(例如每个节点只有一个孩子,整棵树退化成一条链)时,preorder 反过来看起来会和 postorder 很像,

六六哥的博客 1189

Python离线断网情况下安装numpy、pandas和matplotlib等常用第三方包

联网情况下在命令终端CMD中输入“pip install numpy”即可自动安装,pandas和matplotlib同理一样方法进行自动安装。 工作的电脑不能上外网,所以不能通过直接输入pip命令来安装。 环境:电脑上已经安装了Python(没有安装的请参考其他教程)。 Python离线断网情况下安装numpy、pandas和matplotlib等常用第三方包的步骤如下: ...

dayou7738的博客 4945

UNet改进(19):基于残差注意力模块Residual Attention的高效分割网络设计

本文提出一种结合注意力机制的改进UNet网络,通过引入残差注意力模块(ResidualAttentionBlock)增强医学图像分割性能。该网络在传统UNet的U型结构基础上,创新性地将轻量级注意力机制与残差连接相结合,在编码器-解码器各层级实现特征重标定。改进后的网络具有三方面优势:通过注意力机制自适应聚焦关键特征区域,利用残差连接缓解梯度消失问题,采用模块化设计灵活配置注意力位置。

2501_91516851的博客 786

PreOrder, InOrder, PostOrder 题型总结

Serialize and Deserialize BST 思路:用preorder来构建string,因为preorder知道第一个就是root,找到后面大于root的点,就是right tree,注意null,用stringbuilder构建string。Time : O(N) serialize, O(N^2) deserialize;因为要循去找比root大的,T(n) = O(n) +...

leetcode 解题思路 4380

从DDPM到DDIM:深入解读《Denoising Diffusion Implicit Models》

DDIM发表在ICRL2021上,是DDPM重要的改进之一,能显著提高DDPM的样本质量、减少采样时间,并且能显式控制插值,已经被广泛应用到现在的Diffusion Models上。这篇博客和大家一起详细解读一下DDIM,认识这一伟大的模型。.........

沉迷单车的追风少年 1万+

144. Binary Tree Preorder Traversal(94,145,前中后序三种遍历递归与非递归实现,统一模板)

https://leetcode.com/problems/binary-tree-preorder-traversal/ https://leetcode.com/problems/binary-tree-inorder-traversal/ https://leetcode.com/problems/binary-tree-postorder-traversal/ 算法思路:简单递归,或...

Young's Blog 266

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

【Leetcode】99. Recover Binary Search Tree( Morris 遍历)

题目地址: Recover Binary Search Tree 题意是一个二分查找树种的两个元素位置调换,在不改变结构的情况下,恢复这个树。 解法1; 根据平衡二叉树的性质,中跟遍历得到的应该是一个递增序列。 class Solution { public void recoverTree(TreeNode root) { List<Integer> vals...

a342500329a的专栏 457

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

leetcode 144. Binary Tree Preorder Traversal

Given a binary tree, return the preorder traversal of its nodes’ values. Example: Input: [1,null,2,3] 1 2 / 3 Output: [1,2,3] Follow up: Recursive solution is trivial, could you do it iteratively? 大意...

luoshaohong的博客 119

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

[leetcode] Binary Tree Preorder Traversal

/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Soluti

lydcsdn 540

LintCode 66: Binary Tree Preorder Traversal (二叉树遍历经典题!)

Binary Tree Preorder Traversal 中文English Given a binary tree, return the preorder traversal of its nodes’ values. Example Example 1: Input:{1,2,3} Output:[1,2,3] Explanation: 1 / 2 3 it will be s...

roufoo的博客 197

C++非递归二叉搜索树实现:从原理到工业级代码实践

二叉搜索树(BST)是一种基于节点与指针构建的经典数据结构,其核心原理是通过有序的二叉树结构实现高效的数据查找、插入与删除操作。在性能敏感的开发场景中,递归实现的BST可能因栈溢出风险与函数调用开销而受限,而非递归实现则通过循环与显式指针操作,提供了更稳定可控的性能表现。这种底层控制能力对于理解内存管理、指针操作以及构建更复杂的数据结构(如AVL树、红黑树)具有重要技术价值。在C++面试与系统级开发中,掌握非递归BST的实现是评估开发者对数据结构底层逻辑理解深度的重要标尺。本文将以C++模板化实现为例,深入

weixin_30781775的博客 418

二叉树的遍历(基于栈的非递归方式实现)

原文链接:二叉树的遍历(基于栈的非递归方式实现) 二叉树的遍历(基于栈的非递归方式实现) 注意:pop的顺序就是对应遍历的打印顺序。 在写二叉树的时候如果用递归实现二叉树的遍历很简单,但是用非递归来实现二叉树的遍历就不那么简单了需要一些技巧。 那为什么还要非递归实现呢?个人理解:如果树的高度很大,超过了允许递归的次数,那么就会出错,比如我记得python只允许递归100次(不知道记错没) ...

qq_29762941的博客 683

二叉树非递归遍历算法Binary Tree Traverse methods

/* Binary Tree Related Operations @author arhaiyun */ #include using namespace std; typedef int DataType; typedef struct BiTreeNode { DataType m_nValue; struct BiTreeNode m_pLe

arhaiyun的专栏 1040

二叉搜索树(Binary Search Tree)的递归和非递归代码实现(C++)

二叉搜索树简单介绍二叉搜索树(Binary Search Tree)是满足: 左子树的根节点比树的根节点小 右子树的根节点比树的根节点大 的二叉树。 由于这种数据结构具有很高的查询效率,故多用于需要索引的场合。

dawning 1518

Minimum Depth of Binary Tree

【题目描述】 Given a binary tree, find its minimum depth. The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node. 【思路】 一般这样的题目既可以用递归的方法也可

sadjuno的博客 233

007.Binary Tree

      本文给出基于C++完成的二叉树模板类以及它的测试主函数,主要具有二叉树的四种遍历算法的递归与非递归实现,同样,为了不重复造轮子,BinTree模板类给出了可以用来继承的多种接口,用来对日后实现红黑树,AVL,Trie树等数据结构的实现起到辅助作用,代码中大量使用宏,使得在主要的算法里面对函数的复杂调用得以简化,并且在实际执行的...

dosdiosas_的博客 296

二叉树的直径 diameter-of-binary-tree, BFS/DFS

* Tree.h // // Created by EDZ on 2021/4/2. // #ifndef DIAMETEROFTREE_TREE_H #define DIAMETEROFTREE_TREE_H #include "deque" //#ifndef max //#define max(a, b) ((a) > (b) ? (a) : (b)) //#endif template<class T> T max(T a, T b) { return a &..

fareast_mzh的博客 516

非递归二叉树遍历

算法导论:10.4-3 给定一个 n 二叉树结点,写一个 O(n) 非递归处理时间,树中的每个节点keyword出口。堆栈可以用作辅助数据结构。 堆栈实现参考这里。 #ifndef _BINARY_TREE_USE_STACK_H_ #define _BINARY_TREE_USE_STACK_H_ /************************************...

weixin_30763397的博客 74
上一篇: LintCode-95: Validate Binary Search Tree
下一篇: LintCode 433, LeetCode 200: Number of Islands (经典BFS/DFS/Union-Find)
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值