add Day9

Jongeun/Day9/110_BalancedBinaryTree.cpp

@@ -0,0 +1,40 @@
+/**
+ * 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:
+    bool isBalanced(TreeNode *root)
+    {
+        _isBalanced(root);
+        return IsBalanced;
+    }
+
+    int _isBalanced(TreeNode *node)
+    {
+        if (node == nullptr)
+        {
+            return 0;
+        }
+
+        int left = _isBalanced(node->left);
+        int right = _isBalanced(node->right);
+
+        if (abs(left - right) > 1)
+        {
+            IsBalanced = false;
+        }
+        return 1 + max(left, right);
+    }
+
+private:
+    bool IsBalanced = true;
+};

Jongeun/Day9/239_SlidingWindowMaximum.cpp

@@ -0,0 +1,36 @@
+class Solution
+{
+public:
+    vector<int> maxSlidingWindow(vector<int> &nums, int k)
+    {
+
+        int l = 0;
+        int r = 0;
+        deque<int> dq;
+        vector<int> maxWindow;
+
+        while (r < nums.size())
+        {
+            while (!dq.empty() && nums[dq.back()] <= nums[r])
+            {
+                dq.pop_back();
+            }
+
+            dq.emplace_back(r);
+
+            if (l > dq.front())
+            {
+                dq.pop_front();
+            }
+
+            if (r + 1 >= k)
+            {
+                maxWindow.push_back(nums[dq.front()]);
+                l++;
+            }
+            r++;
+        }
+
+        return maxWindow;
+    }
+};

Jongeun/Day9/543_DiameterofBinaryTree.cpp

@@ -0,0 +1,65 @@
+#include <iostream>
+
+using namespace std;
+
+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:
+    int diameterOfBinaryTree(TreeNode *root)
+    {
+
+        int tempt = _diameterOfBinaryTree(root);
+        return diameter;
+    }
+
+    int _diameterOfBinaryTree(TreeNode *node)
+    {
+        if (node == nullptr)
+        {
+            return 0;
+        }
+
+        int left = 0, right = 0;
+        if (node->left != nullptr)
+        {
+            left = 1 + diameterOfBinaryTree(node->left);
+        }
+        if (node->right != nullptr)
+        {
+            right = 1 + diameterOfBinaryTree(node->right);
+        }
+
+        int diameter1 = left + right;
+        if (diameter < diameter1)
+        {
+            diameter = diameter1;
+        }
+        return max(left, right);
+    }
+
+private:
+    int diameter{0};
+};
+
+int main()
+{
+    Solution diameterOfBinaryTree;
+    TreeNode *root = new TreeNode(1);
+    root->left = new TreeNode(2);
+    root->right = new TreeNode(3);
+    root->left->left = new TreeNode(4);
+    root->left->right = new TreeNode(5);
+
+    cout << diameterOfBinaryTree.diameterOfBinaryTree(root) << endl;
+    return 0;
+}