Added one Linked list and one greedy problem

Author: version0chiro

Data Structures/Linked Lists/segregate_even and_odd_nodes_LL.cpp

@@ -0,0 +1,113 @@
+/*
+Given a link list of size N, modify the list such that all the even numbers appear before all the
+odd numbers in the modified list.
+The order of appearance of numbers within each segregation should be same as that in the original list.
+
+Example 1:
+
+Input: 
+N = 7
+Linked List = 
+17 -> 15 -> 8 -> 9 -> 2 -> 4 -> 6 -> NULL
+
+Output: 8 2 4 6 17 15 9
+
+Example 2:
+
+Input:
+N = 4
+Linked List = 1 -> 3 -> 5 -> 7
+
+Output: 1 3 5 7
+
+*/
+
+// { Driver Code Starts
+//Initial template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Node
+{
+    int data;
+    struct Node* next;
+    
+    Node(int x){
+        data = x;
+        next = NULL;
+    }
+};
+void printList(Node* node) 
+{ 
+    while (node != NULL) { 
+        cout << node->data <<" "; 
+        node = node->next; 
+    }  
+    cout<<"\n";
+} 
+
+
+/*
+Method followed:
+- Use to queues to store even and odd data containing nodes of the List.
+- Traverse the LL and populates the queues
+- Re-Traverse the Ll emptying the even queue first followed by odd one.
+- return head 
+*/
+class Solution{
+public:
+    Node* divide(int N, Node *head){
+        queue<int> odd;
+        queue<int> even;
+        Node* curr = head;
+        Node* curr2 = head;
+        while(curr){
+            if(curr->data%2==0){
+                even.push(curr->data);
+            }else{
+                odd.push(curr->data);
+            }
+            curr=curr->next;
+        }
+        
+        while(!even.empty()){
+            curr2->data=even.front();
+            curr2=curr2->next;
+            even.pop();
+        }
+        while(!odd.empty()){
+            curr2->data=odd.front();
+            curr2=curr2->next;
+            odd.pop();
+        }
+        return head;
+    }
+};
+
+
+
+int main() {
+    
+    int t;
+    cin>>t;
+    while(t--){
+        int N;
+        cin>>N;
+        int data;
+        cin>>data;
+        struct Node *head = new Node(data);
+        struct Node *tail = head;
+        for (int i = 0; i < N-1; ++i)
+        {
+            cin>>data;
+            tail->next = new Node(data);
+            tail = tail->next;
+        }
+        
+        Solution ob;
+        Node *ans = ob.divide(N, head);
+        printList(ans); 
+    }
+    return 0;
+}

Greedy/n_meetings_in_a_room.cpp

@@ -0,0 +1,85 @@
+/*
+There is one meeting room in a firm.
+There are N meetings in the form of (S[i], F[i]) where S[i] is 
+start time of meeting i and F[i] is finish time of meeting i.
+
+What is the maximum number of meetings that can be accommodated in the meeting room 
+when only one meeting can be held in the meeting room at a particular time?
+
+Also note start time of one chosen meeting can't be equal to the end time of the other chosen meeting.
+*/
+
+
+
+#include <bits/stdc++.h>
+using namespace std;
+
+
+
+/* 
+Method followed:
+- make a vector of pair of meeting's start and end time
+- sort this vector with respect to the end time
+- count the first meeting and set time limit as the end of first meeting
+- traverse the vector
+    - if start time of any meeting is greater than time limit.
+        - increment count
+        - set time limit as end time of this meeting
+
+*/
+class Solution
+{
+    public:
+    static bool comp(pair<int,int> a,pair<int,int> b){
+        if(a.second<b.second){
+            return true;
+        }
+        return false;
+        
+    }
+    int maxMeetings(int start[], int end[], int n)
+    {
+        vector<pair<int,int>> m;
+        for(int i=0;i<n;i++){
+            m.push_back(make_pair(start[i],end[i]));
+        }
+        
+        sort(m.begin(),m.end(),comp);
+        
+        
+        
+        int currMeet=m[0].first;
+        
+        int timeLimit = m[0].second;
+        
+        int count=1;
+        
+        for(int i=1;i<n;i++){
+            auto a=m[i];
+            if(a.first>timeLimit){
+                count++;
+                timeLimit=a.second;
+            }
+        }
+        
+        return count;
+    }
+};
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+        int start[n], end[n];
+        for (int i = 0; i < n; i++) cin >> start[i];
+
+        for (int i = 0; i < n; i++) cin >> end[i];
+
+        Solution ob;
+        int ans = ob.maxMeetings(start, end, n);
+        cout << ans << endl;
+    }
+    return 0;
+}