算法练习：二叉树

102：二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>>arr1;
        queue<TreeNode*>queue;
        if(root!=nullptr){queue.push(root);}
        while(!queue.empty())
        {
            int size = queue.size();
            vector<int>arr2;
            for(int i = 0;i<size;i++)
            {
                TreeNode* ptr = queue.front();
                arr2.push_back(ptr->val);
                queue.pop();
                if(ptr->left != nullptr)
                {
                    queue.push(ptr->left);
                }
                if(ptr->right != nullptr)
                {
                    queue.push(ptr->right);
                }
            }
            arr1.push_back(arr2);
        }
        return arr1;
    }
};

226:翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*>queue;
        if(root!=nullptr){queue.push(root);}
        while(!queue.empty())
        {
                TreeNode* ptr = queue.front();
                if(ptr->left != nullptr)
                {
                    queue.push(ptr->left);
                }
                if(ptr->right != nullptr)
                {
                    queue.push(ptr->right);
                }
                TreeNode * tmp = ptr->left;
                ptr->left = ptr->right;
                ptr->right = tmp;
                queue.pop();
        }
        return root;
    }
};

101:对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

class Solution {
public:
    TreeNode * fanzhuan(TreeNode * root)
    {
        
        queue<TreeNode*>qu1;
        if(root!=nullptr){qu1.push(root);}
        while(!qu1.empty())
        {
            TreeNode* ptr = qu1.front();
            qu1.pop();
            if(ptr->left != nullptr)
            {
                qu1.push(ptr->left);
            }
            if(ptr->right != nullptr)
            {
                qu1.push(ptr->right);
            }
            TreeNode* tmp = ptr->left;
            ptr->left = ptr->right;
            ptr->right = tmp;
        }
        return root;
    }
bool isSame(TreeNode* p, TreeNode* q) 
    {

	if (p == NULL && q == NULL) {
		return true;
	}
	if (p == NULL || q == NULL) {
		return false;
	}
	return p->val == q->val&&
		isSame(p->left, q->left) &&
		isSame(p->right, q->right);
    }
    bool isSymmetric(TreeNode* root) {
        fanzhuan(root->right);
        return isSame(root->left,root->right);
    }
};

104:二叉树的最大深度

给定一个二叉树，找出其最大深度。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int dep = 0;
        queue<TreeNode*>queue;
        if(root!=nullptr){queue.push(root);}
        while(!queue.empty())
        {
            int size = queue.size();
            for(int i = 0;i<size;i++)
            {
                TreeNode* ptr = queue.front();
                queue.pop();
                if(ptr->left != nullptr)
                {
                    queue.push(ptr->left);
                }
                if(ptr->right != nullptr)
                {
                    queue.push(ptr->right);
                }
            }
            dep++;
        }
        return dep;
    }
};

111.二叉树的最小深度

给定一个二叉树，找出其最小深度。

class Solution {
public:
    int minDepth(TreeNode* root) {
        int deap = 0;
        if(root == nullptr)
        {
            return deap;
        }
        queue<TreeNode*>qu;
        qu.push(root);
        deap += 1;
        while(!qu.empty())
        {
            int size = qu.size();
            for(int i = 0;i<size;i++)
            {
                TreeNode * ptr = qu.front();
                qu.pop();
                if(ptr->left == nullptr && ptr->right == nullptr)
                {
                    return deap;
                }
                else
                {
                    if (ptr->left) qu.push(ptr->left);
                    if (ptr->right) qu.push(ptr->right);
                }
              }
            deap++;
        }
        return deap;
    }
};

222:完全二叉树节点个数

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root == nullptr){return 0;}
        int sum = 0;
        queue<TreeNode*>qu;
        qu.push(root);
        while(!qu.empty())
        {
            int size = qu.size();
            for(int i = 0;i<size;i++)
            {
                TreeNode * ptr = qu.front();
                qu.pop();
                sum++;
                if(ptr->left){qu.push(ptr->left);}
                if(ptr->right){qu.push(ptr->right);}
            }
        }
        return sum;
    }
};

110.平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

class Solution {
public:
     int getHeight(TreeNode *root)
     {
         if(root == nullptr) return 0;
         int leftHeight = getHeight(root->left);
         if (leftHeight == -1) return -1;
         int rightHeight = getHeight(root->right);
         if (rightHeight == -1) return -1;
         return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight);
     }
    bool isBalanced(TreeNode* root) {
        return (getHeight(root) == -1 ? false : true);
    }
};

257.二叉树的所有路径之和

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

class Solution {
public:
    void fun(TreeNode*root,vector<int>&ar1,vector<string>&ar2)
    {
        ar1.push_back(root->val);
        if(root->left == nullptr && root->right == nullptr) 
        {
            string str;
            for(int i = 0;i<ar1.size()-1;++i)
            {
                str += to_string(ar1[i]);
                str += "->";
            }
            str += to_string(ar1[ar1.size() -1]);
            ar2.push_back(str);
            return;
        }
        if(root->left)
        {
            fun(root->left,ar1,ar2);
             ar1.pop_back();
        };
        if(root->right)
        {
            fun(root->right,ar1,ar2);
             ar1.pop_back();
        };
        return;
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string>ar2;
        vector<int>ar1;
        fun(root,ar1,ar2);
        return ar2;
    }
};

404.左叶子之和

给定二叉树的根节点 root ，返回所有左叶子之和。

class Solution {
public:

    int sumOfLeftLeaves(TreeNode* root) {
        if(root == nullptr) return 0;
        int sum1 = sumOfLeftLeaves(root->left);
        if(root->left != nullptr && root->left->left == nullptr && root->left->right == nullptr)
        {
            sum1 = root->left->val;
        }
        int sum2 = sumOfLeftLeaves(root->right);
        
        return sum1+sum2;

    }
};

513.找树左下角的值

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*>qu;
        if(root == nullptr) return 0;
        qu.push(root);
        int result = 0;
        while(!qu.empty())
        {
            int size = qu.size()
;            for(int i = 0;i<size;i++)
            {
                TreeNode *ptr = qu.front();
                qu.pop();
                if(i == 0) result = ptr->val;
                if(ptr->left != nullptr) qu.push(ptr -> left);
                if(ptr->right != nullptr)qu.push(ptr->right);
            }
        }
        return result;
    }
};

112.路经总和

class Solution {
public:
    bool travel(TreeNode *root,int sum)
    {
        if(!root->left && !root->right && sum == 0) return true;
        if(!root->left && !root->right) return false;
        if(root->left)
        {
            sum -= root->left->val;
            if(travel(root->left,sum)) return true;
            sum += root->left->val;
        }
        if(root->right)
        {
            sum -= root->right->val;
            if(travel(root->right,sum)) return true;
            sum += root->right->val;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr){return false;}
        return travel(root,targetSum-root->val);

    }
};