Merge pull request ByteByteGoHq#10 from ongshunping/cpp-solutions-linked-lists

Add C++ solutions for Chapter 3 (Linked Lists)

Author: Destiny-02

cpp/Linked Lists/flatten_multi_level_list.cpp

@@ -0,0 +1,38 @@
+/**
+ * Definition of MultiLevelListNode:
+ * class MultiLevelListNode {
+ * public:
+ *     int val;
+ *     MultiLevelListNode* next;
+ *     MultiLevelListNode* child;
+ *     MultiLevelListNode(int val = 0, MultiLevelListNode* next = nullptr, MultiLevelListNode* child = nullptr)
+ *         : val(val), next(next), child(child) {}
+ * };
+ */
+
+MultiLevelListNode* flattenMultiLevelList(MultiLevelListNode* head) {
+    if (!head) {
+        return nullptr;
+    }
+    MultiLevelListNode* tail = head;
+    // Find the tail of the linked list at the first level.
+    while (tail->next) {
+        tail = tail->next;
+    }
+    MultiLevelListNode* curr = head;
+    // Process each node at the current level. If a node has a child linked list,
+    // append it to the tail and then update the tail to the end of the extended 
+    // linked list. Continue until all nodes at the current level are processed.
+    while (curr) {
+        if (curr->child) {
+            tail->next = curr->child;
+            // Disconnect the child linked list from the current node.
+            curr->child = nullptr;
+            while (tail->next) {
+                tail = tail->next;
+            }
+        }
+        curr = curr->next;
+    }
+    return head;
+}

cpp/Linked Lists/linked_list_intersection.cpp

@@ -0,0 +1,35 @@
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+ListNode* linkedListIntersection(ListNode* head_A, ListNode* head_B) {
+    ListNode* ptr_A = head_A;
+    ListNode* ptr_B = head_B;
+    // Traverse through list A with 'ptr_A' and list B with 'ptr_B' 
+    // until they meet.
+    while (ptr_A != ptr_B) {
+        // Traverse list A -> list B by first traversing 'ptr_A' and 
+        // then, upon reaching the end of list A, continue the 
+        // traversal from the head of list B.
+        if (ptr_A != nullptr) {
+            ptr_A = ptr_A->next;
+        } else {
+            ptr_A = head_B;
+        }
+        // Simultaneously, traverse list B -> list A.
+        if (ptr_B != nullptr) {
+            ptr_B = ptr_B->next;
+        } else {
+            ptr_B = head_A;
+        }
+    }
+    // At this point, 'ptr_A' and 'ptr_B' either point to the 
+    // intersection node or both are null if the lists do not 
+    // intersect. Return either pointer.
+    return ptr_A;  
+}

cpp/Linked Lists/linked_list_reversal.cpp

@@ -0,0 +1,24 @@
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+ListNode* linkedListReversal(ListNode* head) {
+    ListNode* currNode = head;      
+    ListNode* prevNode = nullptr;   
+    // Reverse the direction of each node's pointer until 'currNode' 
+    // is null.
+    while (currNode != nullptr) {
+        ListNode* nextNode = currNode->next;  
+        currNode->next = prevNode;            
+        prevNode = currNode;                 
+        currNode = nextNode;                  
+    }
+    // 'prevNode' will be pointing at the head of the reversed linked 
+    // list.
+    return prevNode;
+}

cpp/Linked Lists/linked_list_reversal_recursive.cpp

@@ -0,0 +1,22 @@
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+ListNode* linkedListReversalRecursive(ListNode* head) {
+    // Base cases.
+    if (head == nullptr || head->next == nullptr) {
+        return head;
+    }
+    // Recursively reverse the sublist starting from the next node.
+    ListNode* newHead = linkedListReversalRecursive(head->next);
+    // Connect the reversed linked list to the head node to fully
+    // reverse the entire linked list.
+    head->next->next = head; 
+    head->next = nullptr;   
+    return newHead;
+}

cpp/Linked Lists/lru_cache.cpp

@@ -0,0 +1,88 @@
+#include <unordered_map>
+
+class DoublyLinkedListNode {
+public:
+    int key;
+    int val;
+    DoublyLinkedListNode* prev;
+    DoublyLinkedListNode* next;
+    DoublyLinkedListNode(int key, int val)
+        : key(key), val(val), prev(nullptr), next(nullptr) {}
+};
+
+class LRUCache {
+public:
+    int capacity;
+    // A hash map that maps keys to nodes.
+    std::unordered_map<int, DoublyLinkedListNode*> hashmap;
+    // Initialize the head and tail dummy nodes and connect them to 
+    // each other to establish a basic two-node doubly linked list.
+    DoublyLinkedListNode* head;
+    DoublyLinkedListNode* tail;
+    LRUCache(int capacity) : capacity(capacity) {
+        head = new DoublyLinkedListNode(-1, -1);
+        tail = new DoublyLinkedListNode(-1, -1);
+        head->next = tail;
+        tail->prev = head;
+    }
+    // Destructor: Cleans up dynamically allocated resources 
+    // to prevent memory leaks. Implemented if time permits 
+    // during an interview.
+    ~LRUCache() {
+        // Delete all nodes in the linked list. 
+        DoublyLinkedListNode* current = head;
+        while (current != nullptr) {
+            DoublyLinkedListNode* nextNode = current->next;
+            delete current;
+            current = nextNode;
+        }
+        // Clear the hashmap. 
+        hashmap.clear();
+    }
+
+    int get(int key) {
+        if (hashmap.find(key) == hashmap.end()) {
+            return -1;
+        }
+        // To make this key the most recently used, remove its node and 
+        // re-add it to the tail of the linked list. 
+        removeNode(hashmap[key]);
+        addToTail(hashmap[key]);
+        return hashmap[key]->val;
+    }
+
+    void put(int key, int val) {
+        // If a node with this key already exists, remove it from the 
+        // linked list.
+        if (hashmap.find(key) != hashmap.end()) {
+            DoublyLinkedListNode* existingNode = hashmap[key];
+            removeNode(existingNode);
+            delete existingNode;
+            hashmap.erase(key);
+        }
+        DoublyLinkedListNode* node = new DoublyLinkedListNode(key, val);
+        hashmap[key] = node;
+        // Remove the least recently used node from the cache if adding 
+        // this new node will result in an overflow.
+        if (hashmap.size() > capacity) {
+            DoublyLinkedListNode* lruNode = head->next;
+            hashmap.erase(lruNode->key);
+            removeNode(lruNode);
+            delete lruNode;
+        }
+        addToTail(node);
+    }
+
+    void addToTail(DoublyLinkedListNode* node) {
+        DoublyLinkedListNode* prevNode = tail->prev;
+        node->prev = prevNode;
+        node->next = tail;
+        prevNode->next = node; 
+        tail->prev = node; 
+    }
+
+    void removeNode(DoublyLinkedListNode* node) {
+        node->prev->next = node->next;
+        node->next->prev = node->prev;
+    }
+};

cpp/Linked Lists/palindromic_linked_list.cpp

@@ -0,0 +1,56 @@
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+// Function prototypes
+ListNode* findMiddle(ListNode* head);
+ListNode* reverseList(ListNode* head);
+bool palindromicLinkedList(ListNode* head);
+
+bool palindromicLinkedList(ListNode* head) {
+    // Find the middle of the linked list and then reverse the second half of the
+    // linked list starting at this midpoint.
+    ListNode* mid = findMiddle(head);
+    ListNode* secondHead = reverseList(mid);
+    // Compare the first half and the reversed second half of the list
+    ListNode* ptr1 = head;
+    ListNode* ptr2 = secondHead;
+    bool res = true;
+    while (ptr2) {
+        if (ptr1->val != ptr2->val) {
+            res = false;
+        }
+        ptr1 = ptr1->next;
+        ptr2 = ptr2->next;
+    }
+    return res;
+}
+
+// From the 'Reverse Linked List' problem.
+ListNode* reverseList(ListNode* head) {
+    ListNode* prevNode = nullptr;
+    ListNode* currNode = head;
+    while (currNode) {
+        ListNode* nextNode = currNode->next;
+        currNode->next = prevNode;
+        prevNode = currNode;
+        currNode = nextNode;
+    }
+    return prevNode;
+}
+
+// From the 'Linked List Midpoint' problem.
+ListNode* findMiddle(ListNode* head) {
+    ListNode* slow = head;
+    ListNode* fast = head;
+    while (fast != nullptr && fast->next != nullptr) {
+        slow = slow->next;
+        fast = fast->next->next;
+    }
+    return slow;
+}

cpp/Linked Lists/remove_kth_last_node.cpp

@@ -0,0 +1,35 @@
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+ListNode* removeKthLastNode(ListNode* head, int k) {
+    // A dummy node to ensure there's a node before 'head' in case we
+    // need to remove the head node.
+    ListNode dummy(-1);
+    dummy.next = head;
+    ListNode* trailer = &dummy;
+    ListNode* leader = &dummy;
+    // Advance 'leader' k steps ahead.  
+    for (int i = 0; i < k; i++) {
+        leader = leader->next;
+        // If k is larger than the length of the linked list, no node 
+        // needs to be removed.
+        if (leader == nullptr) {
+            return head;
+        }
+    }
+    // Move 'leader' to the end of the linked list, keeping 'trailer'
+    // k nodes behind.
+    while (leader->next != nullptr) {
+        leader = leader->next;
+        trailer = trailer->next;
+    }
+    // Remove the kth node from the end.
+    trailer->next = trailer->next->next;
+    return dummy.next;
+}