Merge k sorted lists

c++/longest-palindromic-subseq.cpp

@@ -0,0 +1,34 @@
+class Solution {
+public:
+
+int tabulation(string t1, string t2)
+{
+    vector<int>curr(t2.length()+19,0);
+    vector<int>next(t2.length()+19,0);
+
+    for(int i = t1.length()-1;i>=0;i--)
+    {
+        for(int j =t2.length()-1;j>=0;j--)
+        {
+            int ans =0;
+            if(t1[i]==t2[j])
+            {
+                ans=1+next[j+1];
+            }
+            else
+            {
+                ans=max(next[j],curr[j+1]);
+            }
+            curr[j]=ans;
+        } 
+        next=curr;
+    }
+    return curr[0];
+}
+
+    int longestPalindromeSubseq(string s) {
+        string str=s;
+        reverse(s.begin(),s.end());
+        return tabulation(s,str);
+    }
+};

c++/merge-k-sortedlists.cpp

@@ -0,0 +1,32 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+        store = {}
+        for lst in lists:
+            start = lst
+            while start:
+                curr = start
+                while curr.next and curr.next.val == start.val:
+                        curr = curr.next
+                try:
+                    sect_head, sect_tail = store[start.val]
+                except KeyError:
+                    store[start.val] = [start, curr]
+                else:
+                    sect_tail.next = start
+                    store[start.val][1] = curr
+                start = curr.next
+        tail = None
+        head = None
+        for key in sorted(store.keys()):
+            front = store[key][0]
+            if not tail:
+                head = front
+            else:
+                tail.next = front
+            tail = store[key][1]
+        return head

c++/merge-sort.cpp

@@ -0,0 +1,104 @@
+// C++ program for Merge Sort
+#include <bits/stdc++.h>
+using namespace std;
+
+// Merges two subarrays of array[].
+// First subarray is arr[begin..mid]
+// Second subarray is arr[mid+1..end]
+void merge(int array[], int const left, int const mid,
+		int const right)
+{
+	int const subArrayOne = mid - left + 1;
+	int const subArrayTwo = right - mid;
+
+	// Create temp arrays
+	auto *leftArray = new int[subArrayOne],
+		*rightArray = new int[subArrayTwo];
+
+	// Copy data to temp arrays leftArray[] and rightArray[]
+	for (auto i = 0; i < subArrayOne; i++)
+		leftArray[i] = array[left + i];
+	for (auto j = 0; j < subArrayTwo; j++)
+		rightArray[j] = array[mid + 1 + j];
+
+	auto indexOfSubArrayOne = 0, indexOfSubArrayTwo = 0;
+	int indexOfMergedArray = left;
+
+	// Merge the temp arrays back into array[left..right]
+	while (indexOfSubArrayOne < subArrayOne
+		&& indexOfSubArrayTwo < subArrayTwo) {
+		if (leftArray[indexOfSubArrayOne]
+			<= rightArray[indexOfSubArrayTwo]) {
+			array[indexOfMergedArray]
+				= leftArray[indexOfSubArrayOne];
+			indexOfSubArrayOne++;
+		}
+		else {
+			array[indexOfMergedArray]
+				= rightArray[indexOfSubArrayTwo];
+			indexOfSubArrayTwo++;
+		}
+		indexOfMergedArray++;
+	}
+
+	// Copy the remaining elements of
+	// left[], if there are any
+	while (indexOfSubArrayOne < subArrayOne) {
+		array[indexOfMergedArray]
+			= leftArray[indexOfSubArrayOne];
+		indexOfSubArrayOne++;
+		indexOfMergedArray++;
+	}
+
+	// Copy the remaining elements of
+	// right[], if there are any
+	while (indexOfSubArrayTwo < subArrayTwo) {
+		array[indexOfMergedArray]
+			= rightArray[indexOfSubArrayTwo];
+		indexOfSubArrayTwo++;
+		indexOfMergedArray++;
+	}
+	delete[] leftArray;
+	delete[] rightArray;
+}
+
+// begin is for left index and end is right index
+// of the sub-array of arr to be sorted
+void mergeSort(int array[], int const begin, int const end)
+{
+	if (begin >= end)
+		return;
+
+	int mid = begin + (end - begin) / 2;
+	mergeSort(array, begin, mid);
+	mergeSort(array, mid + 1, end);
+	merge(array, begin, mid, end);
+}
+
+// UTILITY FUNCTIONS
+// Function to print an array
+void printArray(int A[], int size)
+{
+	for (int i = 0; i < size; i++)
+		cout << A[i] << " ";
+	cout << endl;
+}
+
+// Driver code
+int main()
+{
+	int arr[] = { 12, 11, 13, 5, 6, 7 };
+	int arr_size = sizeof(arr) / sizeof(arr[0]);
+
+	cout << "Given array is \n";
+	printArray(arr, arr_size);
+
+	mergeSort(arr, 0, arr_size - 1);
+
+	cout << "\nSorted array is \n";
+	printArray(arr, arr_size);
+	return 0;
+}
+
+// This code is contributed by Mayank Tyagi
+// This code was revised by Joshua Estes