Submission Week Five

week05/delete_node_in_a_linked_list.cpp

@@ -0,0 +1,8 @@
+// Time coplexity: O(1)
+// Space complexity: O(1);
+
+void deleteNode(ListNode* node){
+    ListNode* nextNode = node->next;
+    *(node) = *(node->next); // replacing value stored at node with value stored at node->next.
+    delete nextNode; 
+}

week05/design_linked_list.cpp

@@ -0,0 +1,67 @@
+// Time complexity: O(N) for adding an node or deleting an node at index where N is Number of elements in the list.
+// Space complexity: O(1)
+
+class MyLinkedLIst{
+public:
+    const static int DUMMYVALUE = INT_MIN;
+    class LinkedListNode{
+    public:
+        int value;
+        LinkedListNode* next;
+        LinkedListNode(int val, LinkedListNode* nxt){
+            value = val;
+            next = nxt;
+        }
+    };
+
+private:
+    LinkedListNode* head;
+    int listLength;
+
+public:
+    MyLinkedList(){
+        len = 0;
+        head = new LinkedListNode(DUMMYVALUE, NULL);
+    }
+
+    int get(int index){
+        if(index < 0 || index >= listLength) return -1;
+        LinkedListNode* currNode = head->next;
+        while(index--){
+            currNode = currNode->next;
+        }
+        return currNode->value;
+    }
+
+    void addAtHead(int val){
+        addAtIndex(0, val);
+    }
+
+    void addAtTail(int val){
+        addAtIndex(len, val);
+    }
+
+    void addAtIndex(int index, int val){
+        if(index < 0 || index > listLength) return;
+        LinkedListNode* currNode = head;
+        while(index--){
+            currNode = currNode->next;
+        }
+        LinkedListNode* nextToNewNode = currNode->next;
+        currNode->next = new LinkedListNode(val, NULL);
+        currNode->next->next = nextToNewNode;
+        listLength++;
+    }
+
+    void deleteAtIndex(int index){
+        if(index < 0 || index >= listLength) return;
+        LinkedListNode* currNode = head;
+        while(index--){
+            currNode = currNode->next;
+        }
+        LinkedListNode* dumpNode = currNode->next;
+        currNode->next = currNode->next->next;
+        delete(dumpNode);
+        listLength--;
+    }
+};

week05/linked_list_cycle.cpp

@@ -0,0 +1,14 @@
+// Time complexity: O(N), N is number of elements in the list.
+// Space complexity: O(1)
+
+bool hasCycle(ListNode* head){
+    if(head == NULL) return false;
+    ListNode* slow = head;
+    ListNode* fast = head;
+    while(fast->next && fast->next->next){
+        slow = slow->next;
+        fast = fast->next->next;
+        if(slow == fast) return true;
+    }
+    return false;
+}

week05/maximum_twin_sum_of_a_linked_list.cpp

@@ -0,0 +1,32 @@
+// Time complexity: O(N), N is number of nodes.
+// Space complexity: O(1).
+
+ListNode* reverseList(ListNode* head){
+    if(head == NULL) return head;
+    ListNode* currNode = head;
+    ListNode* prevNode = NULL;
+    while(currNode){
+        ListNode* nextNode = currNode->next;
+        currNode->next = prevNode;
+        prevNode = currNode;
+        currNode = nextNode;
+    }
+    return prevNode;
+}
+
+int pairSum(ListNode* head){
+    ListNode* slow = head;
+    ListNode* fast = head;
+    while(fast && fast->next){
+        slow = slow->next;
+        fast = fast->next->next;
+    }
+    slow = reverseList(slow);
+    int max_result = INT_MIN;
+    while(slow){
+        max_result = max(max_result, slow->val + head->val);
+        slow = slow->next;
+        head = head->next;
+    }
+    return max_result;
+}

week05/populating_next_right_pointers_in_each_node.cpp

@@ -0,0 +1,16 @@
+// Time complexity: O(N) , N is Number of Nodes.
+// Space complexity: O(1)
+
+void nodeTraverse(Node* node){
+    if(!node) return;
+    if(node->left) node->left->next = node->right;
+    if(node->right && node->next) node->right->next = node->next->left;
+
+    nodeTraverse(node->left);
+    nodeTraverse(node->right);
+}
+
+Node* connect(Node* root){
+    nodeTraverse(root);
+    return root;
+}

week05/remove_nth_node_from_end_of_list.cpp

@@ -0,0 +1,17 @@
+// Time complexity: O(N), N = number of nodes;
+// Space complexity: O(1);
+
+ListNode* removeNthFromEnd(ListNode* head, int n){
+    ListNode* currNode = head;
+    ListNode* dummyNode = head;
+    while(n--){
+        dummNode = dummyNode->next;
+    }
+    if(!dummyNode) return head->next;
+    while(dummyNode->next){
+        dummyNode = dummyNode->next;
+        currNode = currNode->next;
+    }
+    currNode->next = currNode->next->next;
+    return head;
+}

week05/reverse_linked_list.cpp

@@ -0,0 +1,15 @@
+// Time complexity: O(N), N = Number of nodes;
+// Space complexity: O(1).
+
+ListNode* reverseList(ListNode* head){
+    if(head == NULL) return head;
+    ListNode* currNode = head;
+    ListNode* prevNode = NULL;
+    while(currNode){
+        ListNode* nextNode = currNode->next;
+        currNode->next = prevNode;
+        prevNode = currNode;
+        currNode = nextNode;
+    }
+    return prevNode;
+}