深度学习迭代次数越多越好吗

转载

mob64ca141a2a87 2024-07-16 19:21:42

文章标签 深度学习迭代次数越多越好吗算法 leetcode 深度优先递归 文章分类 深度学习人工智能

前言

二叉树的遍历分为深度优先遍历和广度优先遍历
今天主要学习了深度优先遍历
最常用的办法就是采用递归法，递归法三要素：

确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

还有一种方法就是采用迭代法，用一个栈来不断遍历二叉树的节点，其实递归的底层实现也是栈。

前序遍历

1.递归法

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if(cur == nullptr) return;
        vec.push_back(cur->val); //中
        traversal(cur->left, vec); //左
        traversal(cur->right, vec); //右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

2.迭代法

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == nullptr) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top(); //处理的节点
            st.pop();
            result.push_back(node->val);
            //先把右节点压入栈中，再压入左节点，弹出时就先处理左节点
            if (node->right) st.push(node->right); 
            if (node->left) st.push(node->left);
        }
        return result;
    }
};

后序遍历

1.递归法

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if(cur == nullptr) return;
        traversal(cur->left, vec); //左
        traversal(cur->right, vec); //右
        vec.push_back(cur->val); //中
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

2. 迭代法

可以将前序遍历的左右节点入栈顺序交换一下，然后将结果数组反转

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> stk;
        vector<int> result;
        if (root == nullptr) return result;
        stk.push(root);
        while (!stk.empty()) {
            TreeNode* node = stk.top();
            stk.pop();
            result.push_back(node->val);
            if (node->left) stk.push(node->left);
            if (node->right) stk.push(node->right);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

中序遍历

1. 迭代法

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if(cur == nullptr) return;
        traversal(cur->left, vec); //左
        vec.push_back(cur->val); //中
        traversal(cur->right, vec); //右
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

2. 迭代法

中序遍历的迭代法不能像前面两种那样，因为处理的顺序是左-中-右，所以需要先将左子树遍历一遍，然后当左子树为空时，处理中节点，然后再处理右子树，如此循环

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        TreeNode* cur = root;
        while (cur != nullptr || !st.empty()) {
            if (cur != nullptr) { //遍历左节点
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                st.pop();
                result.push_back(cur->val); //处理中节点
                cur = cur->right;
            }
        }
        return result;
    }
};