ashnarayan13
diff --git a/‎hackerrank/CMakeLists.txt
Lines changed: 9 additions & 1 deletion b/‎hackerrank/CMakeLists.txt
Lines changed: 9 additions & 1 deletion
diff --git a/‎hackerrank/src/insert_node_dll.cpp
Lines changed: 177 additions & 0 deletions b/‎hackerrank/src/insert_node_dll.cpp
Lines changed: 177 additions & 0 deletions
diff --git a/‎hackerrank/src/merge_ll.cpp
Lines changed: 141 additions & 0 deletions b/‎hackerrank/src/merge_ll.cpp
Lines changed: 141 additions & 0 deletions
@@ -90,4 +90,12 @@ add_executable(insert-node-tail src/insert-node-tail.cpp)
 
 add_executable(array_manip src/array_manip.cpp)
 
-add_executable(attrib_parser src/attrib_parser.cpp)
+add_executable(attrib_parser src/attrib_parser.cpp)
+
+add_executable(merge_point src/merge_point.cpp)
+
+add_executable(insert_node_dll src/insert_node_dll.cpp)
+
+add_executable(reverse_dll src/reverse_dll.cpp)
+
+add_executable(merge_ll src/merge_ll.cpp)
@@ -0,0 +1,177 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class DoublyLinkedListNode {
+    public:
+        int data;
+        DoublyLinkedListNode *next;
+        DoublyLinkedListNode *prev;
+
+        DoublyLinkedListNode(int node_data) {
+            this->data = node_data;
+            this->next = nullptr;
+            this->prev = nullptr;
+        }
+};
+
+class DoublyLinkedList {
+    public:
+        DoublyLinkedListNode *head;
+        DoublyLinkedListNode *tail;
+
+        DoublyLinkedList() {
+            this->head = nullptr;
+            this->tail = nullptr;
+        }
+
+        void insert_node(int node_data) {
+            DoublyLinkedListNode* node = new DoublyLinkedListNode(node_data);
+
+            if (!this->head) {
+                this->head = node;
+            } else {
+                this->tail->next = node;
+                node->prev = this->tail;
+            }
+
+            this->tail = node;
+        }
+};
+
+void print_doubly_linked_list(DoublyLinkedListNode* node, string sep, ofstream& fout) {
+    while (node) {
+        cout << node->data;
+
+        node = node->next;
+
+        if (node) {
+            cout << sep;
+        }
+    }
+}
+
+void free_doubly_linked_list(DoublyLinkedListNode* node) {
+    while (node) {
+        DoublyLinkedListNode* temp = node;
+        node = node->next;
+
+        free(temp);
+    }
+}
+
+// Complete the sortedInsert function below.
+
+/*
+ * For your reference:
+ *
+ * DoublyLinkedListNode {
+ *     int data;
+ *     DoublyLinkedListNode* next;
+ *     DoublyLinkedListNode* prev;
+ * };
+ *
+ */
+DoublyLinkedListNode* sortedInsert(DoublyLinkedListNode* head, int data) {
+
+    DoublyLinkedListNode* newNode = new DoublyLinkedListNode(data);
+    bool filled = false;
+    while(head != NULL)
+    {
+        if(data<head->data)
+        {
+            DoublyLinkedListNode* tempNewNode = head;
+            newNode->next = head;
+            newNode->prev = head->prev;
+            if(head->prev != NULL)
+            {
+                head->prev->next = newNode;
+            }
+            head->prev = newNode;
+            filled = true;
+            break;
+        }
+        else
+        {
+            if(head->next == NULL)
+            {
+                break;
+            }
+            head = head->next;
+        }
+    }
+    if(!filled)
+    {
+        // Add at the end
+        // We should be at the last element
+        head->next = newNode;
+        newNode->prev = head;
+    }
+    // Now need to back iterate till we reach start
+    while(head->prev != NULL)
+    {
+        head = head->prev;
+    }
+    return head;
+    /*
+    DoublyLinkedListNode* newNode = new DoublyLinkedListNode(data);
+    if(head == NULL)
+    {
+        return newNode;
+    }
+    else if(data<head->data)
+    {
+        cout<<"Here \n";
+        newNode->next = head;
+        head->prev = newNode;
+        return newNode;
+    }
+    else {
+        cout<<"No here\n";
+        DoublyLinkedListNode* tempNode = sortedInsert(head->next, data);
+        cout<<tempNode->data<<endl;
+        head->next = tempNode;
+        tempNode->prev = head;
+        return head;
+    }*/
+}
+
+int main()
+{
+    ofstream fout(getenv("OUTPUT_PATH"));
+
+    int t;
+    cin >> t;
+    cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+    for (int t_itr = 0; t_itr < t; t_itr++) {
+        DoublyLinkedList* llist = new DoublyLinkedList();
+
+        int llist_count;
+        cin >> llist_count;
+        cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+        for (int i = 0; i < llist_count; i++) {
+            int llist_item;
+            cin >> llist_item;
+            cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+            llist->insert_node(llist_item);
+        }
+
+        int data;
+        cin >> data;
+        cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+        DoublyLinkedListNode* llist1 = sortedInsert(llist->head, data);
+
+        print_doubly_linked_list(llist1, " ", fout);
+        fout << "\n";
+
+        free_doubly_linked_list(llist1);
+    }
+
+    fout.close();
+
+    return 0;
+}
@@ -0,0 +1,141 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class SinglyLinkedListNode {
+    public:
+        int data;
+        SinglyLinkedListNode *next;
+
+        SinglyLinkedListNode(int node_data) {
+            this->data = node_data;
+            this->next = nullptr;
+        }
+};
+
+class SinglyLinkedList {
+    public:
+        SinglyLinkedListNode *head;
+        SinglyLinkedListNode *tail;
+
+        SinglyLinkedList() {
+            this->head = nullptr;
+            this->tail = nullptr;
+        }
+
+        void insert_node(int node_data) {
+            SinglyLinkedListNode* node = new SinglyLinkedListNode(node_data);
+
+            if (!this->head) {
+                this->head = node;
+            } else {
+                this->tail->next = node;
+            }
+
+            this->tail = node;
+        }
+};
+
+void print_singly_linked_list(SinglyLinkedListNode* node, string sep, ofstream& fout) {
+    while (node) {
+        fout << node->data;
+
+        node = node->next;
+
+        if (node) {
+            fout << sep;
+        }
+    }
+}
+
+void free_singly_linked_list(SinglyLinkedListNode* node) {
+    while (node) {
+        SinglyLinkedListNode* temp = node;
+        node = node->next;
+
+        free(temp);
+    }
+}
+
+// Complete the mergeLists function below.
+/*
+ * For your reference:
+ *
+ * SinglyLinkedListNode {
+ *     int data;
+ *     SinglyLinkedListNode* next;
+ * };
+ *
+ */
+
+SinglyLinkedListNode* mergeLists(SinglyLinkedListNode* head1, SinglyLinkedListNode* head2) {
+    vector<int> data;
+    while(head1 != NULL)
+    {
+        data.push_back(head1->data);
+        head1 = head1->next;
+    }
+    while(head2 != NULL)
+    {
+        data.push_back(head2->data);
+        head2 = head2->next;
+    }
+    
+    sort(data.begin(), data.end());
+    SinglyLinkedList* newList = new SinglyLinkedList();
+    for(int vals : data)
+    {
+        newList->insert_node(vals);
+    }
+    return newList->head;
+}
+
+int main()
+{
+    ofstream fout(getenv("OUTPUT_PATH"));
+
+    int tests;
+    cin >> tests;
+    cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+    for (int tests_itr = 0; tests_itr < tests; tests_itr++) {
+        SinglyLinkedList* llist1 = new SinglyLinkedList();
+
+        int llist1_count;
+        cin >> llist1_count;
+        cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+        for (int i = 0; i < llist1_count; i++) {
+            int llist1_item;
+            cin >> llist1_item;
+            cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+            llist1->insert_node(llist1_item);
+        }
+      
+      	SinglyLinkedList* llist2 = new SinglyLinkedList();
+
+        int llist2_count;
+        cin >> llist2_count;
+        cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+        for (int i = 0; i < llist2_count; i++) {
+            int llist2_item;
+            cin >> llist2_item;
+            cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+            llist2->insert_node(llist2_item);
+        }
+
+        SinglyLinkedListNode* llist3 = mergeLists(llist1->head, llist2->head);
+
+        print_singly_linked_list(llist3, " ", fout);
+        fout << "\n";
+
+        free_singly_linked_list(llist3);
+    }
+
+    fout.close();
+
+    return 0;
+}