add Day11

Jongeun/Day11/102_BinaryTreeLevelOrderTraversal.cpp

@@ -0,0 +1,57 @@
+/**
+ * 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:
+    vector<vector<int>> levelOrder(TreeNode *root)
+    {
+        deque<pair<TreeNode *, int>> nodes;
+        vector<vector<int>> levelOrder;
+
+        pair<TreeNode *, int> first = make_pair(root, 0);
+        nodes.emplace_back(first);
+        while (!nodes.empty())
+        {
+            auto cur = nodes.front();
+            nodes.pop_front();
+            if (cur.first != nullptr)
+            {
+                if (cur.second < levelOrder.size())
+                {
+                    levelOrder[cur.second].push_back(cur.first->val);
+                }
+                else
+                {
+                    vector<int> t1;
+                    t1.push_back(cur.first->val);
+                    levelOrder.push_back(t1);
+                }
+
+                // insert childs
+                pair<TreeNode *, int> tempt;
+                if (cur.first->left != nullptr)
+                {
+                    tempt = make_pair(cur.first->left, cur.second + 1);
+                    nodes.emplace_back(tempt);
+                }
+
+                if (cur.first->right != nullptr)
+                {
+                    tempt = make_pair(cur.first->right, cur.second + 1);
+                    nodes.emplace_back(tempt);
+                }
+            }
+        }
+
+        return levelOrder;
+    }
+};

Jongeun/Day11/235_LowestCommonAncestorofaBinarySearchTree.cpp

@@ -0,0 +1,79 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    TreeNode *lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q)
+    {
+        vector<TreeNode *> ancestors;
+
+        HasChilds(root, p, q, ancestors);
+        return ancestors.front();
+    }
+
+    int HasChilds(TreeNode *node, TreeNode *p, TreeNode *q, vector<TreeNode *> &ac)
+    {
+        if (node != nullptr)
+        {
+            int curFound = 0;
+            if (node->val == p->val || node->val == q->val)
+            {
+                curFound++;
+            }
+
+            int check;
+            if (node->left == nullptr && node->right == nullptr)
+            {
+                return curFound;
+            }
+            else if (node->left == nullptr)
+            {
+                check = HasChilds(node->right, p, q, ac);
+            }
+            else if (node->right == nullptr)
+            {
+                check = HasChilds(node->left, p, q, ac);
+            }
+            else
+            {
+                check = HasChilds(node->left, p, q, ac) + HasChilds(node->right, p, q, ac);
+            }
+
+            if (curFound + check == 2)
+            {
+                ac.push_back(node);
+            }
+        }
+        return 0;
+    }
+};
+
+int main()
+{
+    TreeNode *root = new TreeNode(6);
+    root->left = new TreeNode(2);
+    root->right = new TreeNode(8);
+    root->left->left = new TreeNode(0);
+    root->left->right = new TreeNode(4);
+    root->right->left = new TreeNode(7);
+    root->right->right = new TreeNode(9);
+    root->left->right->left = new TreeNode(3);
+    root->left->right->right = new TreeNode(5);
+
+    Solution s;
+    TreeNode *p = root->left;
+    TreeNode *q = root->left->right;
+    TreeNode *lca = s.lowestCommonAncestor(root, p, q);
+    cout << lca->val << endl;
+    return 0;
+}

Jongeun/Day11/25_ReverseNodesinkGroup.cpp

@@ -0,0 +1,71 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution
+{
+public:
+    ListNode *reverseKGroup(ListNode *head, int k)
+    {
+
+        ListNode *cur = head;
+        ListNode *initFront = new ListNode();
+        ListNode *resultHead = initFront;
+
+        while (cur != nullptr)
+        {
+            int i{0};
+            ListNode *init = cur; // store the current node
+
+            while (i < k - 1)
+            {
+                // check if it has sufficient k nodes
+                cur = cur->next;
+                if (cur == nullptr)
+                {
+                    // end of the list
+                    break;
+                }
+                i++;
+            }
+
+            if (i == k - 1)
+            {
+                // k node exists -> 1 step move further
+                cur = cur->next;
+                // reverse k nodes
+                ListNode *cur2 = init;
+                ListNode *pre = cur;
+                for (int j = 0; j < k; j++)
+                {
+                    ListNode *tempt = cur2->next;
+                    cur2->next = pre;
+                    pre = cur2;
+                    cur2 = tempt;
+                }
+
+                // connect back
+                init->next = cur;
+                // connext front
+                initFront->next = pre;
+                // move initfront
+                for (int j = 0; j < k; j++)
+                {
+                    initFront = initFront->next;
+                }
+            }
+            else
+            { // reach the end of the nodes
+                break;
+            }
+        }
+
+        return resultHead->next;
+    }
+};