2021-10-16

第十七天

树练习题

有点难，全是递归，看吐了
二叉树的中序遍历

/**
 * 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:
    void inorder(TreeNode* root, vector<int>& res) {
        if (!root) {
            return;
        }
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        return res;
    }
};





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);
                root = root->left;
            }
            root = stk.top();
            stk.pop();
            res.push_back(root->val);
            root = root->right;
        }
        return res;
    }
};





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）递归，一开始看不太懂的，看了好一会发现确实还是有点简单的，第一个inorder是为了处理，第二个是直接调用得到结果，说一下inorder，第一开始如果root指向空值就直接返回了，没问题，下面先是左节点，一直一直往下走，走到最里面了，然后出去最里面那层，把叶对应的值放到res里面，外面是找右边的节点，并不是一直往右走，他还是会调用inorder这个功能，到底来说还是找右边那个节点对应的左儿子，就这样一直循环下去，然后在回来的过程中，到外面那一层，还是先放左儿子，再去找右边的，就是这么一个过程。
（2）迭代，栈。第二种是利用栈的方法。先去寻找左左左，并且把左节点依次压到栈里面，这也是一个搜索的顺序，一直到最左边的叶子哪里，这个值肯定是第一个访问到的，存下来，然后去寻找和这个有相同父亲的右儿子，但是要注意先把父节点存下来以后再去找具有相同父亲的右儿子，就这样不断循环，直到stack空掉。
（3）第三种注释很详细了。

第二天还得在做一下这个，用1，2方法。

二叉树的前序遍历

class Solution {
public:
    void preorder(TreeNode *root, vector<int> &res) {
        if (root == nullptr) {
            return;
        }
        res.push_back(root->val);
        preorder(root->left, res);
        preorder(root->right, res);
    }

    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> res;
        preorder(root, res);
        return res;
    }
};

我吐了，又给我套进去了，和上个差不多，没啥好说的了。

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty()){
            TreeNode* r=s.top();
            s.pop();
            if(!r) continue;
            ans.push_back(r->val);
            s.push(r->right);
            s.push(r->left);     
        }
        return ans;
    }
};

迭代方法。

看了一道ccf csp的题目，第二题
非零段查找
这里给一下索引，我深刻地意识到，我还差得远
答案索引