Python | Convert given list into nested list

Sometimes, we come across data that is in string format in a list and it is required to convert it into a list of the list. This kind of problem of converting a list of strings to a nested list is quite common in web development. Let’s discuss certain ways in which this can be performed. 

Method #1: Using iteration 

Method #2: Using list with numeric values 

Time complexity: O(n), where n is the length of the input list Input. 
Auxiliary space: O(n), where n is the length of the input list Input. 

Method #3: Using map()+split()+lambda

We use the map function to apply a function (in this case, the split function) to each element in a list (in this case, the list of strings). The map function returns an iterator that applies the function to each element of the list, and returns the results as a new iterator.

To obtain the final result as a list, we use the list function to convert the iterator returned by map into a list.

Result: [['Geeeks', 'ForLazyroar'], ['65.7492', '62.5405'], ['Geeks', '123'], ['555.7492', '152.5406']]

Time complexity: O(n)
Auxiliary Space: O(n)

Method 4: Using list comprehension. 

The program converts a list of strings into a list of lists by splitting each string by a comma followed by a space. Here’s the idea of the program in three lines:

Here are the steps:

1. Initialize an empty list called output.
2. Use a list comprehension to split each string in Input by the comma followed by a space (‘, ‘), and convert the result into a list.
3. Append the resulting list to output.
4. Print output.

Example:

[['Geeeks', 'ForLazyroar'], ['65.7492', '62.5405'], ['Geeks', '123'], ['555.7492', '152.5406']]

Time complexity: O(n), where n is the number of strings in Input. 
Auxiliary Space: O(n), because the resulting list output has n sublists, each containing two elements.

Method #5: Using numpy library

1. Import the numpy library using the following code:
2. Initialize the input list with string values separated by commas and spaces using the following code:
3. Use a list comprehension to split each element in the input list using commas and spaces as delimiters, and create a list of lists with the split values. This is done using the following code:
4. Convert the list of lists into a 2D numpy array using the following code:
5. Convert the 2D numpy array back to a list of lists using the tolist() method, and assign the result to the variable output using the following code.
6. Print the variable output using the following code:

Output:

[['Geeeks', 'ForLazyroar'], ['65.7492', '62.5405'], ['Geeks', '123'], ['555.7492', '152.5406']]

Time complexity: O(n)
Auxiliary Space: O(n)

Method #6: Using heapq:

1. Initialize the input array with the following values
2. Create an empty output list.
3. For each element elem in Input, do the following:
4. Split elem into a list of strings using the comma and space characters as delimiters.
5. Push the resulting list onto the output list using heapq.heappush().
6. Create a new empty list called result.
7. While the output list is not empty, do the following:
8. Pop the smallest element off the output list using heapq.heappop().
9. Append the popped element to the result list.
10. Print the resulting result list.

[['555.7492', '152.5406'], ['65.7492', '62.5405'], ['Geeeks', 'ForLazyroar'], ['Geeks', '123']]

Time complexity:

The time complexity of the code is O(n log n), where n is the number of elements in the Input list. This is because the code performs two loops:
In the first loop, it takes each element in the Input list, splits it into a list, and adds it to a heap using the heapq.heappush() function. The heapq.heappush() function takes log(n) time, so this loop has a time complexity of O(n log n).
In the second loop, it pops each element from the heap using the heapq.heappop() function and adds it to a list. The heapq.heappop() function also takes log(n) time, so this loop also has a time complexity of O(n log n).
The total time complexity of both loops combined is O(n log n).

Auxiliary Space:

The space complexity of the code is O(n), where n is the number of elements in the Input list. This is because the code creates a new list to hold the split elements from Input, and another list to hold the sorted elements. Additionally, the heapq module itself creates a heap that has a maximum size of n. Therefore, the overall space complexity is O(n).