# Python Program to Flatten a List without using Recursion

Flattening a nested list means converting a list that contains other lists (and potentially more nested lists) into a single-level list containing all the elements from the original list, while preserving their order. This can be achieved through various methods, and one common approach is using iteration (like loops) without involving recursion.

## Problem Statement

Given a nested list containing integers and possibly other nested lists, implement a function in python to flatten the list into a single-level list without using recursion. The order of elements should be preserved.

## Python Program to Flatten a List without using Recursion

```def flatten_list(nested_list):
flattened_list = []
stack = [nested_list]

while stack:
current = stack.pop()
if isinstance(current, list):
stack.extend(current)
else:
flattened_list.append(current)

return flattened_list

# Example usage
nested_list = [1, [2, 3], [4, [5, 6]], 7]
result = flatten_list(nested_list)
print(result)  # Output: [1, 2, 3, 4, 5, 6, 7]
```

## How it Works

1. The function `flatten_list(nested_list)` takes a nested list as input.
2. Inside the function, we initialize an empty list called `flattened_list` to store the flattened elements.
3. We also initialize a stack, which will be used to process the nested structure iteratively. We start by pushing the `nested_list` onto the stack.
4. We enter a loop that continues until the stack is empty.
5. In each iteration of the loop, we pop an element `current` from the stack.
6. We check whether the `current` element is a list using the `isinstance()` function. If it is a list, we extend the stack with the elements of this list. This essentially “unpacks” the nested structure one level at a time.
7. If the `current` element is not a list, it’s an integer or a non-list element. In this case, we add it to the `flattened_list`.
8. We repeat the process, iteratively popping elements from the stack, extending the stack with lists, and adding non-list elements to the `flattened_list`, until the stack is empty.
9. Once the loop completes, all elements have been processed and added to the `flattened_list`.
10. We return the `flattened_list`, which now contains all the elements from the original nested list, flattened into a single-level list while preserving their order.