leetcode刷题笔记-树1

方便之后复习，记录一下leetcode上有关于树的几道题

先是树的前序遍历、中序遍历、和后序遍历
分别是leetcode上144、94、145
前序遍历就是先根结点 – 左子树 – 右子树
中序遍历就是左子树 – 根结点 – 右子树
后序遍历就是左子树 – 右子树 --根结点
代码：递归方法

 struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };

//前序遍历
 class Solution {
 public:
     vector<int> res;
     vector<int> preorderTraversal(TreeNode* root) {
         order(root);
         return res;

     }
     void order(TreeNode* root)
     {
         if (root == NULL)
         {
             return;
         }
         else
         {
             res.push_back(root->val);   //前序遍历 这里放在前面 因为根结点要先进来
             order(root->left);
             order(root->right);
         }
     }
 };

//中序遍历
class Solution {
public:
    vector<int> res;
    vector<int> inorderTraversal(TreeNode* root) {
        order(root);
        return res;
      


    }
    void order(TreeNode *root)
    {
        if (root == NULL)
        {
            return;
        }
        else
        {
            order(root->left);
            res.push_back(root->val); //中序遍历，这个放在这里 这样可以保证先左在根在右
            order(root->right);
        }
    }

};

//后序遍历
class Solution {
public:
    vector<int> res;
    vector<int> postorderTraversal(TreeNode* root) {
        order(root);
        return res;


    }
    void order(TreeNode* root)
    {
        if (root == NULL)
        {
            return;
        }
        else
        {
            order(root->left);
            order(root->right);
            res.push_back(root->val);  
        }
    }

};

这个可以找个例子 按照代码走一遍就明白了

然后是层序遍历
层序遍历主要是用bfs
但是bfs出来的结果没有把树的每一层分开
所以在再进一步做点处理
下边先写bfs在做一下处理

//BFS
 class Solution_bfs {
 public:
     vector<int> bfs(TreeNode* root) {

         vector<int> res;
         queue<TreeNode*> que;  //队列
         que.push(root);
         while (1)
         {
             if (que.empty())
             {
                 break;
             }
             auto node = que.front();
             res.push_back(node->val);
             que.pop();
             if (node->left != NULL)
             {
                 que.push(node->left);
             }
             if (node->right != NULL)
             {
                 que.push(node->right);
             }
         }
         return res;

     }
 };

 //加一个for循环 使每一次 一个层里面的都出来 而不是一个一个的出来
 
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        
        
        vector<vector<int>> ans;
        queue<TreeNode*> que;

        que.push(root);
        while (true)
        {
            vector<int> res;
            if (que.empty())
            {
                break;
            }
            auto n = que.size();
            //输出这层结果，并且把下一层节点放进que里面
            for (int i = 0; i < n; i++)
            {
                auto node = que.front();
                res.push_back(node->val);
                que.pop();
                if (node->left !=  NULL)
                {
                    que.push(node->left);
                }
                if (node->right != NULL)
                {
                    que.push(node->right);
                        
                }
            }
            ans.push_back(res);
        }

    }
};

leetcode 101：

/*
给定一个二叉树，检查它是否是镜像对称的。



例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
*/
/*
解析，深度优先搜索 左树的左节点和右树的右节点相等，左树的右节点和右树的左节点相等
*/
#include
#include



 struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };
 
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL)
        {
            return true;
        }
        else
        {
            return ismoirror(root->left,root->right);
        }
        

    }
    bool ismoirror(TreeNode *rootleft,TreeNode *rootright)
    {
        if (rootleft == NULL && rootright == NULL)
        {
            return true;
        }
        if ((rootleft == NULL && rootright != NULL) || (rootleft != NULL && rootright == NULL))
        {
            return false;
        }
        auto res = rootleft->val == rootright->val && ismoirror(rootleft->left, rootright->right) && ismoirror(rootleft->right,rootright->left);
        return res;
    }
};