**What Data Structure Is Used to Perform Non Recursion?**

When it comes to solving problems in computer science and programming, recursion is a common technique that is often used. However, there are cases where using recursion may not be the best approach or may not be possible due to constraints such as limited stack space.

In such situations, a non-recursive approach is required. To perform non-recursion, various data structures can be used. Let’s explore some of these data structures and understand how they can be leveraged.

## 1. Stack Data Structure

The stack data structure is widely used to perform non-recursion. It follows the Last-In-First-Out (LIFO) principle, where the last element added is the first one to be removed.

To implement non-recursion using a stack, we can mimic the recursive function call stack by manually maintaining a stack of function calls. Each function call can be represented as a stack frame containing relevant information such as parameters and local variables.

__Example:__

```
stack = []
stack.append(initial_function_call)
while stack:
current_function_call = stack.pop()
# Process current_function_call
# Add new function calls to the stack
```

## 2. Queue Data Structure

The queue data structure is another option for performing non-recursion. It follows the First-In-First-Out (FIFO) principle, where the first element added is the first one to be removed.

To implement non-recursion using a queue, we can simulate breadth-first traversal of recursive algorithms by enqueuing new function calls and dequeuing them in order.

__Example:__

```
queue = []
queue.append(initial_function_call)
while queue:
current_function_call = queue.pop(0)
# Process current_function_call
# Add new function calls to the queue
```

## 3. Heap Data Structure

The heap data structure, specifically the binary heap, can also be utilized for non-recursion. A binary heap is a complete binary tree in which each node has a value greater than or equal to its children (for max heap) or less than or equal to its children (for min heap).

To perform non-recursion using a heap, we can use the heap as a priority queue, where the function calls are ordered based on their priorities.

__Example:__

```
heap = []
heap.push(initial_function_call)
while heap:
current_function_call = heap.pop()
# Process current_function_call
# Add new function calls to the heap
```

## 4. Linked List Data Structure

Although not as commonly used as the stack, queue, or heap, a linked list can also be employed for non-recursion.

To perform non-recursion using a linked list, we can maintain a list of function calls where each node in the list contains a reference to the next function call.

__Example:__

```
linked_list = LinkedList()
linked_list.add(initial_function_call)
current_node = linked_list.head
while current_node:
current_function_call = current_node.value
# Process current_function_call
# Move to next node in the linked list
current_node = current_node.next
```

### Conclusion

In conclusion, there are several data structures that can be used to perform non-recursion in computer science and programming. The choice of data structure depends on the specific requirements and constraints of the problem at hand. Stack, queue, heap, and linked list are some of the commonly used data structures for non-recursion, each with its own advantages and use cases.

By understanding these data structures and their implementations, you can design efficient non-recursive algorithms to solve complex problems in an organized manner without relying on recursion.