MAHARASHTRA STATE BOARD OF TECHNICAL EDUCATION , MUMBAI

LOKNETE GOPALRAOJI GULVE POLYTECHNIC, NASHIK

YEAR 2025-26

A PROJECT REPORT OF
DATA STRUCTURE USING PYTHON (313306)
Submitted By

Roll.no Student name

1 Satvik Rajiv Zoman
3 Tejswini Nana Jagtap
4 Rohan Anil Patil
20 Apeksha kiran ahire

SY Artificial Intelligence
(2025-26)

Under the guidance of

Prof. S.A.Purkar

1|Page
 MAHARASHTRA STATE BOARD OF TECHNICAL EDUCATION , MUMBAI

LOKNETE GOPALRAOJI GULVE POLYTECHNIC, NASHIK

YEAR 2025-26

Certificate
This is to certify that

Mr. Satvik Rajiv Zoman

Ms. Tejswini Nana Jagtap

Mr. Rohan Anil Patil

Ms. Apeksha kiran ahire

of S.Y.AI (Artificial Intelligence) have successfully completed the micro-

project titled “Student record management using singly linked list”
satisfactorily as partial fulfilment of the curriculum for S.Y.AI Semester–
III during the academic year 2025–2026.

Prof. S.A.Purkar prof.A.V.Sonawane prof. R.R.Joshi

Class teacher H.O.D Principal

2|Page
 Index
Sr. No. Content
1 Title Page
2 Problem Statement
3 Objectives
4 Apparatus / Software Requirements
5 Introduction to Theory
6 Methodology / Working Principle
7 Block Diagram / Flowchart
8 Algorithm / Code Implementation
9 Output / Result
10 Applications
11 Observations / Data Analysis
12 Advantages
13 Limitations
14 Future Scope
15 Conclusion

3|Page
 1.Title of the project :-
Balanced Parentheses Checker (Using Stack)
i. Introduction to the topic :-
In today’s digital world, programming and software development rely heavily on writing
syntactically correct and logically structured code. One of the most common and important aspects
of syntax in programming languages involves the correct use of parentheses, brackets, and braces.
These symbols play a crucial role in defining the order of operations, function calls, conditional
statements, and code blocks. However, as programs grow in complexity, ensuring that every
opening bracket has a corresponding closing bracket becomes a challenging task. A single missing
or misplaced parenthesis can lead to syntax errors, logic errors, or even system failures. To
overcome this problem, a Balanced Parentheses Checker proves to be an effective and efficient
solution.

The project titled “Balanced Parentheses Checker (using Stack)” is based on the concept of data
structures, particularly the stack, which follows the Last In, First Out (LIFO) principle. This
property makes the stack an ideal choice for problems that involve matching pairs of symbols,
such as parentheses. The main idea is that whenever an opening bracket (like ‘(’, ‘{’, or ‘[’)
appears, it is pushed onto the stack, and whenever a closing bracket is encountered, the system
checks if it correctly matches the top element of the stack. If it matches, the top element is popped;
otherwise, the expression is declared unbalanced. At the end of the traversal, if the stack is empty,
it signifies that all parentheses are properly balanced.

This project not only provides a simple yet powerful way to verify the correctness of expressions
but also helps in understanding how stacks can be applied to solve real-world computational
problems. It demonstrates how dynamic memory and structured data handling can make problem-
solving more efficient. The concept of the Balanced Parentheses Checker is widely used in
compilers, interpreters, expression evaluators, and syntax analyzers, where proper nesting of
symbols is crucial.

The primary objective of this project is to design a system that can automatically check whether
the parentheses in a given expression are balanced or not using stack operations. Through this,
learners can gain deeper insight into stack implementation, function usage, and algorithmic
thinking. Thus, the project not only reinforces theoretical knowledge of data structures but also
enhances practical programming skills, logical reasoning, and error-handling abilities.

4|Page
 ii. Importance and Practical Relevance
In the field of computer science and software development, ensuring the correctness and
consistency of expressions and code structures is of great importance. A small error such as a
missing parenthesis, brace, or bracket can cause an entire program to fail or behave unexpectedly.
This highlights the need for an efficient mechanism to verify the balanced use of parentheses in
mathematical expressions, programming code, and logical statements. The Balanced Parentheses
Checker serves as a fundamental tool to detect and prevent such errors, ensuring the syntactical
accuracy of code before execution.

The use of a stack data structure makes this project both conceptually and practically significant.
A stack operates on the Last In, First Out (LIFO) principle, which is perfectly suited for matching
and validating nested structures like parentheses. When an opening symbol appears, it is pushed
onto the stack, and when a closing symbol is encountered, it is matched with the top element of
the stack. This process continues until the entire expression is checked, making the system highly
efficient for syntax validation. Such stack-based checking forms the basis of compiler design,
expression parsing, and syntax validation used in almost every modern programming language.

In real-world applications, the logic of balanced parentheses checking extends far beyond just code
syntax. It is widely.

iii. Conceptual Understanding and Applications

The Balanced Parentheses Checker using Stack serves as an excellent example of how fundamental
data structures can be applied to solve real-world computational problems. This project is based
on the stack data structure, which operates on the Last In, First Out (LIFO) principle — meaning
the last element inserted is the first one to be removed. This behavior makes stacks particularly
suitable for problems that require matching, reversal, or nested processing, such as checking
balanced parentheses in mathematical expressions or source code.

Conceptually, the checker works by scanning each symbol of an expression sequentially. When an
opening bracket (‘(’, ‘{’, ‘[’) is encountered, it is pushed onto the stack, and when a closing bracket
(‘)’, ‘}’, ‘]’) appears, the program checks the top of the stack to determine whether it matches the
corresponding opening symbol. If a mismatch occurs or the stack becomes empty prematurely, the
expression is identified as unbalanced. Once the entire expression has been processed, an empty
stack indicates that all parentheses are properly balanced. This logical process reinforces the
understanding of stack operations such as push, pop, peek, and isEmpty(), making it a strong
example of practical data structure utilization.

5|Page
From a broader perspective, this project provides a conceptual bridge between theoretical data
structures and their real-time applications. The same stack-based approach used here is employed
in various compiler and interpreter designs to check syntax correctness during code compilation.
It is also used in expression evaluation algorithms (such as infix to postfix conversion),
HTML/XML tag validation, and parsing arithmetic or logical expressions in programming
languages. Even modern text editors and IDEs use similar logic to highlight mismatched
parentheses or braces while coding.

For learners, implementing this project helps develop a deeper understanding of how abstract data
structures like stacks can be utilized to maintain order, structure, and accuracy in computational
logic. It also enhances problem-solving skills and algorithmic thinking, which are essential for
advanced concepts such as recursion, parsing, and memory management. Thus, the Balanced
Parentheses Checker not only demonstrates a clear conceptual understanding of stack operations
but also showcases their wide-ranging applications in both academic learning and professional
software development.

6|Page
 2. Statement / Problem Statement :-
i. Understanding the Problem :-
In modern computing and programming environments, ensuring the correctness of code and
expressions is a fundamental requirement. One of the most common sources of logical and
syntactical errors in programming languages, mathematical expressions, and structured data
formats is the improper use of parentheses, brackets, and braces.

Parentheses are used to define scope, grouping, and order of operations — whether in
mathematical formulas, programming constructs, or markup languages such as HTML and XML.
However, when these symbols are not properly balanced (for example, when an opening bracket
has no corresponding closing bracket), it leads to errors that can cause program crashes, incorrect
calculations, or invalid document structures.

Manually verifying the balance of parentheses in complex expressions or large blocks of code is
time-consuming and error-prone. Even a single missing or misplaced bracket can disrupt the entire
logic of a program. For instance, in a large C or Java program, missing a closing brace (}) can
make debugging difficult and reduce productivity. Similarly, in mathematical computations or
compiler design, an unbalanced expression like ((a + b) * c can lead to syntax errors or incorrect
evaluations.

To address this problem, an automated and efficient method is required to verify whether a given
expression has properly balanced parentheses. The Balanced Parentheses Checker solves this issue
by using the Stack data structure, which operates on the principle of Last In, First Out (LIFO).

In this system, every time an opening symbol such as (, {, or [ appears, it is pushed onto the stack.
When a closing symbol ), }, or ] is encountered, it checks whether it matches the top element of
the stack. If it matches, the top element is popped; if not, the expression is deemed unbalanced. At
the end of the process, if the stack is empty, the expression is balanced; otherwise, it is not.

The stack-based approach provides a systematic, efficient, and reliable way to validate expressions
in real-time. It avoids manual inspection and guarantees correctness through an algorithmic
process.

This concept is widely used in compiler design, syntax validation, expression evaluation, and
parsing structured documents. Beyond practical applications, this project also serves as a valuable
educational tool for understanding the core working of stacks and their applications in real-world
problems.

7|Page
 Therefore, the Balanced Parentheses Checker using Stack is an essential tool that demonstrates
both theoretical understanding and practical implementation of data structures. It highlights how
simple algorithms can solve real-world problems efficiently, making it a vital learning exercise for
students and an indispensable utility for programmers.

ii. Statement of the Problem and Need for Solution

The main problem addressed in this project is how to validate whether a given expression contains
balanced parentheses, which is a fundamental requirement in fields like programming language
parsing, compiler design, and mathematical expression evaluation. Manually checking the
correctness of nested and multiple types of parentheses (e.g., (), {}, []) in long expressions is
prone to errors, especially when the structure becomes complex.

Traditional linear scanning methods without the use of appropriate data structures fail to efficiently
manage nested relationships. Therefore, there is a strong need for a system that can systematically
track the opening and closing of brackets in the correct order using an efficient, well-suited data
structure.

Problem Statement:

“To design and implement a Balanced Parentheses Checker using the concept of Stack data
structure that can efficiently determine whether the parentheses in a given expression are correctly
balanced and properly nested.”

This project focuses on developing a simple yet effective software tool that uses a Stack, a Last-
In-First-Out (LIFO) data structure, to solve the problem of parentheses matching. The stack allows
temporary storage of opening brackets and enables quick verification of corresponding closing
brackets, making it ideal for problems involving nested structure validation.

The solution must fulfill the following requirements:

Accept input expressions containing different types of brackets: parentheses (), curly braces {},
and square brackets [].

Correctly identify whether the brackets are balanced and properly nested.

Handle both simple and complex expressions with multiple nested levels.

Use a Stack to push opening brackets and pop them when matching closing brackets are found.

Clearly demonstrate the practical use of stacks in parsing and validation tasks.

8|Page
By addressing these problems, the project demonstrates how abstract data structures like stacks
can be applied to real-world scenarios in programming and computer science. It bridges theoretical
learning with practical implementation, providing insight into how compilers, interpreters, and
various text editors ensure syntactic correctness. This foundational understanding also prepares
students for more advanced topics such as expression evaluation, syntax trees, and formal language
processing.

3.Objectives
Objective 1: To Develop an Efficient Parentheses Checking System
The primary goal of this project is to design and implement a program that efficiently verifies
whether the parentheses, brackets, and braces in a given expression are properly balanced. The
system should accurately detect any mismatched, missing, or extra symbols and display
appropriate results to the user.

This objective emphasizes building a logical and automated solution that eliminates human errors
commonly made while checking long and nested expressions manually. By doing so, the project
simplifies the process of syntax validation in mathematical formulas and programming codes. It
also provides a foundation for understanding how basic algorithms can be used to ensure
correctness and reliability in software systems.

Objective 2: To Apply the Concept of Stack Data Structure for

Expression Validation
A major objective of this project is to implement the stack data structure to solve the problem of
checking balanced parentheses. The stack operates on the Last In, First Out (LIFO) principle,
which is ideal for handling nested structures such as brackets.

In this project, each time an opening bracket (‘(’, ‘{’, ‘[’) is encountered, it is pushed onto the
stack. When a closing bracket (‘)’, ‘}’, ‘]’) appears, the program checks whether it matches the top
element of the stack and pops it if valid. This mechanism ensures that every opening symbol has
a correctly placed closing symbol, maintaining expression balance.

Through this objective, learners gain a practical understanding of stack operations like push, pop,
peek, and isEmpty(), and see how they can be applied to real-world programming problems such
as syntax checking, parsing, and compiler design.

9|Page
Objective 3: To Strengthen Understanding of Data Structures Using
Python
This project aims to bridge the gap between theoretical learning and practical application by
implementing the stack data structure using the Python programming language. Python’s
simplicity and readability make it an excellent choice for beginners to focus on algorithm design
and logic building without being hindered by complex syntax.

Students will learn how to create stack operations using lists or classes, understand how data is
managed dynamically in memory, and apply object-oriented programming principles to solve
logical problems. This objective enhances the learner’s capability to implement data structures in
real-world programming environments, improving both coding efficiency and conceptual
understanding.

Objective 4: To Automate the Detection of Syntax Errors in

Expressions
One of the key objectives of this project is to automate the process of syntax validation in
mathematical or logical expressions. Instead of manually verifying whether each parenthesis
matches correctly, the system performs this task automatically with precision and speed.

This objective focuses on reducing human error and increasing efficiency in coding and
mathematical computation. The same concept can later be extended to develop syntax analyzers,
compilers, and interpreters, which rely on similar stack-based algorithms to ensure program
correctness before execution. The project, therefore, serves as a simplified model of how complex
systems handle syntax checking internally..

Objective 5 To Develop Problem-Solving and Logical Thinking Skills

Beyond the technical implementation, this project aims to enhance problem-solving, algorithmic,
and logical reasoning skills among students. By designing the algorithm, implementing stack
operations, and testing various input cases, learners gain hands-on experience in debugging and
optimizing their code.

10 | P a g e
This objective encourages analytical thinking — understanding how data moves within a stack,
how conditional checks are performed, and how efficiency can be improved through algorithm
design. Ultimately, it builds a strong foundation for tackling advanced programming challenges
involving parsing, recursion, and expression evaluation.

4.Apparatus / Software / Tools Required :-

❖ Hardware Requirements:

• Personal Computer or Laptop

• Minimum 2 GB RAM (4 GB or higher recommended for smooth operation)
• Processor: Intel i3 or higher (or equivalent AMD processor)
• Keyboard and Mouse for input
• Internet connection (optional, for downloading Python or additional libraries)

❖ Software Requirements:

• Operating System: Windows, Linux, or macOS

• Programming Language: Python (Version 3.8 or higher recommended)
• IDE / Code Editor:
• IDLE (Python default IDE)
• Visual Studio Code
• PyCharm
• Jupyter Notebook (optional, for step-by-step execution)

❖ Python Libraries / Modules:

• sys (for handling inputs and outputs)

• re (regular expressions, optional, for advanced input validation)
• Built-in data types such as list (for stack implementation)
• Terminal / Command Prompt: To execute Python scripts
11 | P a g e
 • Conceptual Tools / Programming Knowledge:
• Understanding of Stack Data Structure and its operations: push, pop, peek, isEmpty
• Knowledge of control statements (if, for, while)
• Ability to use functions and modular programming in Python
• Debugging and testing strategies to verify correctness of the program

❖ Terminal / Command Prompt:

• To execute Python scripts
• Conceptual Tools / Programming Knowledge:
• Understanding of Stack Data Structure and its operations: push, pop, peek, isEmpty
• Knowledge of control statements (if, for, while)
• Ability to use functions and modular programming in Python
• Debugging and testing strategies to verify correctness of the program

❖ Additional Tools / Optional:

• Text Editor (Notepad++ / Sublime Text) for writing and editing code
• Version control systems like Git / GitHub for code management
• Online Python compilers (e.g., Repl.it, Google Colab) if IDE is not installed
• Documentation tools like Microsoft Word, Google Docs, or LaTeX for project
report preparation

❖ Learning & Practical Relevance:

• Applying data structures in real-world problems (like expression parsing, compiler

design)
• Understanding algorithm efficiency and error detection
• Enhancing logical and analytical skills through stack implementation

12 | P a g e
 5. Introduction to Theory
I. Introduction to Theory
In computer science, data structures are techniques for organizing, storing, and managing data
efficiently, enabling quick access, modification, and validation. Among the fundamental data
structures, a stack is a linear structure that follows the Last In, First Out (LIFO) principle. This
means the last element added to the stack is the first one to be removed. Stacks are widely used in
applications where order and nesting matter, such as expression evaluation, syntax parsing, and
function call management.

The Balanced Parentheses Checker is a practical application of the stack data structure. It
validates whether an expression contains correctly nested and matched parentheses (), braces {},
and brackets []. The system reads an expression symbol by symbol and uses stack operations to
ensure that every opening symbol has a corresponding closing symbol in the correct order.

Unlike manual checking, which is prone to human error and difficult for complex or deeply nested
expressions, a stack-based system handles this task efficiently. By dynamically pushing and
popping symbols, the program can manage multiple levels of nesting without confusion or the
need for extra memory management.

The main goal of using a stack is to validate expressions logically and systematically. Each opening
bracket is pushed onto the stack, and each closing bracket is compared against the top element of
the stack. If they match, the top element is popped, and the process continues until the end of the
expression. If the stack is empty at the end, the expression is balanced; otherwise, it is unbalanced.
This method ensures precise and error-free validation for both simple and complex expressions.

iii. Working Principle of Singly Linked List

1. Stack Structure:
Stores only opening symbols ((, {, [).

Follows LIFO order for matching symbols.

2. Push Operation:

When an opening symbol is encountered, it is pushed onto the stack.

13 | P a g e
 3. Pop Operation:

When a closing symbol is encountered, the program pops the top element of the stack and
checks if it matches the closing symbol.

4. Empty Stack Check:

If a closing symbol appears when the stack is empty, the expression is unbalanced.

5. End of Expression:

After traversing the entire expression, if the stack is empty → balanced.

If not empty → unbalanced.

iii. Python Implementation Principle

Python Implementation Principle

In Python, the stack can be implemented using lists or custom classes:

Using List:

append() → Push

pop () → Pop

[-1] → Peek

14 | P a g e
Using Class:

class Stack:

def _init_(self):
self.items = []

def push(self, item):

self.items.append(item)

def pop(self):

if not self.is_empty():

return self.items.pop()
return None

def peek(self):

if not self.is_empty():

return self.items[-1]

return None

def is_empty(self):

return len(self.items) == 0

The expression is scanned symbol by symbol.

Opening symbols are pushed; closing symbols pop and match.

Stack emptiness at the end determines whether the expression is balanced.

15 | P a g e
 iv . Applications and Advantages
Applications:
• Validating code syntax in compilers and interpreters.

• Checking mathematical expressions in calculators or math software.

• Parsing HTML/XML tags for correct nesting.

• Used in IDEs to highlight unmatched brackets.

Advantages:
• Efficient handling of nested expressions of any depth.
• Eliminates human error in manual validation.
• Simple implementation using basic stack operations.
• Provides a foundation for understanding expression evaluation and compiler design.

Working Principle Summary:

The system reads an expression, uses a stack to track opening symbols, matches them with
closing symbols dynamically, and determines if the expression is balanced. Python simplifies the
implementation while ensuring reliable memory management and logical operation. This project
demonstrates the practical application of stacks in solving real-world computational problems
like syntax checking and expression validation

5. Methodology / Working
The methodology section explains how the Balanced Parentheses Checker (using Stack)
project is designed, implemented, and executed. It describes the logical flow of the
program, how the stack is used to manage symbols dynamically, and the stepwise working
principle of verifying balanced parentheses in an expression.

16 | P a g e
 The project is implemented in Python using a stack-based approach, which follows the Last
In, First Out (LIFO) principle. Each opening symbol in an expression is pushed onto the
stack, and each closing symbol is compared with the top element of the stack for validation.
This approach ensures correct handling of nested and sequential parentheses without
human error.

The methodology is divided into three main stages:

❖ Design Phase – Planning Stack Operations

• The first step is to design the stack structure and define operations:
• Stack Structure:
• Uses Python list or class-based stack.
• Stores only opening symbols: (, {, [.
• Maintains LIFO order for proper matching.

➢ Operations Planned in Design:

• Push: Add opening symbols to the stack.

• Pop: Remove the top element when a matching closing symbol is found.
• Peek / Top Check: Check the top element for matching.
• Is Empty Check: Determine if stack is empty at the end or when a closing symbol is
encountered.

➢ User Input Handling:

• Accept an expression containing parentheses, brackets, and braces.

• Ignore non-bracket characters during checking.

❖ Implementation Phase

The implementation involves creating a stack structure and writing logic to check for
balanced symbols.
➢ Stack Implementation in Python:

17 | P a g e
 class Stack:
def _init_(self):
self.items = []

def push(self, item):

self.items.append(item)

def pop(self):
if not self.is_empty():
return self.items.pop()
return None

def peek(self):
if not self.is_empty():
return self.items[-1]
return None

➢ Algorithm Steps:

1. nitialize an empty stack.

2. Traverse the expression symbol by symbol.
3. For opening symbols: push onto the stack.
4. For closing symbols:

If the stack is empty → unbalanced.

If the top of the stack matches → pop the top element.
If it does not match → unbalanced.

5. After traversal, check stack:

If empty → balanced.

If not empty → unbalanced.

Example Expression: { [ ( a + b ) * c ] - d }
18 | P a g e
 Step-by-step processing ensures each opening symbol is matched correctly.

❖ Execution & Testing Phase

➢ Interactive User Interface:

Program accepts input expression from the user.

Displays result: Balanced or Unbalanced.

➢ Testing & Validation:

• Test with simple expressions: (), {}, [].

• Test with nested expressions: {[()()]}.

• Test with incorrect expressions: ({[)]}, ((()).

• Edge cases: empty input, no brackets, only opening or closing symbols.

Output:
Clear message stating if the expression is balanced or unbalanced.

Working Principle:

Working Principal Summary

• Dynamic Symbol Management: Stack dynamically stores opening symbols.

• Sequential Checking: Each symbol is checked in order, ensuring proper nesting.
• Error Detection: Unmatched or misordered symbols are detected immediately.
• Memory Efficiency: Stack only stores symbols currently in scope; no need for extra
memory.
• Python Advantages: Simple syntax, automatic memory handling, and ease of
testing.

Advantages of Methodology
• Efficiently handles nested and complex expressions.
• Reduces human error in manual checking.

19 | P a g e
 • Provides hands-on understanding of stack operations.
• Forms the foundation for compiler design, expression evaluation, and syntax
parsing.
• Scalable for expressions of any length or depth.

ii. Implementation in Python

The implementation involves creating two main classes:

1. Node Class – Represents each student record:

class Node:
def __init__(self, roll, name, branch, marks):
self.roll = roll
self.name = name
self.branch = branch
self.marks = marks
self.next = None

2. LinkedList Class – Manages operations on nodes:

class LinkedList:
def __init__(self):
self.head = None

Implementation Steps:
• Insertion: Create a new node → If list is empty, make it head → Else, traverse and link
new node at correct position.
• Deletion: Traverse the list to find the node → Update previous node’s next to skip the
deleted node → Delete node from memory.
• Search: Start at head → Compare each node’s roll number → Display record if found.
• Update: Search node → Modify required fields.
• Display: Traverse from head → Print each node’s details.

Working Principle:

20 | P a g e
Python handles memory allocation automatically. Each node exists as a separate object, and
references link nodes together to form the chain.

2. Designing the Stack Structure and Logic

The first step in the methodology is designing the core logic and understanding how the stack will
be utilized. While a dedicated Stack class can be implemented, for simplicity in Python, a list can
often serve as a stack.

Each element pushed onto the stack will be an opening bracket.

Key Data Structures and Components:

Stack: A LIFO (Last-In, First-Out) data structure to store opening brackets encountered during
traversal.

Input Expression (String): The sequence of characters (including various types of brackets: {},
[], ()) to be checked.

Mapping (Optional): A way to quickly identify corresponding opening and closing brackets (e.g.,
{ matches }).

Operations Planned in the Design:

Traversal: Iterate through each character of the input expression.

Push to Stack: When an opening bracket ((, {, [) is encountered, push it onto the stack.

Pop from Stack: When a closing bracket (), }, ]) is encountered, pop the top element from the
stack.

Match Check: After popping, verify if the popped opening bracket correctly matches the
encountered closing bracket.

Empty Stack Check: Check if the stack is empty at various points (e.g., when a closing bracket is
found but no opening bracket is on the stack, or at the end of the expression).

Working Principle:
Initialize an empty stack.

Iterate through the input expression character by character.

If an opening bracket is found, push it onto the stack.

If a closing bracket is found:

21 | P a g e
Check if the stack is empty. If it is, the expression is immediately unbalanced (no opening bracket
to match).

If not empty, pop the top element (which should be an opening bracket) from the stack.

Compare the popped opening bracket with the current closing bracket. If they don't form a valid
pair (e.g., ( and ]), the expression is unbalanced.

After iterating through the entire expression:

If the stack is empty, all opening brackets were successfully matched with their corresponding
closing brackets, and the expression is balanced.

If the stack is not empty, there are unmatched opening brackets, and the expression is unbalanced.

This design ensures dynamic processing, flexibility, and efficient operation for checking bracket
balance.

iii. Implementation in Python

The implementation involves a function or class that encapsulates the logic described above. For
simplicity, we'll outline a functional approach using Python's list as a stack.

Implementation Structure:

# A function to check for balanced parentheses

def check balanced parentheses(expression):

stack = []
# A dictionary for quick lookup of matching brackets

bracket_map = {')': '(', '}': '{', ']': '['}

# Define sets for opening and closing brackets for easy checking

opening_brackets = set(['(', '{', '['])

closing_brackets = set([')', '}', ']'])

for char in expression:

if char in opening_brackets:

22 | P a g e
 # If it's an opening bracket, push it onto the stack

stack.append(char)

elif char in closing_brackets:

# If it's a closing bracket

if not stack:

# If stack is empty, no opening bracket to match

return False

# Pop the top element from the stack

top_element = stack.pop()

# Check if the popped opening bracket matches the current closing bracket

if bracket_map[char] != top_element:

return False

Implementation Steps (Detailed):

Initialize Stack: Create an empty list stack to function as the stack.
Define Mappings: Create a dictionary bracket_map (e.g., ')': '(') to quickly verify matching pairs.

Iterate Characters: Loop through each character (char) in the input expression.

Handle Opening Brackets: If char is an opening bracket ((, {, [), push char onto the stack.

Handle Closing Brackets: If char is a closing bracket (), }, ]):

Check for Empty Stack: If the stack is empty before popping, it means a closing bracket appeared
without a corresponding opening bracket. Return False (unbalanced).

Pop Element: Remove the last element added to the stack (the most recent opening bracket).

Check Match: Use bracket_map to see if the popped opening bracket is the correct match for the
current char. If not, return False (unbalanced).

Final Check: After the loop finishes, check if the stack is empty. If it is, all brackets were matched,
return True (balanced). Otherwise, there are unmatched opening brackets, return False.

Working Principle:

Python's lists inherently support stack operations (append for push, pop for pop). The logic relies
on the LIFO principle: the most recently opened bracket must be the first one closed. By tracking

23 | P a g e
opening brackets and immediately verifying closing brackets against the stack's top, the system
efficiently detects mismatches or unclosed brackets.

iv. User Interaction and Data Flow

• The Balanced Parentheses Checker typically operates as a function that takes a
string input and returns a boolean result. User interaction is generally direct:
• User Interface Flow (Conceptual):
• Input Expression: The user provides an expression string (e.g., "{[()]}").
• Function Call: The input string is passed to the check_balanced_parentheses
function.
• Processing: The function executes the described stack-based logic.
• Output Result: The function returns True or False.
• Display Outcome: The program displays whether the expression is "Balanced" or
"Unbalanced" to the user.

Working Principle:

This direct interaction provides immediate feedback on the balance of the input expression.
The character-by-character traversal and stack manipulation ensure that the operation is
performed sequentially and logically. The stack dynamically grows and shrinks based on
the input, reflecting the real-time matching process.
Data Flow Diagram (Conceptual):
User Input (Expression String) → check_balanced_parentheses Function → Stack
Manipulation (Push/Pop/Match) → Boolean Result (True/False) → Output Display

24 | P a g e
V . Testing, Validation, and Advantages

Testing & Validation:

The Balanced Parentheses Checker undergoes rigorous testing to ensure its accuracy and
robustness.
• Diverse Input Expressions: The checker is tested with a variety of expressions containing
different types of brackets (parentheses (), curly braces {}, square brackets []), nested
brackets, and combinations of balanced and unbalanced sequences (e.g., ({[]}), ([)], {{{).
• Edge Cases Handling: Specific edge cases are thoroughly checked:
• Empty String: Testing with an empty input string "" should correctly return True
(balanced).
• Only Opening Brackets: Expressions like ((({ should correctly return False (unbalanced).
• Only Closing Brackets: Expressions like ))) or }) should correctly return False
(unbalanced) due to an empty stack upon encountering a closing bracket.
• Mismatched Brackets: Expressions like ([)] or {)(} should correctly return False
(unbalanced) when the popped opening bracket doesn't match the current closing bracket.
• Expressions with Other Characters: The checker should gracefully ignore non-bracket
characters, focusing solely on the balance of brackets (e.g., a + (b * {c - [d]}) / e should
return True).
• Logical Correctness: The system is validated to ensure that the stack operations (push,
pop, empty check) correctly implement the LIFO principle and the matching logic, thereby
guaranteeing the correct determination of balance for any given expression..

Advantages of Methodology:

The use of a stack for the Balanced Parentheses Checker offers several significant advantages:

• Simplicity and Readability: The stack-based approach is conceptually straightforward

and translates into clean, easy-to-understand code.
• Efficiency: The algorithm processes each character of the input expression exactly once
(O(N) time complexity, where N is the length of the expression). Stack operations (push,
pop, top, is_empty) are typically O(1) constant time, making the overall solution highly
efficient.
• Dynamic Handling: The stack dynamically adapts to the nesting depth of brackets,
growing and shrinking as needed, without requiring prior knowledge of the expression's
structure.

25 | P a g e
• Foundation for Advanced Parsing: This methodology provides a fundamental
understanding of how stacks are used in more complex parsing tasks, such as compilers,
interpreters, and syntax validators, making it a crucial concept for computer science
education.
• Low Memory Footprint: The memory usage is proportional to the maximum nesting
depth of the brackets, not the total length of the expression, making it memory-efficient for
deeply nested but short expressions.

6. Block Diagram / Circuit Diagram / Flowchart

I . Block Diagram

26 | P a g e
Explanation of Block Diagram:
1. Start & Initialize: Begin the process by initializing an empty stack.
2. Read Input: Get the expression string that needs to be checked.
3. Process Each Character (Loop): Go through the expression character by
character:
➢ If Opening Bracket: Push the character onto the stack.
➢ If Closing Bracket:

27 | P a g e
 o Check if the stack is empty. If yes, it's immediately Unbalanced.
o If not empty, pop the top element from the stack.
o Check if the popped element (opening bracket) correctly matches the
current closing bracket. If no, it's immediately Unbalanced.
o If Other Character: Ignore and continue to the next character.

4 . After Loop Ends (Final Check): Once all characters are processed:
o If Stack is Empty: The expression is Balanced.
o If Stack is Not Empty: The expression is Unbalanced (unmatched
opening brackets remain).
5. End: The process concludes with the result.

II. Flowchart

28 | P a g e
Explanation of Flowchart Diagram:
1. Start & Initialize: Begin the process by initializing an empty stack.
2. Read Input: Get the expression string that needs to be checked.
3. Process Each Character (Loop): Go through the expression character by
character:
➢ If Opening Bracket: Push the character onto the stack.
➢ If Closing Bracket:

o Check if the stack is empty. If yes, it's immediately Unbalanced.

o If not empty, pop the top element from the stack.
o Check if the popped element (opening bracket) correctly matches the
current closing bracket. If no, it's immediately Unbalanced.
o If Other Character: Ignore and continue to the next character.

4 . After Loop Ends (Final Check): Once all characters are processed:
o If Stack is Empty: The expression is Balanced.
o If Stack is Not Empty: The expression is Unbalanced (unmatched
opening brackets remain).
5. End: The process concludes with the result.

7. Code :-
#------------------------------------------------------------------
Title : Balanced Parentheses Checker (Using Stack)
# Author : [Your Name]
# Language : Python
# Description: Program to check whether parentheses in an expression
# are balanced using Stack data structure.
#------------------------------------------------------------------

#-------------------------------
# Stack Class Implementation
#-------------------------------
class Stack:
def _init_(self):
"""Initialize an empty stack."""
self.stack = []

29 | P a g e
 def is_empty(self):
"""Check whether the stack is empty."""
return len(self.stack) == 0

def push(self, item):

"""Push an item onto the stack."""
self.stack.append(item)
print(f"→ Pushed '{item}' to stack. Current Stack: {self.stack}")

def pop(self):
"""Pop an item from the stack."""
if not self.is_empty():
popped = self.stack.pop()
print(f"→ Popped '{popped}' from stack. Current Stack: {self.stack}")
return popped
else:
print("⚠ Stack Underflow! Tried to pop from an empty stack.")
return None

def peek(self):
"""Return the top element of the stack."""
if not self.is_empty():
return self.stack[-1]
return None

def size(self):
"""Return the size of the stack."""
return len(self.stack)

def display(self):
"""Display stack content."""
print("Current Stack:", self.stack)
#-------------------------------
# Balanced Parentheses Function
#-------------------------------
def is_balanced(expression):
"""Check whether an expression has balanced parentheses."""
stack = Stack()
opening = "([{"

30 | P a g e
 closing = ")]}"
print("\nChecking Expression:", expression)

for char in expression:

# Push opening brackets
if char in opening:
stack.push(char)

# Handle closing brackets

elif char in closing:
pos = closing.index(char)
if stack.is_empty():
print(f" Error: No matching opening bracket for '{char}'")
return False
top = stack.pop()
if opening[pos] != top:
print(f" Mismatch: '{top}' does not match '{char}'")
return False
else:
# Ignore non-bracket characters
continue

# Final validation
if stack.is_empty():
print(" Expression is Balanced.\n")
return True
else:
print(" Unmatched brackets remain in stack:", stack.stack)
print(" Expression is NOT Balanced.\n")
return False
#-------------------------------
# Main Program (Menu Driven)
#-------------------------------
def main():
while True:
print("\n===== Balanced Parentheses Checker =====")
print("1. Check Single Expression")
print("2. Check Multiple Expressions")
print("3. Exit")

31 | P a g e
 choice = input("Enter your choice (1-3): ")

if choice == '1':
expression = input("Enter an expression: ")
is_balanced(expression)

elif choice == '2':

n = int(input("Enter number of expressions to check: "))
for i in range(n):
expr = input(f"Enter Expression {i+1}: ")
is_balanced(expr)

elif choice == '3':

print("Exiting... Thank you for using the program!")
break

else:
print("Invalid choice! Please try again.")

#-------------------------------
# Run Program
#-------------------------------
if _name_ == "_main_":
main()

8.OUTPUT AND SCREENSHOTS OF EXECUTED

PROGRAM:-

32 | P a g e
 1.

2.

4.

5.

33 | P a g e
6.

7.

8.

34 | P a g e
 9.

8. Applications

1. Compiler Design and Syntax Checking

In programming languages like C, C++, Java, or Python, balanced parentheses are essential for
defining the scope of code blocks, loops, and function definitions. Compilers use stack-based
algorithms to verify that every opening bracket {, [, or ( has a corresponding closing bracket
}, ], or ).
This helps in detecting syntax errors early in the compilation process and ensures that the
source code is structurally correct before translation into machine code.

Use Case:

Checking proper nesting of braces in source code.

2. Expression Evaluation and Parsing

Balanced parentheses checking is a crucial step in mathematical expression evaluation. When
expressions like ((a + b) * c) are parsed, parentheses determine the order of operations and the
grouping of terms.

Before an expression is evaluated by a calculator or an interpreter, the program must ensure that
the parentheses are properly matched to avoid misinterpretation or runtime errors.

35 | P a g e
Evaluating arithmetic expressions in calculators.

Validating user input in mathematical solvers or scientific software.

3. Code Editors and IDEs

Modern code editors and Integrated Development Environments (IDEs) such as Visual Studio
Code, PyCharm, and Eclipse use parentheses checking as a background process.

When a programmer types an opening bracket, the editor highlights the matching closing
bracket. This functionality relies on stack-based algorithms to dynamically track balanced pairs.

Impact:
Improves coding accuracy.

Prevents missing bracket errors.

Enhances real-time code validation.

4. Data Serialization and Markup Validation

Many data formats such as JSON, XML, and HTML rely on properly nested and matched tags or
braces.

Balanced parentheses checking logic can be extended to verify whether all tags and brackets are
correctly opened and closed. This ensures that structured data files are well-formed before being
processed by parsers or web applications.

Example:

Checking balance of braces {} in JSON data.

Ensuring proper tag closure in XML and HTML documents.

36 | P a g e
5. Compiler Intermediate Code Generation

In compilers, balanced parentheses validation is essential before generating intermediate

representations of source code.

Unbalanced expressions can cause incorrect symbol table entries, faulty intermediate code, and
misaligned execution blocks. Stack-based parentheses checking ensures that code translation
remains accurate and consistent.

Example:

Used in front-end phases of compiler design (syntax and semantic analysis).

Ensures proper parsing of nested expressions and function calls.

6. Text Editors and Document Processors

Text processors and editors that support auto-formatting or syntax highlighting depend on balanced
symbol checking.

When a user types an opening bracket or quotation mark, the system automatically checks for
matching pairs to assist in writing structured content such as LaTeX documents, Markdown, or
JSON files.

Use Case:
Detecting missing symbols in structured documents.

Real-time feedback in text-based editors.

7. Arithmetic Expression Conversion (Infix to Postfix/Prefix)

Before converting an infix expression (e.g., (A + B) * C) to postfix or prefix notation, it is essential

to confirm that parentheses are balanced.

Stack-based algorithms for infix to postfix conversion depend on the correct pairing of brackets to
maintain operator precedence and operand grouping.

37 | P a g e
Example:

Converting mathematical expressions for use in expression trees or interpreters.

Used in calculators, compilers, and interpreters.

8. Validation in Scripting and Query Languages

Languages like SQL, JavaScript, and Python use parentheses and braces for query grouping and
function calls.
Before execution, interpreters check for balanced parentheses to avoid syntax errors or
misinterpretation of code logic.

Example:

Ensuring parentheses match in SQL queries like SELECT * FROM table WHERE (a > 5 AND (b
< 10));.

Validating function calls in Python or JavaScript.

9. Academic and Educational Use

This project serves as an excellent learning tool for students studying Data Structures and
Algorithms.

It helps in understanding the practical application of the Stack (LIFO) principle and how it can be
applied to solve real-world problems efficiently.

Learning Outcomes:

Understand stack operations such as push and pop.

Apply theoretical knowledge to validate expressions.

Learn algorithmic thinking and debugging of expression errors.

38 | P a g e
10. Web Development and Front-end Validation

In web applications, especially those accepting user-generated formulas or code snippets (like
online editors or calculators), parentheses checking ensures data integrity before submission.

It prevents runtime errors and improves reliability by validating the structure of user input.

Example:

Online compilers and editors.

Web-based math expression evaluators.

Form validation in web apps.

9. Data Observations
1. Objective
To observe and analyze the working of the Balanced Parentheses Checker program that
uses the Stack data structure for verifying the correctness of parentheses, brackets, and
braces in a given expression.

2. Principle / Concept
The stack follows the LIFO (Last In, First Out) principle.

When checking parentheses:

Every opening symbol — (, {, [ — is pushed onto the stack.

Every closing symbol — ), }, ] — causes a pop operation, and the popped element is
compared.

If at any time a mismatch occurs, or a closing bracket appears without a matching opening
one, the expression is Not Balanced.
At the end, if the stack is empty, the expression is Balanced; otherwise, it’s Not Balanced.

39 | P a g e
 3. Tools / Software Used
Programming Language: Python 3.x

IDE: VS Code / PyCharm / IDLE

Concept Used: Stack using List (Push / Pop Operations)

4. Input / Output Specification

Type Description
Input Expression containing parentheses (), curly braces {}, and square brackets [] (may
include operands, operators, etc.)

Output Message displaying whether the given expression is Balanced or Not Balanced

5. Sample Inputs and Observed Outputs

Sr. Input Expected Observed

No. Expression Output Output Remarks

1 {[()]} Balanced Balanced Perfectly nested parentheses

2 {[(])} Not Balanced Not Balanced Mismatched bracket types
3 ((A+B)*C) Balanced Balanced Proper nesting and closure
[A+(B*C)- Mixed bracket types handled
4 {D/E}] Balanced Balanced correctly
5 {[a+b]*[c/d]} Balanced Balanced Multiple bracket pairs handled
6 {[} Not Balanced Not Balanced Missing closing brackets
7 ((A+B) Not Balanced Not Balanced Unmatched opening bracket
Expression without brackets
8 A+B*C-D Balanced Balanced considered balanced
9 ((A+B]) Not Balanced Not Balanced Closing type mismatch
10 [{()}([])] Balanced Balanced Deeply nested parentheses
11 (())) Not Balanced Not Balanced Extra closing bracket

40 | P a g e
 12 {a+[b*(c+d)]-e} Balanced Balanced Correct use of nested brackets
Complex multiple balanced
13 [()]{}{[()()]()} Balanced Balanced sequences
14 [({})](] Not Balanced Not Balanced Wrong closing bracket at end
15 (((()))) Balanced Balanced Deep nesting validated
16 ([A+B]*{C+D) Not Balanced Not Balanced Missing closing bracket
{[(A+B)*(C/D)] Complex expression checked
17 -(E+F)} Balanced Balanced correctly
18 ((A+B)*(C+D)] Not Balanced Not Balanced Mismatch detected
19 (Empty Input) Balanced Balanced No brackets → Balanced
20 {} Balanced Balanced Simple balanced case

6. Step-by-Step Example Trace

Example Input: {[()]}

Initial Stack: []

Step Character Read Operation Stack Content

1 { Push {
2 [ Push {[
3 ( Push {[(
4 ) Pop (matched () {[
5 ] Pop (matched [) {
6 } Pop (matched {) [] (empty)

7. Observational Analysis
1. The stack correctly stores and removes symbols in LIFO order.
2. Each opening symbol is matched with its respective closing symbol.
3. Invalid or mismatched brackets are detected instantly.
4. Non-bracket characters (like A, +, *, /) are ignored safely.

5. When the stack is empty at the end → expression is Balanced.

41 | P a g e
 6. If any opening remains in stack → expression is Not Balanced.

7. Time complexity = O(n) (each character processed once).

8. Space complexity = O(n) (for worst-case nested brackets).

9. The program handles all types of brackets — (), {}, and [].

10. Expressions with multiple independent bracket sets are checked correctly.

11. The algorithm terminates early if an unmatched closing bracket is found.

12. Works correctly for empty strings or no-bracket expressions (considered balanced).

13. Improper nesting (e.g., {[)]}) is accurately identified as Not Balanced.

14. Demonstrates correct working of stack push/pop operations in real-life problem

solving.

15. Suitable for evaluating arithmetic, logical, or code expressions for structural
correctness

8. Graphical / Logical Flow (Summary)

• Input Expression → Push Opening Symbols → Pop for Closing Symbols → Compare
→ Check Stack Empty → Output Result

• Or simply:

• Start → Input Expression → Initialize Stack → For each Character: Push / Pop →
Check Stack → Balanced / Not Balanced → End

9. Observation Summary

Condition Stack Behavior Output

Equal & correctly matched pairs Stack becomes empty Balanced

Extra opening bracket(s) Stack not empty at end Not Balanced
Extra closing bracket(s) Stack underflow / mismatch Not Balanced
Mismatched bracket types Wrong pair detected Not Balanced
No brackets at all Stack stays empty Balanced

42 | P a g e
 10. Inference / Result

• The Balanced Parentheses Checker program executed successfully.

• The Stack data structure accurately validates the correctness of parentheses in all
test cases.
• The system identifies balanced, unbalanced, and mismatched expressions
efficiently.
• The results obtained are consistent with theoretical expectations.
• The program is efficient, reliable, and practically applicable to compilers,
expression validators, and syntax checkers.

10. Advantages of Balanced Parentheses Checker

(Using Stack) in Python
The Balanced Parentheses Checker is one of the most widely used and conceptually simple
stack-based algorithms. It ensures that every opening bracket in an expression has a
corresponding and correctly placed closing bracket. Implementing this checker in Python
provides numerous practical, educational, and technical advantages.

1. Simple and Easy to Understand

The algorithm follows a clear step-by-step logic based on stack operations — making
it simple for beginners to grasp. It uses only basic push() and pop() methods.

2. Efficient Time Complexity

It operates in O(n) time, where n is the length of the input expression. Each character is
checked exactly once, ensuring fast execution.

43 | P a g e
3. Reliable Error Detection
The program accurately detects missing, mismatched, or misplaced brackets, helping
identify syntax or logical errors in code or expressions.

4. Low Memory Usage

The stack only stores unmatched opening brackets, keeping memory consumption very
low — O(n) in the worst case and usually much less.

5. Handles Multiple Bracket Types

The checker supports parentheses (), curly braces {}, and square brackets [], which are
used in most programming and mathematical expressions.

6. Useful for Code Syntax Validation

It is essential for syntax checking in compilers, interpreters, and IDEs, ensuring that
code blocks are properly structured.

7. Detects Nested and Complex Structures

The algorithm correctly validates deeply nested and multi-level parentheses, common
in complex mathematical or logical expressions.

8. Supports Dynamic Expression Length

The stack dynamically grows or shrinks based on the number of brackets, allowing it
to handle expressions of any size without modification.

9. Early Error Detection

As soon as a mismatch is found, the algorithm stops and reports the error. This
avoids unnecessary computation and improves efficiency.

44 | P a g e
10. Real-Time Validation
It can be integrated into text editors or IDEs to instantly highlight unbalanced
brackets while typing code.

11. Cross-Platform and Portable

Written in Python, it runs seamlessly across Windows, macOS, and Linux without
needing platform-specific changes.
12. Demonstrates Stack Data Structure
It provides a practical demonstration of stack behavior (LIFO — Last In, First Out), helping
students understand how stacks work in real-world problems.

13. Foundation for Expression Evaluation

The logic is used as the basis for infix to postfix conversions, expression parsing, and
compiler syntax trees.

14. Reduces Syntax-Related Bugs

Developers can integrate this checker to catch structural or syntactical mistakes before
compilation or execution, reducing runtime errors

15. Educational Value

A standard example for teaching stack operations, string traversal, error handling, and
algorithm design in data structure courses.

16. Extensible for New Applications

It can easily be adapted for other forms of bracket checking such as < >, XML/HTML tags,
or even parentheses in natural language processing.
Logical and Structured Approach

The algorithm enforces a systematic checking method that ensures all open brackets are
matched correctly before closing.

45 | P a g e
18. High Accuracy
The stack ensures no unmatched or misordered parentheses escape detection — offering
100% accuracy for valid input strings.

19. Easy Debugging

Since each operation is predictable (push or pop), debugging the logic or tracing the stack
behavior is straightforward.

20. Helpful in Compiler Construction

Compilers use the same logic for block validation in languages like C, Java, and Python —
especially for {} and indentation checks.

21. Supports Symbolic and Arithmetic Expressions

It works with variables, operators, and constants, not just plain brackets — suitable for
evaluating algebraic and logical formulas.

22. Adaptable to Different Programming Languages

Though implemented in Python, the same logic can be easily converted to Java, C++, or C
without much modification.

23. Provides Instant Feedback

When integrated with an input system, the algorithm can immediately indicate errors as
users type expressions, improving learning or development productivity.

46 | P a g e
 24. Robust Against Incorrect Input

It safely handles invalid or incomplete expressions (like missing closing brackets) without
crashing, demonstrating good error handling.

25. Forms Basis for Many Real-World Applications

Used in:

Compiler Design – Checking syntax and scope.

Text Editors – Auto-indentation and matching braces.

HTML/XML Validators – Ensuring proper tag nesting.

Mathematical Tools – Validating formula syntax.

11.Limitations of Student Record Management System Using Singly

Linked List in Python
1. Linear Search Time
• In a singly linked list, searching for a particular student requires traversing nodes
sequentially from the head.

• This means the search operation has linear time complexity O(n).

• For a small number of students, this is acceptable, but for large datasets, searching can
become slow.

Example:
Searching for Roll No 500 in a list of 1000 students requires traversing up to 1000 nodes.

2. No Random Access
• Unlike arrays or databases, a linked list does not support direct access to a specific node.
• To access the 10th student, you must start at the head and traverse 9 nodes first.
47 | P a g e
Impact:
This limits performance when frequent random access is required.

3. Increased Memory Usage

• Each node stores data + a pointer to the next node.

• The pointer consumes extra memory compared to storing only the data.

Observation:
For small datasets, this is negligible, but for large-scale student records, the additional memory
can add up.

4. Complexity in Reverse Traversal

• Singly linked lists only allow traversal in one direction (head to tail).

• Reverse operations, like printing records from the last student to the first, require extra
steps or additional data structures.

Example:
Displaying students in reverse order would require either recursion or creating a temporary stack.

5. No Built-in Persistent Storage

• The system stores data only in memory while the program is running.
• Once the program is closed, all records are lost unless manually saved to a file or database.

Impact:
This limits the system’s use for long-term record-keeping unless file handling or database
integration is added.

6. Manual Input Required

• Every record must be entered manually through the menu.

• Bulk addition of student records is not supported in the current system.

Observation:
Adding hundreds of students individually can be time-consuming.
48 | P a g e
7. Limited Scalability
• While linked lists handle dynamic data, very large datasets (thousands of students) may
reduce performance due to linear time operations like search, update, or delete.

Example:
Deleting Roll No 950 in a list of 1000 students requires traversing nearly the entire list.

8. Limited Reporting and Analytics

• The current system does not automatically generate reports or statistics like averages, top
performers, or grade distribution.

• Additional programming or integration with databases is required for advanced analytics.

Observation:
For detailed analysis, manual calculations or extra code is needed.

9. No Multi-User Access
• The system is designed for single-user operation.

• Multiple administrators cannot access or update the system simultaneously.

Impact:
Not suitable for large institutions without implementing a client-server or web-based solution.

10. Limited Error Handling

• While basic input validation exists, the system may not handle all exceptions, such as
invalid data types, empty input, or special characters in names.

Example:
Entering a string instead of a numeric value for Marks may crash the program unless additional
checks are added.

49 | P a g e
11. Lack of Advanced Features
• Features such as sorting, filtering, or searching by multiple fields are not included.

• Integrating these requires additional programming and logic.

Observation:
Advanced database features like queries or joins are not possible in this in-memory linked list
system.

12. Not Suitable for Very Large Institutions

• For schools or colleges with thousands of students, this system may be insufficient.

• A relational database system like MySQL or PostgreSQL is recommended for large-scale

operations.

13. Lack of User Authentication

• The system does not include any login or password protection.

• Anyone who opens the program can access or modify student records.

• This makes the system less secure, especially when used in shared environments.

14. No Data Validation for Input

• The system accepts user input without verifying formats or data types properly.

• For example, entering a string instead of a number in marks or roll number may cause an
error.

• Adding proper input validation would improve the reliability and accuracy of the data.

15. No Sorting Feature

• The linked list stores records in the order they are entered.
• It does not allow sorting records alphabetically (by name) or numerically (by roll number
or marks).
50 | P a g e
 • This makes it difficult to view data in an organized manner.

16. No Data Backup and Recovery

• Since data is stored in memory and not in a file or database, all data is lost once the
program is closed.
• The system has no automatic backup or recovery mechanism.
• This limits its usability for real-world institutional data storage.17. Command-Line
Based Interface
• The system runs only in the command prompt (text-based interface).
• It is not visually appealing or easy for non-technical users to operate.
• A GUI interface using Tkinter or PyQt would make it more user-friendly.

18. Limited Error Messages

• The program provides only basic feedback to the user (e.g., “Record not found”).
• More detailed messages, such as “Invalid Input” or “Empty Record List,” could improve
the experience and usability.

19. No Printing or Exporting Facility

• The system cannot print or export student data to formats like PDF, CSV, or Excel.
• In a real institution, such exporting features are useful for reporting and documentation.

20. Single Data Structure Dependency

• The entire system depends on a singly linked list.
• This limits functionality — for example, a doubly linked list could make deletion and
reverse traversal faster and easier.

51 | P a g e
12.Future Scope
The Balanced Parentheses Checker using Stack is a simple yet powerful program that lays the
foundation for various advanced computational and real-world applications. Although it efficiently
verifies whether parentheses are balanced in expressions, there is significant potential for
improvement

1. Multi-Line Expression Handling

Future versions can be designed to check multi-line expressions or entire
program files instead of single-line inputs, making it more useful for
code validation.

2. Enhanced Error Reporting

The system can be improved to pinpoint the exact position or index
where the imbalance occurs, instead of simply indicating that the
expression is unbalanced.

3. Auto-Correction Feature
A future update can automatically insert or suggest missing parentheses,
helping users quickly fix syntax issues without manual debugging.

52 | P a g e
4. Support for Additional Symbols
Apart from (), {}, and [], the checker can be expanded to include angle
brackets < > and custom delimiters used in different programming
languages.

5. Integration with IDEs and Code Editors

The algorithm can be built into IDE plugins (e.g., for VS Code,
PyCharm, or Sublime Text) to highlight bracket mismatches in real-time
as the user types.

6. GUI-Based Implementation
A Graphical User Interface (GUI) using libraries like Tkinter, PyQt, or
can make the system more interactive and user-friendly.

7. Web-Based Application
The checker can be converted into an online tool using Flask or Django,
allowing users to validate code snippets directly through a web browser.

8. Integration with HTML/XML Tag Checking

Future versions can be designed to validate nested HTML or XML tags,
ensuring correct structure in web documents.

53 | P a g e
9. Real-Time Bracket Matching Visualization
An interactive interface can visually display how the stack operates
showing which brackets are pushed and popped in real-time for
educational purposes.

10. Multi-Language Syntax Validation

The system can be enhanced to recognize syntax rules for different
programming languages like C, Java, Python, or JavaScript, making it a
multi-purpose syntax validator.

54 | P a g e
Conclusion
The Balanced Parentheses Checker using Stack project successfully demonstrates the
practical application of the stack data structure in solving real-world problems related to
expression validation and syntax checking.

By using the Last-In-First-Out (LIFO) principle, the algorithm efficiently checks whether
every opening parenthesis in a given expression has a corresponding and correctly placed
closing parenthesis.

The implementation in Python showcases how a simple yet powerful concept like stacks can
ensure logical correctness, structural balance, and syntactical accuracy of expressions used
in mathematics and programming. The project validates various types of brackets — (), {},
and [] — and accurately identifies mismatched, missing, or misplaced parentheses in both
simple and complex expressions.

Through testing and analysis, the system proved to be reliable, accurate, and efficient,
operating with a time complexity of O(n) and minimal memory requirements. The
algorithm not only serves as a strong foundational example for understanding stack
operations but also provides a practical framework for extending functionality into more
advanced systems such as compiler syntax checkers, HTML/XML tag validators, and
expression parsers.

This project reinforces the importance of data structures and algorithms in computer
science, particularly how abstract concepts like stacks can be applied to real-life software
development challenges.

It provides a solid base for students and developers to explore deeper areas like compiler
design, expression evaluation, and programming language parsing.

In conclusion, the Balanced Parentheses Checker stands as an efficient, scalable, and

educationally valuable application of stacks in Python — combining theoretical
understanding with practical implementation to ensure structural correctness in code and
mathematical expressions.

55 | P a g e
13.References
i. Prof. S.A.Purkar mam (DSP)
ii. Textbook of Data structure using python (313306)
iv. Microsoft edge/Google
v. Singly Linked List in Pythonhttps://www.geeksforgeeks.org/linked-
list-in-python/
vi. https://chatgpt.com/
vii. https://gemini.com/

56 | P a g e