# Limitations of Stack in Data Structures

To better understand the limitations of stack in data structure we need to know about stack and its uses and where it cannot be used.

## Stack and Representation

A straightforward linear data structure used to store data is called a stack. The Last In First Out (LIFO) principle, which stipulates that the piece that is put last will come out first, is used by stack. As an actual illustration, consider a stack of dishes stacked on top of one another. We may claim that the plate we put last comes out first because the plate we put last is on top and we take the plate at the top.

It may be accomplished using a linked list or an array. Its primary functions are push(), pop(), top(), isEmpty(), size(), and others. Certain actions are made available to us so that we can manipulate a stack. The operation is known as a push operation when we want to add an element to the stack and as a pop operation when we want to remove an element from the stack. Underflow occurs when we attempt to pop an element from an empty stack, and overflow occurs when we attempt to push an element into an already-full stack.

### Fundamental Stack Operations:

• Pushing an element into the stack is accomplished using the void push(int data) function.
• When the int pop() function is used, an element is taken from the top of the stack and returned.

### Operations on the auxiliary stack:

• Top(): This operation returns the most recent added element without deleting it from the list.
• The size of the stack, or the total number of elements in the stack, is returned by the int size() procedure.
• The int isEmpty() function determines whether or not the stack is empty.
• The int isFull() function determines whether or not the stack is full.

## Types of Stack

### Register

The smallest data storage components that are part of the CPU itself are called registers. These are the memory areas that the CPU can access right away. It might include a storage location, an instruction, or any sort of data, such a series of bits or a single character. As an instance, an instruction may state that the contents of two designated registers should be multiplied and then stored in a certain register.

Examples include the address register, instruction register, program counter, and accumulator register.

### Memory

Memory is a piece of hardware used to store data, instructions, and programmes for computers. A secondary memory is a memory that is external to the processor, whereas a main memory is a memory that is inside to the CPU (RAM) (Hard Drive). Volatile and non-volatile memory is additional categories for memory. Memory that loses its contents when a computer or other hardware device loses power is referred to as volatile memory. A type of volatile memory is RAM (Random Access Memory). Non-volatile memory is memory that retains its data even in the event of a power outage. An illustration of non-volatile memory is EPROM.

Example: RAM, EPROM etc.

### What exactly does Top of the Stack mean?

The top of the stack refers to the pointer that is used to access, add, and remove elements from the stack. It serves as a pointer to the stack's topmost element.

### Use of the Stack Data Structure:

• For evaluating expressions containing operands and operations, a stack is utilized.
• Any text editor's undo feature will match tags in HTML and XML.
• Conversion from Infix to Postfix.
• Stacks are employed in parenthesis matching and backtracking.
• One arithmetic notation to another arithmetic notation is converted using stacks.
• Stacks are helpful for function calls because they can store the activation information and then be deleted once the function returns. Processing the function calls makes use of it extremely effectively.
• Stacks may be used to reverse any collection of data or strings.

### The use of Stack in real life

• CD/DVD holder
• In a bookstore a stack of books.
• Text editors include an undo and redo feature.
• A web browser stores its history as a stack of items.
• As a stack, call logs, emails, and Google images are also kept in any gallery.

### Benefits of stacking:

• Stack aids in the management of data organized using the LIFO method.
• Stacks are employed in a methodical memory management system.
• Many virtual machines, including JVM, use it.
• Local variables and other function arguments are placed on the stack when a function is called, and they are immediately removed once the function returns. Effective function management is necessary.
• Stacks are more dependable and secure because they are difficult to corrupt.
• Control over memory de-allocation and allocation is possible using stack.
• Stack automatically cleans up the items.

### Negative aspects of Stack:

• Stack memory has a finite capacity.
• Before anything else, the stack's overall size must be determined.
• Stack overflow can happen if too many items are produced.
• In a stack, random accessing is not feasible.
• An unusual termination may result if the stack leaves the memory.

### Heap Memory

Each program is given a set amount of heaps in memory. In contrast to memory allocated to stacks, memory allocated to heaps can be allocated dynamically.

So, anytime the application requires it, the heap fragment may be requested and released. Additionally, because this memory is global, it cannot be confined by the function in which it is allocated and may be accessed and updated from anywhere in the program. Pointers are used to refer to dynamically allocated memory, which somewhat reduces speed compared to utilizing local variables (on the stack).

Local stack memory is distinct from heap memory. It differs not just in how variables are allocated and released when the function is called but also in how variables are released when the function terminates. The size of the item they are building often determines the size of this memory "block" automatically.

### Heap memory can be used to tackle the following issues:

• These are some crucial ideas to remember when it comes to garbage collection.
• Garbage collection is utilized by the Java Virtual Machine to eliminate unnecessary heap memory items. Every object that the active Java program is no longer using gets removed. Unused memory is released throughout this procedure for usage by other new objects.
• Before removing an object from memory and giving it a chance to be cleaned up, garbage collection calls the finalise() function of the object. Invocation of the default finalize method will occur if the programmer does not override this function (the method defined in the Object class).
• Based on how much memory from the heap has been dynamically allocated, garbage collection is started. Slow and unpredictable, it is programs subject to real-time performance restrictions. It moves slowly and is unpredictable. Real-time performance-constrained programs could find it challenging to manage.

### Heap memory's drawback

• Is that it executes more slowly than the stack.
• Calculation is more time-consuming.
• It can offer the most RAM that an OS is capable of.
• Since heap memory is used everywhere, memory management is more difficult.

### Important Distinctions Between Stack and Heap Memory

• While Heap is a hierarchical data structure, Stack is a linear data structure.
• Heap memory can become fragmented when memory blocks are initially created and subsequently released, however stack memory can never become fragmented.
• Heap allows you to access variables worldwide, whereas Stack only offers access to local variables.
• Heap variables can be enlarged but Stack variables cannot.
• Heap memory is allocated in any random sequence, whereas stack memory is allocated in a single, continuous block.
• De-allocating variables is not necessary for stack, but it is for heap.
• Compiler instructions handle stack allocation and de-allocation, whereas programmers handle heap allocation and de-allocations.

## Difference between Stack and Heap Memory

Parameter Stack Heap
Basic Each block of memory is allocated individually. Block of memory is randomly allocated.
Allocation and De-allocation Via compiler instructions, automatically. By the coder manually.
Cost Less More
Implementation Easy Hard
Access Time Faster Slower