lOMoARcPSD|27610193
DSA - E130941 - Assignment with answers
HND in Computing (ESOFT Metro Campus)
Studocu is not sponsored or endorsed by any college or university
Downloaded by TEST TEST (purpose30321@gmail.com)
lOMoARcPSD|27610193
Higher Nationals
Internal verification of assessment decisions – BTEC (RQF)
INTERNAL VERIFICATION – ASSESSMENT DECISIONS
Higher National Diploma in Computing
Programme title
Assessor
Internal Verifier
Unit 19 – Data Structures and Algorithms
Unit(s)
Assignment title
Specification, Implementation, and Assessment of Data Structures for a sample
scenario.
Student’s name
M.S. MARYAM RUQSHA
List which assessment criteria
the Assessor has awarded.
Pass
Merit
Distinction
INTERNAL VERIFIER CHECKLIST
Do the assessment criteria awarded match
those shown in the assignment brief?
Is the Pass/Merit/Distinction grade awarded
justified by the assessor’s comments on the
student work?
Has the work been assessed
accurately?
Is the feedback to the student:
Give details:
• Constructive?
• Linked to relevant assessment criteria?
• Identifying opportunities for
improved performance?
• Agreeing actions?
Does the assessment decision need
amending?
Y/N
Y/N
Y/N
Y/N
Y/N
Y/N
Y/N
Y/N
Assessor signature
Date
Internal Verifier signature
Date
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
1
lOMoARcPSD|27610193
Programme Leader signature (if required)
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
Date
2
lOMoARcPSD|27610193
Confirm action completed
Remedial action taken
Give details:
Assessor signature
Date
Internal Verifier
signature
Date
Programme Leader
signature (if required)
Date
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
3
lOMoARcPSD|27610193
Higher Nationals - Summative Assignment Feedback Form
Student Name/ID
M.S. MARYAM RUQSHA / E130941
Unit Title
Unit 19:
Assignment Number
1
Assessor
04/04/2023
Submission Date
Date Received 1st
submission
Re-submission Date
Date Received 2nd
submission
Data Structures and Algorithms
Assessor Feedback:
LO1 Examine different concrete data structures and it’s valid operations.
Pass, Merit &
P1
P2
M1
M2
Distinction Descripts
D1
LO2 Discuss the advantages, complexity of Abstract Data Type and importance concepts of
Object orientation.
Pass, Merit &
Distinction Descripts
P3
M3
D2
LO3 Implement, Demonstrate and evaluate complex ADT algorithm.
Pass, Merit &
Distinction Descripts
P4
P5
M4
D3
LO4 Examine the advantages of Independent data structures and discuss the need of
asymptotic analysis to assess the effectiveness of an algorithm.
Pass, Merit &
P6
P7
D4
M5
Distinction Descripts
Grade:
Assessor Signature:
Date:
Resubmission Feedback:
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
4
lOMoARcPSD|27610193
Grade:
Assessor Signature:
Date:
Internal Verifier’s Comments:
Signature & Date:
* Please note that grade decisions are provisional. They are only confirmed once internal and external moderation has taken place and
grades decisions have been agreed at the assessment board.
Assignment Feedback
Formative Feedback: Assessor to Student
Action Plan
Summative feedback
Feedback: Student to Assessor
Assessor signature
Date
Student signature
Date
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
5
lOMoARcPSD|27610193
Pearson Higher Nationals in
Computing
Unit 19: Data Structures & Algorithms
Assignment 01
M.S. MARYAM RUQSHA - COL00088920
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
6
lOMoARcPSD|27610193
General Guidelines
•
A Cover page or title page – You should always attach a title page to your assignment. Use previous
page as your cover sheet and make sure all the details are accurately filled.
• Attach this brief as the first section of your assignment.
• All the assignments should be prepared using a word processing software.
• All the assignments should be printed on A4 sized papers. Use single side printing.
• Allow 1” for top, bottom , right margins and 1.25” for the left margin of each page.
Word Processing Rules
•
The font size should be 12 point, and should be in the style of Time New Roman.
•
Use 1.5 line spacing. Left justify all paragraphs.
•
Ensure that all the headings are consistent in terms of the font size and font style.
•
Use footer function in the word processor to insert Your Name, Subject, Assignment No, and
Page Number on each page. This is useful if individual sheets become detached for any reason.
•
Use word processing application spell check and grammar check function to help editing your
assignment.
Important Points:
•
It is strictly prohibited to use textboxes to add texts in the assignments, except for the compulsory
information. eg: Figures, tables of comparison etc. Adding text boxes in the body except for the
before mentioned compulsory information will result in rejection of your work.
•
Carefully check the hand in date and the instructions given in the assignment. Late submissions
will not be accepted.
•
Ensure that you give yourself enough time to complete the assignment by the due date.
•
Excuses of any nature will not be accepted for failure to hand in the work on time.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
7
lOMoARcPSD|27610193
•
You must take responsibility for managing your own time effectively.
•
If you are unable to hand in your assignment on time and have valid reasons such as illness, you
may apply (in writing) for an extension.
•
Failure to achieve at least PASS criteria will result in a REFERRAL grade .
•
Non-submission of work without valid reasons will lead to an automatic RE FERRAL. You will then
be asked to complete an alternative assignment.
•
If you use other people’s work or ideas in your assignment, reference them properly using
HARVARD referencing system to avoid plagiarism. You have to provide both in-text citation and
a reference list.
•
If you are proven to be guilty of plagiarism or any academic misconduct, your grade could be
reduced to A REFERRAL or at worst you could be expelled from the course
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
8
lOMoARcPSD|27610193
Student Declaration
I hereby, declare that I know what plagiarism entails, namely to use another’s work and to present it as
my own without attributing the sources in the correct form. I further understand what it means to copy
another’s work.
•
I know that plagiarism is a punishable offence because it constitutes theft.
•
I understand the plagiarism and copying policy of Edexcel UK.
•
I know what the consequences will be if I plagiarize or copy another’s work in any of the
assignments for this program.
•
I declare therefore that all work presented by me for every aspect of my program, will be my own,
and where I have made use of another’s work, I will attribute the source in the correct way.
•
I acknowledge that the attachment of this document signed or not, constitutes a binding
agreement between myself and Pearson, UK.
•
I understand that my assignment will not be considered as submitted if this document is not
attached to the assignment.
maryamruqsha16@gmail.com
Student’s Signature:
(Provide E-mail ID)
04/04/2023
Date:
(Provide Submission Date)
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
9
lOMoARcPSD|27610193
Higher National Diploma in Business
Assignment Brief
Student Name /ID Number
Unit Number and Title
Academic Year
Unit Tutor
Assignment Title
M.S. MARYAM RUQSHA / E130941
Unit 19 :
Data Structures and Algorithms
2021/22
Specification, Implementation, and Assessment of Data Structures for a
sample scenario.
Issue Date
Submission Date
IV Name & Date
04/04/2023
Submission format
The submission should be in the form of a report, which contains code snippets (which must
be described well), text-based descriptions, and diagrams where appropriate. References to
external sources of knowledge must be cited (reference list supported by in-text citations)
using the Harvard Referencing style.
Unit Learning Outcomes:
LO1. Examine abstract data types, concrete data structures and algorithms.
LO2. Specify abstract data types and algorithms in a formal notation.
LO3. Implement complex data structures and algorithms.
LO4. Assess the effectiveness of data structures and algorithms.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
10
lOMoARcPSD|27610193
Assignment Brief and Guidance:
Scenario
ABC Pvt Ltd organizing Car Racing event across western province and they decided to have
maximum of 6 cars(participants) to compete.
There are totally 3 Rounds and at the end of each round lowest rank car will be eliminated
from the Race.
Each car has unique number, brand, sponsor and driver details.
In order to manage this particular event ABC Pvt Ltd decided to develop an Application.
Application functions are listed down.
1.Register Car Details
2.Delete a car
3.Insert 3 Rounds Results.
4.Find out the winners (1st,2nd,3rd)
5.Search for a particular car
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
11
lOMoARcPSD|27610193
Task 1: Examine and create data structure by simulating the above scenario and explain the
valid operations that can be carried out on this data structure.
Determine the operations of a queue and critically review how it is used to implement
function calls related to the above scenario.
Task 2: Implement the above scenario using the selected data structure and its valid
operations for the design specification given in task 1 by using java programming. Use
suitable error handling and Test the application using suitable test cases and illustrate the
system. Provide evidence of the test cases and the test results.
Task 3 : Registered Car details are stored from oldest to newest. Management of ABC Pvt Ltd
should be able to find from the newest to oldest registered car details. Using an imperative
definition, specify the abstract data type for the above scenario and implement specified ADT
using java programming and briefly discuss the complexity of chosen ADT algorithm. List
down the advantages of Encapsulation and Information hiding when using an ADT selected
for the above scenario.
“Imperative ADTs are basis for object orientation.” Discuss the above view stating whether
you agree or not. Justify your answer.
Task 4: ABC Pvt Ltd plans to visit all of these participants through the shortest path within a
day.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
12
lOMoARcPSD|27610193
Analyse the above operation by using illustrations, of two shortest path algorithms, specify
how it operates using a sample graph diagram. Sort the cars based on numbers with two
different sorting algorithms and critically review the performances of those two algorithms
by comparing them.
Task 5: Evaluate how Asymptotic analysis can be used to assess the effectiveness of an
algorithm and critically evaluate the different ways in which the efficiency of an algorithm
can be measured.
Critically review the sort of trade-offs exists when you use an ADT for implementing
programs. You also need to evaluate the benefits of using independent data structures for
implementing programs.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
13
lOMoARcPSD|27610193
Grading Rubric
Grading Criteria
Achieved
Feedback
LO1. Examine abstract data types, concrete
data structures and algorithms.
P1 Create a design specification for data
structures explaining the valid operations that
can be carried out on the structures.
P2 Determine the operations of a memory
stack and how it is used to implement
function calls in a computer.
M1 Illustrate, with an example, a concrete
data structure for a First In First out (FIFO)
queue.
M2 Compare the performance of two sorting
algorithms.
D1 Analyse the operation, using illustrations,
of two network shortest path algorithms,
providing an example of each.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
14
lOMoARcPSD|27610193
LO2. Specify abstract data types and
algorithms in a formal notation.
P3 Using an imperative definition, specify
the abstract data type for a software stack.
M3 Examine the advantages of
encapsulation and
information hiding when using an ADT.
D2 Discuss the view that imperative ADTs are
a basis for object orientation and, with
justification, state whether you agree.
LO3. Implement complex data structures and
algorithms.
P4 Implement a complex ADT and algorithm
in an executable programming language to
solve a well-defined problem.
P5 Implement error handling and report test
results.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
15
lOMoARcPSD|27610193
M4 Demonstrate how the implementation of
an ADT/algorithm solves a well-defined
problem.
D3 Critically evaluate the complexity of an
implemented ADT/algorithm.
LO4. Assess the effectiveness of data
structures and algorithms.
P6 Discuss how asymptotic analysis can be
used to assess the effectiveness of an
algorithm.
P7 Determine two ways in which the
efficiency of an algorithm can be measured,
illustrating your answer with an example.
M5 Interpret what a trade-off is when
specifying an ADT using an example to
support your answer.
D4 Evaluate three benefits of using
implementation independent data
structures.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
16
lOMoARcPSD|27610193
Table of Contents
Acknowledgement ........................................................................................................................ 22
1.
Data Structure and Algorithm................................................................................................ 23
1.1
Design Specifications for Data Structure ....................................................................... 23
1.2
Fundamental kinds of Data Structures ........................................................................... 25
1.3 Algorithms ........................................................................................................................... 26
1.4 The accompanying PC issues can be settled using Data Structures .................................... 28
2. Create data structure by simulating the above scenario and explain the valid operations that
can be carried out on this data structure........................................................................................ 29
2.1 Data structure for given scenario. ....................................................................................... 29
2.1.1 Linked list Data structure. ............................................................................................ 29
2.1.1.1 Linked List Representation .................................................................................... 30
2.1.1.2 Uses of Linked list ................................................................................................. 30
2.1.1.3 Types of Linked list ............................................................................................... 31
2.1.1.4 Performing various operations on linked list ......................................................... 32
2.1.2 LIFO principle of Stack ................................................................................................ 34
2.1.2.1 Basic operation of stack ......................................................................................... 36
2.1.2.2 Flowchart for implementing stack using array. ..................................................... 39
2.1.2.3 Representation of stack .......................................................................................... 42
2.1.3 Stack memory implementation for PCs. ....................................................................... 43
3.
Illustrate, with an example, a concrete data structure for a First in First out (FIFO) queue. 47
3.1 Queue Data Structure .......................................................................................................... 47
4.
Illustrate, with an example, a concrete data structure for a First in First out (FIFO) queue. 52
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
17
lOMoARcPSD|27610193
4.1 Software Stack..................................................................................................................... 52
4.2 Abstract Data Type (ADT) .................................................................................................. 53
4.2.1 Common Examples of ADTs ....................................................................................... 55
4.2.1.1 List ADT ................................................................................................................ 55
4.2.1.2 Stack ADT ............................................................................................................. 57
4.2.1.3 Queue ADT ............................................................................................................ 58
4.2.2 Stack, Queue and List Abstract Data Type Comparison .............................................. 59
4.3 Selecting the suitable ADT for the scenario and implementing it ...................................... 60
5. Implement a complex ADT and algorithm in an executable programming language to solve
a well-defined problem. ................................................................................................................ 61
5.1 Describe the scenario and design the system ...................................................................... 61
5.2 Implementation the system.................................................................................................. 62
5.2.1 Full functionable code which I used in my application ................................................ 69
5.3 Implementation of the fully commented code..................................................................... 77
5.4 Output of the codes ............................................................................................................. 83
5.5 Complexity of Stack ADT .................................................................................................. 89
5.6 Encapsulation ...................................................................................................................... 90
5.6.1 Advantages of using Encapsulation .............................................................................. 92
6.
Implement Error Handling and Report Test Results. ............................................................ 94
6.1 Error Handling..................................................................................................................... 94
6.1.1 Option and Unwrap ...................................................................................................... 96
6.1.2 Panic ............................................................................................................................. 99
6.1.3 Result .......................................................................................................................... 100
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
18
lOMoARcPSD|27610193
6.1.4 Multiple error type ...................................................................................................... 102
6.1.5 Iterative over results ................................................................................................... 103
6.1.6 Handling Errors using Do-Catch ................................................................................ 107
6.1.7 Changing Error over to Option values ........................................................................ 108
6.1.8 Bugs Versus exceptions .............................................................................................. 109
6.1.9 Error handling implementation ................................................................................... 109
6.2 Test report ......................................................................................................................... 112
6.2.1 Why test report is important. ...................................................................................... 113
6.2.2 What does test report contain ..................................................................................... 114
6.2.3 Test results screen shot for given scenario. ................................................................ 115
7.
Discuss how asymptotic analysis can be used to assess the effectiveness of an algorithm. 118
7.1 Asymptotic analysis .......................................................................................................... 118
7.2 Most pessimistic scenario and Average-Case Analysis .................................................... 119
7.3 Calculation Efficiency and Asymptotic Analysis ............................................................. 120
7.3.1 Issue with timing code ................................................................................................ 122
7.3.2 Analysis Framework ................................................................................................... 123
7.3.3 Asymptotic notation ................................................................................................... 125
8. Determine two ways in which the efficiency of an algorithm can be measured, illustrating
your answer with an example. .................................................................................................... 128
8.1 Algorithm Efficiency......................................................................................................... 128
8.1.1 Time complexity ......................................................................................................... 128
8.1.2 Space complexity........................................................................................................ 129
9.
Conclusion ........................................................................................................................... 140
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
19
lOMoARcPSD|27610193
List of Figures
Figure 1: LIFO .............................................................................................................................................. 34
Figure 2: Flowchart for Push () Operation .................................................................................................. 39
Figure 3: Flowchart for Pop () Operations .................................................................................................. 40
Figure 4: Flowchart for Peek () Operations ................................................................................................. 41
Figure 5: Stack Representation ................................................................................................................... 42
Figure 6: Stack functioning Principle........................................................................................................... 45
Figure 7: Car class........................................................................................................................................ 62
Figure 8: Main Class .................................................................................................................................... 63
Figure 9: Function ....................................................................................................................................... 63
Figure 10: Case 1 ......................................................................................................................................... 64
Figure 11: Case 2 ......................................................................................................................................... 65
Figure 12: Case 3 ......................................................................................................................................... 66
Figure 13: Case 4 ......................................................................................................................................... 67
Figure 14: Case 5 ......................................................................................................................................... 68
Figure 15: Function list................................................................................................................................ 83
Figure 16: Case 1 Output ............................................................................................................................ 83
Figure 17: Case 1 Output 2.......................................................................................................................... 84
Figure 18: Delete a car Case 2 ..................................................................................................................... 85
Figure 19: Case 3 ......................................................................................................................................... 86
Figure 20: Case 4 ......................................................................................................................................... 87
Figure 21: Case 5 ......................................................................................................................................... 88
Figure 22: Case 6 ......................................................................................................................................... 88
Figure 23: Encapsulation example .............................................................................................................. 91
Figure 24: Error Handling ............................................................................................................................ 94
Figure 25: Error log ................................................................................................................................... 109
Figure 26: Try catch1................................................................................................................................. 110
Figure 27: Try catch 2 ................................................................................................................................ 111
Figure 28: Test cycle.................................................................................................................................. 115
Figure 29: Functions .................................................................................................................................. 116
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
20
lOMoARcPSD|27610193
Figure 30: Defect density .......................................................................................................................... 116
Figure 31: Defect Fixed Ratio .................................................................................................................... 117
Figure 32: Θ Notation (theta).................................................................................................................... 132
Figure 33: Ω Notation................................................................................................................................ 133
Figure 34: Big O notation .......................................................................................................................... 135
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
21
lOMoARcPSD|27610193
Acknowledgement
First and foremost I wish to thank my lord and my parents who is my constant source of help,
strength and support and who is truly is my all in all. A very big thank you to our course
Coordinator Miss. Chathurika and Our Data Structure & Algorithms module Lecturer Miss. Navodi
and all the other lecturers for all the support, patience guidance and valuable advice they gave
me throughout this assignment, without them this project would not have been possible. I
sincerely acknowledge and thank my mother, my father and my friends who gave moral support
for me to complete the project duly. I am thankful and fortunate enough to get constant
encouragement, support and guidance from my family who sacrificed their works and helped me
in successfully my project work. I would also like to take this opportunity to thank Esoft for giving
me such a great opportunity. Thank you all.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
22
lOMoARcPSD|27610193
1. Data Structure and Algorithm
The usage of a data structure allows for the efficient organization and storage of data in a computer.
Hash tables, trees, graphs, linked lists, and arrays are examples of common data structures. Data
structures offer a way to efficiently manage massive volumes of data for a variety of applications,
including databases, search engines, and video games.
A set of instructions or procedures used to solve a problem or carry out a task is known as an
algorithm. In computer programming, algorithms are used to process data, carry out calculations,
and reach decisions. They can be used in a variety of programming languages and are an essential
component of computer science. Effective algorithms are crucial for tackling complicated issues
and can considerably boost the speed of computer applications. The study of algorithms involves
understanding their properties such as correctness, efficiency, and complexity.
1.1 Design Specifications for Data Structure
Design specifications for a data structure typically include:
1. Purpose and Functionality: The purpose and functionality of the data structure should be
clearly defined. This includes what types of data it will store, how it will be accessed, and
what operations can be performed on it.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
23
lOMoARcPSD|27610193
2. Implementation Details: Implementation details should be provided, including the
programming language to be used, the platform it will run on, and any specific memory or
performance requirements.
3. Performance Requirements: The data structure should be designed to meet performance
requirements such as memory usage, time complexity of operations, and scalability.
4. Error Handling: Error handling should be defined for situations such as invalid input or
overflow of data.
5. Security: Any security requirements such as access control or data encryption should be
defined.
6. Extensibility: The data structure should be designed with extensibility in mind, so that it
can be easily modified or extended in the future.
7. Testing and Verification: Test cases should be specified to verify that the data structure
functions as intended, and that it meets performance requirements.
8. Documentation: Documentation should be provided to explain how to use the data
structure, its limitations, and any assumptions made during design.
The design specifications for a data structure should, in general, give a clear and comprehensive
understanding of how the data structure is meant to operate as well as how it should be
implemented and evaluated.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
24
lOMoARcPSD|27610193
1.2 Fundamental kinds of Data Structures
There are several fundamental kinds of data structures. Here are some of the most common:
1. Arrays: An array is a collection of elements of the same data type that are stored in
contiguous memory locations. It is used for storing and accessing a fixed number of
elements efficiently.
2. Linked Lists: A linked list is a collection of elements, where each element (node) contains
a value and a reference (pointer) to the next node. It is used for storing and accessing a
variable number of elements efficiently.
3. Stacks: A stack is a collection of elements that allows access only to the last element
inserted (LIFO – last in, first out). It is used for keeping track of the state of a program or
for solving problems that can be solved using the LIFO principle.
4. Queues: A queue is a collection of elements that allows access only to the first element
inserted (FIFO – first in, first out). It is used for managing resources, handling
interruptions, and scheduling tasks.
5. Trees: A tree is a collection of nodes connected by edges. It is used for representing
hierarchical data, such as a file system or the structure of a web page.
6. Graphs: A graph is a collection of vertices (nodes) connected by edges. It is used for
representing complex relationships between objects, such as social networks or road
networks.
7. Hash Tables: A hash table is a collection of key-value pairs that allows access to elements
in constant time on average. It is used for efficient searching and indexing of data.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
25
lOMoARcPSD|27610193
Many algorithms and computer programs use these data structures as their basic building
elements. Choosing the appropriate data structure for a given issue is essential for creating
effective algorithms and programs because each data structure has strengths and weaknesses.
1.3 Algorithms
An algorithm is a set of clear instructions for resolving a dilemma or carrying out a particular job.
Algorithms are the fundamental units of computer programs and are crucial for effectively tackling
challenging computational issues.
Algorithms are a collection of rules intended to solve a particular issue or carry out a particular
job. They are an essential component of computer science and are widely used in data processing,
programming, and other technological fields.
Sorting algorithms, searching algorithms, graph algorithms, optimization algorithms, and many
other kinds of algorithms can all be categorized. They can be represented in a variety of ways,
such as programming languages, flowcharts, and pseudo code.
An algorithm's accuracy, running time, and memory utilization are just a few examples of the
factors that affect an algorithm's efficiency and effectiveness. Algorithm design is therefore a
fundamental component of computer science, and researchers are constantly trying to create new
and improved algorithms to address ever-more-complex issues.
The binary search algorithm, bubble sort, quicksort, and Dijkstra's algorithm for shortest route
problems are a few of the most well-known algorithms. Here are some common types of
algorithms:
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
26
lOMoARcPSD|27610193
1. Sorting algorithms: Sorting algorithms are used to rearrange a collection of elements in a
specific order, such as ascending or descending order. Some popular sorting algorithms
include bubble sort, quicksort, and merge sort.
2. Searching algorithms: Searching algorithms are used to find a specific element or value
in a collection of elements. Some popular search algorithms include linear search and
binary search.
3. Path finding algorithms: Path finding algorithms are used to find the shortest path
between two points in a graph or a grid. Some popular path finding algorithms include
Dijkstra's algorithm and A* algorithm.
4. Compression algorithms: Compression algorithms are used to reduce the size of a file or
data without losing significant information. Some popular compression algorithms include
Huffman coding and Lempel-Ziv-Welch (LZW) algorithm
5. Cryptographic algorithms: Cryptographic algorithms are used to ensure the security and
confidentiality of data by encrypting or decrypting it. Some popular cryptographic
algorithms include RSA, AES, and SHA.
6. Machine learning algorithms: Machine learning algorithms are used to make predictions
or decisions based on large amounts of data. Some popular machine learning algorithms
include decision trees, neural networks, and support vector machines.
In many disciplines, including computer science, mathematics, engineering, and economics,
algorithms are used. It is essential to comprehend algorithms and how they are used in order to
effectively solve complex problems and create successful software systems.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
27
lOMoARcPSD|27610193
1.4 The accompanying PC issues can be settled using Data Structures
A key idea in computer science and programming, data structures are used to arrange and store
data in a way that makes it easy to handle and retrieve it later. Although data structures can be
employed to address a variety of computing issues, they are not frequently employed to address
hardware or system-level issues with computers. However, data structures can be used to enhance
the efficiency of computer software programs and algorithms, which tangentially aids in the
resolution of some computer-related problems. For instance, if a computer application is sluggish
or unresponsive as a result of ineffective data storing and retrieval, using the right data structure
can enhance performance and fix the problem.
Data structures can also be used to effectively manage and process vast amounts of data, which
can help with problems with data management and storage. For instance, utilizing a hash table data
structure can facilitate quicker data retrieval and searching, which can assist in resolving issues
with slow database searches or ineffective data storage. In conclusion, even though data structures
themselves might not be able to handle some common computer issues directly, they can be used
to enhance the functionality of software programs and algorithms, which might be able to do so.
Data Structures can be used to solve the following PC concerns

Fibonacci number series

Backpack issue

Pinnacle of Hanoi

All pair most limited way by Floyd-Warshall

Most limited way by Dijkstra

Venture booking
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
28
lOMoARcPSD|27610193
2. Create data structure by simulating the above scenario and explain
the valid operations that can be carried out on this data structure
2.1 Data structure for given scenario.
Stack data structures and linked list data structures were utilized by the author to create the application for
ABC Pvt Ltd. Stacks are linear data structures that adhere to the Last in First out rule (LIFO). This suggests
that the final item to be removed from the stack does so first. When it comes to managing dynamic data
items, a linked list is the most desired data structure. A node is a type of data element found in linked lists.
Moreover, each node has two fields: one field contains data, and the other field contains an address that
maintains a link to the node after it.
2.1.1 Linked list Data structure.
A linked list is a group of links that includes stuff. There is a relationship between each link and
another link. The second most used data structure is the linked list, behind the array. The key words
for understanding the concept of a linked list are listed below.
Link − Each link of a linked list can store data called an element.
Next − Each link of a linked list contains a link to the next link called Next.
Linked List − A Linked List contains the connection link to the first link called First (Anon., n.d.).
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
29
lOMoARcPSD|27610193
2.1.1.1 Linked List Representation
Linked list can be visualized as a chain of nodes, where every node points to the next node.
As per the above illustration, the following are the important points to be considered.

Linked List contains a link element called first.

Each link carries a data field(s) and a link field called next.

Each link is linked with its next link using its next link.

Last link carries a link as null to mark the end of the list (Anon., n.d.).
2.1.1.2 Uses of Linked list
Linked lists are a fundamental data structure in computer science and are commonly used in
programming and software development. Here are some of the most common uses of linked lists:
1. Implementing stacks and queues: Linked lists are used to implement stacks and queues
because they support efficient insertion and deletion at one end of the list.
2. Dynamic memory allocation: Linked lists are used to allocate and deallocate memory
dynamically at run-time. For example, in C programming language, the malloc and free
functions are used to allocate and deallocate memory for linked lists.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
30
lOMoARcPSD|27610193
3. Implementing hash tables: Linked lists are used to resolve collisions in hash tables. In a
hash table, if two keys hash to the same index, they are stored in a linked list at that index.
4. Representing sparse matrices: A sparse matrix is a matrix that contains mostly zeros.
Linked lists are used to represent sparse matrices because they can efficiently store only
the non-zero elements.
5. Music and video playlists: Linked lists can be used to implement music and video playlists.
Each node in the linked list represents a song or a video, and the links represent the order
in which they are played.
6. Navigation systems: Linked lists are used in navigation systems to represent the sequence
of directions to reach a destination. Each node in the linked list represents a direction, and
the links represent the order in which they are followed.
7. Graphs: Linked lists are used to represent graphs, where each node represents a vertex, and
the links represent the edges connecting the vertices.
Overall, linked lists are a versatile data structure that can be used in many different applications,
making them an essential tool for software developers and computer scientists.
2.1.1.3 Types of Linked list
There are several types of linked lists, including:
1. Singly linked list: In a singly linked list, each node has only one link pointing to the next
node in the list.
2. Doubly linked list: In a doubly linked list, each node has two links: one pointing to the next
node and another pointing to the previous node in the list. This allows for efficient traversal
in both directions.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
31
lOMoARcPSD|27610193
3. Circular linked list: In a circular linked list, the last node points to the first node in the list,
creating a circular structure. This allows for efficient traversal from the last node back to
the first node.
4. Singly linked list with a tail pointer: In this type of linked list, there is an additional pointer
to the last node in the list, which allows for efficient insertion at the end of the list.
A doubly linked list with a tail pointer combines two linked lists: a single linked list with a tail
pointer and a doubly linked list. With a tail pointer, it combines the advantages of a doubly linked
list and a single linked list.
2.1.1.4 Performing various operations on linked list
Here are some common operations that can be performed on a linked list:
1. Traversing the linked list: This involves visiting each node in the list sequentially, starting
from the head node and following the links until the end of the list is reached.
2. Inserting a node: This involves creating a new node and inserting it into the list at a specific
position. The node can be inserted at the beginning of the list (as the new head node), at
the end of the list, or in the middle of the list (before or after a specific node).
3. Deleting a node: This involves removing a specific node from the list. The node can be
deleted from the beginning of the list (as the head node), from the end of the list, or from
the middle of the list (after locating the node).
4. Searching for a node: This involves locating a specific node in the list based on a given
value or key. The search can start from the head node and continue until the end of the list
is reached or the node is found.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
32
lOMoARcPSD|27610193
5. Reversing the linked list: This involves reversing the order of the nodes in the list, so that
the last node becomes the head node and vice versa.
6. Concatenating two linked lists: This involves joining two linked lists together, so that the
last node of the first list points to the head node of the second list.
7. Sorting the linked list: This involves arranging the nodes in the list in a specific order, such
as ascending or descending order based on the node values.
8. Splitting the linked list: This involves dividing a linked list into two separate lists based on
a specific condition or position. For example, a list can be split into two lists with odd and
even values.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
33
lOMoARcPSD|27610193
2.1.2 LIFO principle of Stack
Figure 1: LIFO
The LIFO principle, or "Last In, First Out," is the fundamental concept behind a stack data
structure. A stack is a linear data structure that allows elements to be added and removed from one
end only, which is called the top of the stack.
In a stack, elements are added to the top of the stack, and the most recently added element is always
at the top of the stack. Similarly, elements are removed from the top of the stack, so the element
that was most recently added is the first one to be removed.
The LIFO principle can be thought of as a stack of plates in a cafeteria. When plates are added to
the stack, they are placed on top of the other plates. When a customer wants a plate, they take the
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
34
lOMoARcPSD|27610193
top plate off the stack, which is the last plate that was added. As plates are used, they are removed
from the top of the stack in the reverse order that they were added.
In a computer program, stacks are often used to keep track of function calls, where each function
call creates a new stack frame that is added to the top of the call stack. When the function returns,
its stack frame is removed from the top of the call stack, allowing the program to continue
executing from the previous point in the program.
Here's an example to illustrate the LIFO principle of a stack:
Suppose you are at a cafeteria, and you need to stack a set of plates. The LIFO principle would
mean that you would place the most recently used plate at the top of the stack, and when a plate is
needed, it would be taken from the top of the stack, which is the last plate that was placed.
For example, imagine you have the following sequence of plate stacking and plate usage:
1. You place a blue plate on the table.
2. You place a red plate on top of the blue plate.
3. You place a green plate on top of the red plate.
4. You take a plate from the top of the stack, which is the green plate.
5. You place a yellow plate on top of the stack.
6. You take a plate from the top of the stack, which is the yellow plate.
7. You take a plate from the top of the stack, which is the red plate.
In this example, the LIFO principle ensures that the most recently used plate is always at the top
of the stack. When a plate is needed, it is taken from the top of the stack, which is the last plate
that was placed. This is like how a stack data structure works in computer programming, where
elements are added to the top of the stack and removed from the top of the stack in reverse order
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
35
lOMoARcPSD|27610193
2.1.2.1 Basic operation of stack
The basic operations of a stack are as follows:
1. Push: This operation adds an element to the top of the stack. When an element is pushed
onto the stack, it becomes the new top element.
2. Pop: This operation removes the top element from the stack. When an element is popped
from the stack, the element just below it becomes the new top element.
3. Peek/Top: This operation returns the top element of the stack without removing it. It simply
returns the value of the element at the top of the stack.
4. Is Empty: This operation checks whether the stack is empty or not. It returns a boolean
value (true or false) based on whether the stack is empty or not.
These four basic operations are sufficient to implement any other operations or algorithms that
may be required using a stack data structure. Here's an example implementation of a stack data
structure using these basic operations in Java:
import java.util.*;
public class StackExample {
private ArrayList<Integer> stack;
public StackExample() {
stack = new ArrayList<>();
}
public void push(int value) {
stack.add(value);
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
36
lOMoARcPSD|27610193
}
public int pop() {
if (!isEmpty()) {
int topIndex = stack.size() - 1;
int topValue = stack.get(topIndex);
stack.remove(topIndex);
return topValue;
}
return -1; // Or throw an exception
}
public int peek() {
if (!isEmpty()) {
int topIndex = stack.size() - 1;
return stack.get(topIndex);
}
return -1; // Or throw an exception
}
public boolean isEmpty() {
return stack.isEmpty();
}
}
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
37
lOMoARcPSD|27610193
In this implementation, we have defined the basic operations of push, pop, peek/top, and isEmpty
for a stack data structure using an ArrayList. The push operation adds an element to the end of the
list, while the pop operation removes and returns the last element of the list if the list is not empty.
The peek operation returns the last element of the list without removing it if the list is not empty.
Finally, the isEmpty operation returns a boolean value based on whether the list is empty or not.
Position of top
Status of stack
-1
Stack is Empty
0
Only one element in Stack
N-1
Stack is Full
N
Overflow state of Stack
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
38
lOMoARcPSD|27610193
2.1.2.2 Flowchart for implementing stack using array.
Flowchart for Push () Operation
Figure 2: Flowchart for Push () Operation
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
39
lOMoARcPSD|27610193
Flowchart for Pop () Operation
Figure 3: Flowchart for Pop () Operations
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
40
lOMoARcPSD|27610193
Flowchart for Peek () Operation
Figure 4: Flowchart for Peek () Operations
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
41
lOMoARcPSD|27610193
2.1.2.3 Representation of stack
A stack may be represented in the memory in various ways. There are two main ways: using a onedimensional array and a single linked list. Array Representation of Stacks: First we have to allocate
a memory block of sufficient size to accommodate the full capacity of the stack. Then, starting
from the first location of the memory block, the items of the stack can be stored in a sequential
fashion. In Figure, Itemi denotes the ith item in the stack; l and u denote the index range of the
array in use; usually the values of these indices are 1 and SIZE respectively. TOP is a pointer to
point the position of the array up to which it is filled with the items of the stack. With this
representation, the following two ways can be stated:
EMPTY: TOP < l FULL: TOP ≥ u
Figure 5: Stack Representation
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
42
lOMoARcPSD|27610193
Linked List Representation of Stacks: Although array representation of stacks is very easy and
convenient, it allows the representation of only fixed sized stacks. In several applications, the size
of the stack may vary during program execution. An obvious solution to this problem is to
represent a stack using a linked list. A single linked list structure is sufficient to represent any
stack. Here, the DATA field is for the ITEM, and the LINK field is, as usual, to point to the next'
item. Above Figure b depicts such a stack using a single linked list. In the linked list representation,
the first node on the list is the current item that is the item at the top of the stack and the last node
is the node containing the bottom-most item. Thus, a PUSH operation will add a new node in the
front and a POP operation will remove a node from the front of the list.
2.1.3 Stack memory implementation for PCs.
Each running PC software makes use of a section of memory known as the stack to enable certain
functions to function properly. The stack is used by the machine to carry work contentions, store
return data, reserve registers for later reclamation, and for close-by variables. A stack outline is
the area of the stack reserved for a single capacity call. As a result, a new space (i.e., stack outline)
is created on the stack for each capacity call.
The stack of the computer resides in memory's very top regions. Stack is a stack information
structure, as suggested by its name, with the "top" of the stack moving from high value locations
towards poor quality addresses. We employ pop D to remove the top value from the stack and
place it into a destination, and we employ push S to push the source into the stack (for example a
register or memory area). As a pointer to the top of the stack, which is also the top of the topmost
stack outline, we use the stack register, %esp.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
43
lOMoARcPSD|27610193
Stack memory is a special type of memory that is used for temporary data storing when we need
to read data exactly the opposite way from how it was written in, without thinking about getting
sorted out information tending.
Stack memory is a sequential memory with clear access restrictions that only allow writing to and
reading from one location in the memory, known as the top of the stack. A shift of all data stored
in subsequent regions by one scenario down inside and out of this line is made concurrently by the
stack memory, which serves as a line to which information can be assembled at the top of the stack.
Only looking at the top of the stack, the readout from the stack is plausible.
The readout causes data from the top of the stack to be removed, and new data from the depth of
the stack is created in its place, shifting all previously stored data one position upward. The line
then switches to a Last-In-First-Out format.
The stack memory operates similarly to a rifle's magazine in that presenting a new cartridge causes
the magazine's normally-remaining cartridges to move to the inside and outside, and firing a
cartridge (a shot) causes the top cartridge to be removed and replaced by the first cartridge that
was previously stored beneath the used one.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
44
lOMoARcPSD|27610193
Figure 6: Stack functioning Principle
In the memory of a computer, information is kept in linear information structures called memory
stacks. They could also be referred to as lines. A stack of information should regularly contain
similar types of information. Every function on your computer, including the main() function,
creates temporary variables that are stored in a unique region of memory. The stack is a "LIFO"
(last in, first out) data structure that the CPU carefully monitors and advances. Another variable
is "pushed" into the stack every time a capacity declares another one. Then, at that point, every
variable that was added to the stack by a capacity is released whenever that capacity exists (in
other words, they are erased).
This region of memory becomes available for other stack variables after a stack variable is
released. Using the stack to hold variables has the advantage of managing memory for you.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
45
lOMoARcPSD|27610193
Memory doesn't need to be allocated manually or released if you no longer require it. Also, reading
from and writing to stack variables happen very quickly because of how efficiently the CPU
organizes stack memory. The idea that when a capacity exists, each of its variables is popped off
of the stack (and subsequently lost till the end of time) is essential to comprehending the stack.
Stack variables are consequently close in nature. This is related to a previous concept we discussed,
factor extension, or local vs global variables. Trying to access a variable that was created on the
stack inside of a capacity from a location in your program outside of that capacity (for example,
after that capacity has left) is a common error in C programming. Another aspect of the stack to
keep in mind is that the maximum size of variables that can be stored on it has a cutoff (which
varies with OS). Variables allotted on the heap are an exception to this rule.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
46
lOMoARcPSD|27610193
3. Illustrate, with an example, a concrete data structure for a First in
First out (FIFO) queue.
3.1 Queue Data Structure
A queue is a linear data structure that follows the First in First out (FIFO) principle. It is an ordered
collection of elements in which an element is added to the end of the queue and removed from the
front of the queue.
The two basic operations of a queue are:
1. Enqueue - adding an element to the end of the queue.
2. Dequeue - removing the element from the front of the queue.
Queues are used in a variety of applications such as scheduling, resource allocation, and breadthfirst search algorithms.
Some of the key properties of a queue are:

FIFO: The first element added to the queue is the first one to be removed.

Linear: The elements are stored in a linear sequence.

Dynamic size: The size of the queue can be changed dynamically as elements are added or
removed.

Limited access: The only way to access elements in the middle of the queue is to dequeue
elements until the desired element is reached.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
47
lOMoARcPSD|27610193
Queues can be implemented using different data structures such as arrays, linked lists, or circular
buffers. The choice of data structure depends on the specific use case and performance
requirements.
Common operations on a queue include enqueue, dequeue, peek (viewing the element at the front
of the queue without removing it), checking if the queue is empty or full, and getting the size of
the queue.
Here's an example implementation of a First in First out (FIFO) queue in Java using an array-based
circular buffer:
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
48
lOMoARcPSD|27610193
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
49
lOMoARcPSD|27610193
In this implementation, we define a Queue class with four methods:

isEmpty(): Returns true if the queue is empty, false otherwise.

isFull(): Returns true if the queue is full, false otherwise.

enqueue(int value): Adds an element to the end of the queue by incrementing rear and
adding the new element to the buffer array.

dequeue(): Removes and returns the element at the front of the queue by incrementing
front and returning the value at the corresponding index of the buffer array.

peek(): Returns the element at the front of the queue without removing it.

size(): Returns the current size of the queue.
The circular buffer allows for efficient use of memory and avoids the need to shift elements in the
array when the front pointer changes.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
50
lOMoARcPSD|27610193
Here's an example of how to use this implementation:
In this example, I create a new Queue object with a maximum capacity of 3, add three elements
to the queue using enqueue, remove the first element using dequeue, and then peek at the front
element and get the current size of the queue using peek and size, respectively
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
51
lOMoARcPSD|27610193
4. Illustrate, with an example, a concrete data structure for a First in
First out (FIFO) queue.
4.1 Software Stack
A software stack refers to a set of software components and technologies that are used to create
and operate a software application or system. A typical software stack includes several layers of
software that work together to provide a complete solution.
For example, a web application software stack could include the following layers:
1. Operating system: The lowest layer of the stack that provides the foundation for running
the application. Examples of popular operating systems include Linux, Windows, and
macOS.
2. Server software: This layer includes software such as web servers, application servers, and
database servers. Examples of server software include Apache, Nginx, Tomcat, and
MySQL.
3. Frameworks and libraries: These are software components that provide pre-built
functionality to the application. Examples of frameworks include React, Angular, and
Django, while popular libraries include jQuery, React Native, and NumPy.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
52
lOMoARcPSD|27610193
4. Application code: This is the custom code that
is written to provide the specific functionality of
the application. It is typically written in programming languages such as Python, Java, or
JavaScript.
5. User interface: This layer includes the graphical user interface (GUI) of the application,
which allows users to interact with the application.
Overall, a software stack represents the complete set of technologies and software components
required to build, run, and manage a software application. It usually consists of several layers of
software, each of which provides a different level of functionality and interacts with the layers
above and below it
4.2 Abstract Data Type (ADT)
An abstract data type (ADT) is a high-level data type that is defined by its behavior and operations,
independent of its implementation details. It is an abstraction of a data structure that describes what
operations can be performed on it and what their behavior and properties are, without specifying
how those operations are implemented.
The definition of an ADT includes the set of operations that can be performed on it, their input and
output parameters, and any preconditions or postconditions that apply to those operations. The
behavior and properties of an ADT are defined by the behavior of its operations and any constraints
or invariants that apply to its data.
ADTs are useful because they provide a level of abstraction that enables software designers and
developers to think about data structures and algorithms at a higher level, without being concerned
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
53
lOMoARcPSD|27610193
with their low-level details. This allows for modular, reusable, and extensible software design, as
ADTs can be used as building blocks to construct more complex data structures and algorithms.
Stacks are a useful abstract data type with a variety of applications in computer science and
programming. Here are some common employment of ADT Stack:
1. Function call stack: One of the most common employment of the stack is in the
implementation of function calls in a program. Each function call is pushed onto the stack,
and when the function completes, it is popped from the stack, allowing the program to
return to the previous point of execution.
2. Expression evaluation: Stacks can be used in expression evaluation, where operators and
operands are pushed onto the stack and then popped off in the correct order to evaluate the
expression.
3. Undo/redo functionality: Stacks can be used to implement undo/redo functionality in a text
editor or other applications. Each operation performed by the user is pushed onto the stack,
and the most recent operation can be undone by popping it from the stack.
4. Backtracking: Stacks can be used in backtracking algorithms, where a sequence of choices
are made and then potentially reversed if the choices lead to a dead end.
5. Parsing: Stacks can be used in parsing, where tokens are pushed onto the stack and then
popped off as the parser processes them.
6. Memory allocation: Stacks can be used in memory allocation, where memory is allocated
in a stack-like fashion and then deallocated in the reverse order.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
54
lOMoARcPSD|27610193
Overall, stacks are a versatile and powerful tool with many practical applications in computer
science and programming.
4.2.1 Common Examples of ADTs
4.2.1.1 List ADT
List ADT (Abstract Data Type) is a data structure that allows storage and manipulation of a
collection of elements. It provides a set of operations that can be used to insert, delete, and retrieve
elements from the list. The list ADT does not specify how the elements are stored in memory or
how the operations are implemented; it only defines the interface for accessing and manipulating
the elements.
The basic operations of the list ADT include:
1. Insertion: This operation adds an element to the list at a specified position.
2. Deletion: This operation removes an element from the list at a specified position.
3. Retrieval: This operation retrieves an element from the list at a specified position.
4. Traversal: This operation allows the user to traverse the list from the beginning to the end,
accessing each element in turn.
5. Size: This operation returns the number of elements in the list.
6. Search: This operation searches for a specific element in the list.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
55
lOMoARcPSD|27610193
The list ADT can be implemented using different data structures such as arrays, linked lists, and
dynamic arrays. The choice of data structure depends on the specific requirements of the
application. The list ADT is widely used in many applications such as databases, file systems, and
programming languages, making it a fundamental concept in computer science.
Here are some common operations that are typically supported by the List ADT:
1. Append: Adds an element to the end of the list.
2. Prepend: Adds an element to the beginning of the list.
3. Insert: Adds an element at a specified position within the list.
4. Remove: Removes an element from the list at a specified position.
5. Get: Returns the element at a specified position within the list.
6. Set: Changes the value of the element at a specified position within the list.
7. Length: Returns the number of elements in the list.
8. Find: Searches for an element within the list and returns its position.
9. Concatenate: Combines two lists into a single list.
10. Slice: Extracts a subset of elements from the list, based on a specified range of indices.
Lists are used extensively in programming and computer science, and they serve as a fundamental
building block for many other data structures, such as stacks, queues, and trees. They are
implemented using arrays or linked lists, and the choice of implementation depends on the
requirements of the application and the performance characteristics of the data structure.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
56
lOMoARcPSD|27610193
4.2.1.2 Stack ADT
The Stack abstract data type (ADT) is a collection of elements that follows the Last-In-First-Out
(LIFO) principle. It supports two main operations: push, which adds an element to the top of the
stack, and pop, which removes the most recently added element from the top of the stack. In
addition, the stack ADT typically includes a third operation, peek, which returns the element at the
top of the stack without removing it.
The basic operations of the stack ADT include:
1. Push: Adds an element to the top of the stack.
2. Pop: Removes the most recently added element from the top of the stack.
3. Peek: Returns the element at the top of the stack without removing it.
4. IsEmpty: Determines whether the stack is empty.
5. Size: Returns the number of elements in the stack.
Stacks are used extensively in programming and computer science, and they serve as a
fundamental building block for many other data structures, such as queues, trees, and graphs. They
are implemented using arrays or linked lists, and the choice of implementation depends on the
requirements of the application and the performance characteristics of the data structure.
Stack ADT is useful in a wide variety of applications, including function call management,
expression evaluation, backtracking, parsing, undo/redo functionality, and memory allocation.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
57
lOMoARcPSD|27610193
4.2.1.3 Queue ADT
The First-In-First-Out (FIFO) concept is applied to the elements in the Queue abstract data type
(ADT). Enqueue, which adds an element to the back of the queue, and dequeue, which removes
the element at the front of the queue, are the two primary actions that it supports. A third action,
known as peek, is frequently included in the queue ADT as well. It returns the element at the front
of the queue without removing it.
Here are some common operations that are typically supported by the Queue ADT:
1. Enqueue: Adds an element to the back of the queue.
2. Dequeue: Removes the element at the front of the queue.
3. Peek: Returns the element at the front of the queue without removing it.
4. IsEmpty: Determines whether the queue is empty.
5. Size: Returns the number of elements in the queue.
In programming and computer science, queues are widely used and act as a basic building block
for a variety of other data structures, including stacks, trees, and graphs. Depending on the needs
of the program and the performance characteristics of the data structure, they are implemented
using arrays or linked lists.
The queue ADT is useful in a wide variety of applications, including task scheduling, message
passing, network packet routing, and event handling.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
58
lOMoARcPSD|27610193
4.2.2 Stack, Queue and List Abstract Data Type Comparison
Three of the most popular abstract data types (ADTs) in computing and computer science are
stacks, queues, and lists. While there are some parallels between them, there are also some
significant differences.
1. Structure: Stacks and queues are both linear data structures, meaning that their elements
are arranged in a linear sequence. Lists can also be linear, but they can also be
implemented as linked lists, which are more flexible in terms of their structure.
2. Principle of operation: Stacks follow the Last-In-First-Out (LIFO) principle, meaning that
the most recently added element is the first one to be removed. Queues follow the FirstIn-First-Out (FIFO) principle, meaning that the first element added is the first one to be
removed. Lists do not have a fixed principle of operation.
3. Main operations: The main operations supported by stacks are push, pop, and peek. The
main operations supported by queues are enqueue, dequeue, and peek. The main
operations supported by lists are append, prepend, insert, remove, get, set, and slice.
4. Use cases: Stacks are often used in applications that require backtracking, expression
evaluation, undo/redo functionality, or function call management. Queues are often used
in applications that require task scheduling, message passing, or network packet routing.
Lists are often used in applications that require the storage and manipulation of ordered
collections of elements.
Stacks, queues, and lists are intended to serve different purposes and have different qualities that
make them more suitable for certain types of applications, even though they have some similarities.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
59
lOMoARcPSD|27610193
4.3 Selecting the suitable ADT for the scenario and implementing it
If stack data structures use the phrase "first in, last out," we can use them in our application.
Therefore, if we are entering the car's details from oldest to newest and need the results in reverse
chronological sequence, we can use stack data structure as our ADT. Consequently, we can use a
linked list in this instance for the Java version. Because the count that the corporation gets cannot
be measured and must be arranged dynamically, the answer should be implemented as a linked
list.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
60
lOMoARcPSD|27610193
5. Implement a complex ADT and algorithm in an executable
programming language to solve a well-defined problem.
5.1 Describe the scenario and design the system
In the aforementioned situation, we need an object array to store the relevant data about each car,
then an object. When registering a car, we can quickly retrieve the array index and fill in the
required data inside the object. I decide to use an object array because it is effective and simple to
apply the program. We can quickly delete an automobile by assigning null to the array index,
which will cause the object to be deleted automatically. We can sort the array by rank after entering
the data to get rid of the last car from the list. The first record entered will be the first record exited
in a queue data structure. If we arrange the array in that manner, the winners can be readily
distinguished from all other competitors. A queue can be used in the aforementioned scenario to
input race results, eliminate the final competitor based on those results, and choose the winners.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
61
lOMoARcPSD|27610193
5.2 Implementation the system
In accordance with the task description, I first established a class, then I created the main class,
and I carried out the corresponding tasks.
Figure 7: Car class
The process of importing libraries, making the Car class, and adding class properties like number,
brand, sponsor, and driver is illustrated by this snippet of code. And using this class, I created
objects to hold the data about the cars. When objects are made, initializing the properties of cars
is easier. This is the primary class, and it is in this class that I have all of the program's features.
Here, I made a collection of Car objects with the name "c" and a size of 6. Because there are only
six cars entered in the competition consequently, there can be a limit of 6 cars.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
62
lOMoARcPSD|27610193
Figure 8: Main Class
I created a scanner object to enter all user inputs with the name "input." I also initialized the
numbers select, I, and r at this location. I counts the number of registered cars, R counts the number
of rounds in the competition out of three, and "select" refers to the menu.
Figure 9: Function
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
63
lOMoARcPSD|27610193
This code snippet displays the program's menu as well as the switch statement that selects choices
on a case-by-case basis. I'll talk about the code snippets I used to apply the functionalities in the
following paragraphs.
Figure 10: Case 1
This code snippet shows the way I register a car using the car object array. So, I will be representing
the count of the cars that registered. So, with that we can see if the car count increases by 6. It will
display an error, saying, “You can only register 6 cars for the race!”
I used the functionalities here itself is there is no repetition of the functionality.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
64
lOMoARcPSD|27610193
Figure 11: Case 2
This instance is where I got the delete car functionality. The vehicle number is being entered in
this box. That is followed by the reviewing phase. It will be removed from the array if any of the
registry numbers match the car number that we put there. As a result, the object array's index will
be changed to NULL. The quantity of cars will drop by one, as indicated by "i—." The next action
should be to fill the array starting at the deleted position if it is in the array's middle. Therefore, I
created a for loop to populate the null index in the array while preserving the hierarchy of the
registry's other information. And if there is no such a car like that I entered to the search tool, it
will output the result, as “No car found to delete!”
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
65
lOMoARcPSD|27610193
Figure 12: Case 3
In this case, I developed the functionality for the round outcomes, and following one round, it will
be sorted by the car's rating. Additionally, it will reduce the range of the ongoing for loop by 1.
After a round has concluded, the final car is unable to fight against the other vehicles. I applied the
solution for the race's rounds with rankings in this specific case in the same manner.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
66
lOMoARcPSD|27610193
Figure 13: Case 4
In this case, this shows the winners of the race. It is going to happen, only if they complete all 3
rounds. If we were not completed all 3 rounds and asks for the winners, it will show the current
ranking after with the round rounds.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
67
lOMoARcPSD|27610193
Figure 14: Case 5
Therefore, this snippet of code illustrates the "search car" feature. So, in this case, we input the
car's number and use a for loop to find the car. And in the for loop, if any object numbers match
the number that we entered, all information about the car that number possesses will be displayed.
And if there isn't a car matching that description, it will say "No car found." And if there isn't a
vehicle listed, it will say so in the prints.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
68
lOMoARcPSD|27610193
5.2.1 Full functionable code which I used in my application
import java.util.Scanner;
import java.util.*;
class Car {
int number;
String brand;
String sponsor;
String driver;
}
public class main {
public static void main(String[] args) {
Car c[]=new Car[6];
int choose=0,i=0,r=0;
System.out.println("\t***ABC PVT LTD. car race***\t");
Scanner input = new Scanner(System.in);
while(choose!=7) {
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
69
lOMoARcPSD|27610193
System.out.println("1. Register a car ");
System.out.println("2. Delete a car ");
System.out.println("3. Insert 3 rounds details ");
System.out.println("4. Find out winners ");
System.out.println("5. Search a car ");
System.out.println("6.Display registered cars");
System.out.println("7. Exit ");
choose=input.nextInt();
switch(choose) {
case 1:
if(i<6) {
c[i]=new Car();
System.out.print("enter car number: ");
c[i].number=input.nextInt();
input.nextLine();
System.out.print("enter car brand: ");
c[i].brand=input.nextLine();
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
70
lOMoARcPSD|27610193
System.out.print("enter car sponsor: ");
c[i].sponsor=input.nextLine();
System.out.print("enter car driver: ");
c[i].driver=input.nextLine();
i++;
} else {
System.out.println("you only can register 6 cars
for the race!");
}
break;
case 2:
System.out.println("enter the car number to delete: ");
int carNum=input.nextInt();
for(int m=0; m<i; m++) {
if(carNum==c[m].number) {
System.out.println("Car deleted!");
c[m]=null;
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
71
lOMoARcPSD|27610193
i--;
for(int k=m; k<i; k++) {
if(k!=6) {
c[k]=c[k+1];
}
}
} else if(m+1==i) {
System.out.println("No car found to delete!");
}
}
break;
case 3:
System.out.println("enter round"+(++r)+" results: ");
Car temp=new Car();
int num,a=0;
for(int k=0; k<6-(r-1); k++) {
System.out.print("place "+(k+1)+": ");
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
72
lOMoARcPSD|27610193
num=input.nextInt();
for(int m=0; m<i; m++) {
if(num==c[m].number) {
temp=c[m];
c[m]=c[a];
c[a++]=temp;
}
}
}
break;
case 4:
if(r==3) {
System.out.println("1st place: "+c[0].number+"
"+c[0].driver);
System.out.println("2nd place: "+c[1].number+"
"+c[1].driver);
System.out.println("3rd place: "+c[2].number+"
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
73
lOMoARcPSD|27610193
"+c[2].driver);
} else {
System.out.println("Race is still going on, current results are: ");
System.out.println("End of round"+r+": ");
for(int k=0; k<6; k++){
System.out.println((k+1)+" place:"+c[k].number);
}
}
break;
case 5:
System.out.print("Enter the car number: ");
int n=input.nextInt();
for(int k=0; k<i; k++) {
if(n==c[k].number) {
System.out.println("Brand: "+c[k].brand);
System.out.println("Sponsor: "+c[k].sponsor);
System.out.println("Driver: "+c[k].driver);
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
74
lOMoARcPSD|27610193
} else if(k+1==i) {
System.out.println("No car found!");
} else if(k==0) {
System.out.println("No car in registry!");
}
}
break;
case 6:
System.out.println("---------------Car registry----------------");
for(int m=0; m<i; m++) {
System.out.println(c[m].number+"\t"+c[m].brand+"\t"+c[m].spons
or+"\t"+c[m].driver);
}
break;
case 7:
System.out.println("Exit!");
break;
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
75
lOMoARcPSD|27610193
}
}
}
}
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
76
lOMoARcPSD|27610193
5.3 Implementation of the fully commented code
import java.util.Scanner;
import java.util.*;
import static java.lang.System.exit;// import package
class CarRegistryStack {// Create Stack Using Linked list
private class Node {// A linked list node
int carNum;
String brand;
String sponsor;
String driver;
Node next; // reference variable Node type
}
Node top;
CarRegistryStack(){// Constructor
this.top = null;
}
public void push(int x, String br, String sp, String dr) // enter in the beginning.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
77
lOMoARcPSD|27610193
{
Node tmp = new Node();// create new node tmp and allocate memory
if (tmp == null) {
System.out.print("\nHeap Overflow");// check whether stack (heap) is full or not.
return;
}
tmp.carNum = x; // initialize carNum into tmp carNum field
tmp.brand = br; // initialize brand
tmp.sponsor = sp; // initialize sponsor
tmp.driver = dr; // initialize driver
tmp.next = top; // put top reference into tmp next
top = tmp; // update top reference
}
public boolean isEmpty(){// Utility function to check if the stack is empty or not
return top == null;
}
public String peek(){ // Utility function to return top element in a stack
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
78
lOMoARcPSD|27610193
if (!isEmpty()) { // check for empty stack
return top.carNum+" "+top.brand+" "+top.sponsor+" "+top.driver;
}
else {
System.out.println("Stack is empty");
return null;
}
}
public void pop() // remove at the beginning
{
// check whether stack is underflow or not.
if (top == null) {
System.out.print("\nStack Underflow");
return;
}
top = (top).next;
}
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
79
lOMoARcPSD|27610193
public void display()
{
// check whether stack is underflow or not.
if (top == null) {
System.out.printf("\nStack Underflow");
exit(1);
}
else {
Node tmp = top;
while (tmp != null) {
System.out.printf("%d->", tmp.carNum);// print node carNum
tmp = tmp.next;// assign tmp next to tmp
}
}
}
}
public class atd {
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
80
lOMoARcPSD|27610193
public static void main(String[] args){
CarRegistryStack obj = new CarRegistryStack();// create Object of
Implementing class
int choose=0;
System.out.println("\t***ABC PVT LTD. car race***\t");
Scanner input = new Scanner(System.in);
while(choose!=3){
System.out.println("1. Register a car ");
System.out.println("2. get car details ");
choose=input.nextInt();
switch(choose){
case 1:
System.out.print("enter car num: ");
int n=input.nextInt();
input.nextLine();
System.out.print("enter car brand: ");
String brand=input.nextLine();
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
81
lOMoARcPSD|27610193
System.out.print("enter car sponsor: ");
String sponsor=input.nextLine();
System.out.print("enter car driver: ");
String driver=input.nextLine();
obj.push(n,brand,sponsor,driver);
break;
case 2:
System.out.println(obj.peek());
obj.pop();
break;
case 3:
System.out.println("Exit!");
break;
}
}
}
}
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
82
lOMoARcPSD|27610193
5.4 Output of the codes
Figure 15: Function list
The Function wants to be performed by the ABC Company.
Figure 16: Case 1 Output
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
83
lOMoARcPSD|27610193
Register Car details.
Figure 17: Case 1 Output 2
As per Scenario only 6 people can register to the Race if more then 6 people are join to the even
can get this message.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
84
lOMoARcPSD|27610193
Figure 18: Delete a car Case 2
Above Image we can see Car details after deleted and before delete by entering car number can
delete particular car.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
85
lOMoARcPSD|27610193
Figure 19: Case 3
Above image is the way of inserting places of every end of each round this is help to know
finally who the winner is
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
86
lOMoARcPSD|27610193
Figure 20: Case 4
As I said earlier by inserting places to end of each round finally can identify who is the winner and
that is shown on above picture.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
87
lOMoARcPSD|27610193
Figure 21: Case 5
Search car by car‟s Number this is very helpful for identify the details of car brand,sponsor and
Driver‟s Name.
Figure 22: Case 6
In the above picture can find the details of all registered car.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
88
lOMoARcPSD|27610193
5.5 Complexity of Stack ADT
The complexity of the Stack ADT (Abstract Data Type) operations depends on the implementation
of the stack.
1. Array-based implementation:

Push: O(1) amortized time complexity, O(n) worst-case time complexity when the array
needs to be resized.

Pop: O(1) time complexity.

Peek: O(1) time complexity.

Search: O(n) time complexity.
2. Linked list-based implementation:

Push: O(1) time complexity.

Pop: O(1) time complexity.

Peek: O(1) time complexity.

Search: O(n) time complexity.
3. Dynamic Array-based implementation (such as std::vector in C++):

Push: O(1) amortized time complexity, O(n) worst-case time complexity when the dynamic
array needs to be resized.

Pop: O(1) time complexity.

Peek: O(1) time complexity.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
89
lOMoARcPSD|27610193

Search: O(n) time complexity.
In general, the stack operations have a time complexity of O(1) for push, pop, and peek. However,
the search operation has a time complexity of O(n) for all implementations.
5.6 Encapsulation
In object-oriented programming (OOP), the term "encapsulation" refers to the grouping of data
and the methods that act on it into a single entity, such as a class. Encapsulation is a technique
used to provide a clearly specified interface for interacting with an object while keeping the
implementation details of the object hidden from the outside world.
Encapsulation is the process of containing data and behavior within a singular entity and allowing
controlled access to that entity, to put it another way. By forbidding direct access to an object's
data and methods and requiring access through clearly defined interfaces, it allows the developer
to create reliable and secure software systems.
This approach ensures that the implementation details of an object are not exposed to the outside
world and that the object is responsible for maintaining its own integrity.
Encapsulation helps in achieving data hiding, which means that the internal representation of an
object is hidden from the outside world. This allows the developer to modify the internal
implementation of an object without affecting the code that uses it. Encapsulation also facilitates
code reuse and modularity by providing a clear separation between the interface and the
implementation of an object.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
90
lOMoARcPSD|27610193
Encapsulation provides several benefits, including:

Improved maintainability: Changes to the internal implementation of an object do not
affect the external code that uses the object.

Improved security: Encapsulated data cannot be modified or accessed directly from outside
the class.

Improved usability: Encapsulation allows developers to define a clear and concise interface
to an object, making it easier to use and understand.
Overall, encapsulation is a crucial concept in object-oriented programming and plays a significant
role in designing software systems that are modular, reusable, and maintainable. Below I have
mentioned example for encapsulation using java language.
Figure 23: Encapsulation example
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
91
lOMoARcPSD|27610193
In this case, the account number and balance information are confidential and enclosed within the
BankAccount class. This indicates that the only place from which to obtain these variables is the
BankAccount class.
By returning the contents of the secret variables, the getAccountNumber() and getBalance()
methods allow for controlled access to the data that is encapsulated. Other classes may use these
methods to get the account number and amount.
There are two ways to change the account balance: transfer() and withdraw(). These methods are
used to guarantee that the balance is updated in a controlled and consistent way and can only be
called from within the BankAccount class.
By encapsulating the data and methods within the BankAccount class, the developer can ensure
that the account information is accessed and modified in a controlled and secure way, reducing the
risk of errors and vulnerabilities in the software system
5.6.1 Advantages of using Encapsulation
There are several advantages to using encapsulation in programming:
1. Security: By concealing an object's internal implementation details, encapsulation aids in
keeping the security and integrity of data. This minimizes the danger of unauthorized
access by ensuring that the data can only be accessed using the methods offered by the
object.
2. Modularity: By clearly separating an object's interface and execution, encapsulation
encourages modularity. This makes it simpler to update and expand the code without
having an adverse effect on other system components.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
92
lOMoARcPSD|27610193
3. Code Reusability: By producing self-contained objects that can be used in various system
components without change, encapsulation facilitates code reuse. As a result, less code
needs to be created, tested, and managed.
4. Maintenance: Encapsulation reduces the scope of changes to an object's internal
implementation, which makes the code simpler to manage and debug. This lowers the
possibility of causing unintended adverse effects or damaging other system components.
5. Abstraction: Through the provision of a clearly specified interface for interacting with an
object, encapsulation makes abstraction easier. Because of this notion, it is simpler to
comprehend an object's behavior without having to comprehend how it is implemented
internally.
Overall, encapsulation is a powerful technique that promotes security, modularity, code
reusability, maintainability, and abstraction in programming. By encapsulating data and methods
within objects, developers can create more robust and secure software systems that are easier to
modify, maintain and extend.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
93
lOMoARcPSD|27610193
6. Implement Error Handling and Report Test Results.
6.1 Error Handling
Figure 24: Error Handling
The procedure used to deal with the possibility for disappointment is called error handling. For
instance, it would be risky to use a paper even after realizing it was terrible and choosing to
disregard it. Recognizing and fixing those issues right away shields the remainder of the software
from additional pitfalls.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
94
lOMoARcPSD|27610193
The accompanying subchapters illustrate various approaches to error handling in Rust. They all
have a variety of use cases and rather unpretentious contrasts. As a general guideline:
The most effective use of unambiguous panic is in handling testing and unrecoverable errors. It
may be helpful for prototyping, for example, when dealing with yet-to-be-performed tasks, but in
those circumstances, the more illustrative the unimplemented, the better. It makes sense to panic
during testing as a surefire method to fail.
The Option type should be used when a value is optional or when the absence of a value is not an
error circumstance. For example, neither C: nor -/ have a parent directory. Unwrap works well
when managing Options for experimentation and situations where there is unquestionably going
to be a benefit. The ability to define an error message with expect, should something go wrong,
makes it more useful.
There are several techniques for error handling, including:
1. Exception handling: This technique involves detecting errors and throwing exceptions to
handle them. It allows developers to control the flow of the program and handle errors
gracefully without crashing the application.
2. Logging: Logging is the process of recording events, errors, and other information that
occurs during the execution of an application. It helps developers identify errors and
troubleshoot issues that occur during runtime.
3. Defensive programming: Defensive programming is a technique that involves writing
code that anticipates potential errors and handles them proactively. It includes techniques
such as input validation, boundary checking, and data sanitization.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
95
lOMoARcPSD|27610193
4. Graceful degradation: graceful degradation is a technique used in web development that
allows a website or application to continue functioning even when some features or
components are not working correctly. This technique ensures that users can still use the
application even if some features are unavailable.
Overall, error handling is an essential part of software development, and developers should
implement robust error handling techniques to ensure that their applications are reliable and
resilient.
6.1.1 Option and Unwrap
In the prior model, we demonstrated how simple it is for us to start a disappointing program. If we
consume sugary lemonade, we instructed our program to panic. But contemplate the possibility
that we might ask for a drink but not get one. It's important to handle that circumstance because
the consequences would be terrible.
Similarly to a lemonade, we could compare this to the invalid text. (""). We would prefer to have
the compiler flag cases when there isn't a drink because we are using Rust.
When nonattendance is reasonable, the sexually transmitted disease library's Option<T> Enum is
used. It manifests as one of two possible "options":
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
96
lOMoARcPSD|27610193
These situations can be dealt with either categorically using coordinate or tangibly using unwind.
Either the internal part will be returned or there will be a panic.
Keep in mind that it is possible to physically alter fear with anticipation, but doing so results in a
less important outcome than express handling. In the accompanying model, unambiguous
management produces a more controlled outcome while retaining the ability to panic at any time.
// The adult has seen it all, and can handle any drink well.
// All drinks are handled explicitly using `match`.
fn give_adult(drink: Option<&str>) {
// Specify a course of action for each case.
match drink {
Some("lemonade") => println!("Yuck! Too sugary."),
Some(inner) => println!("{}? How nice.", inner),
None => println!("No drink? Oh well."),
}
}
// Others will `panic` before drinking sugary drinks.
// All drinks are handled implicitly using `unwrap`.
fn drink(drink: Option<&str>) {
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
97
lOMoARcPSD|27610193
// `unwrap` returns a `panic` when it receives a `None`.
let inside = drink.unwrap();
if inside == "lemonade" { panic!("AAAaaaaa!!!!"); }
println!("I love {}s!!!!!", inside);
}
fn main() {
let water = Some("water");
let lemonade = Some("lemonade");
let void = None;
give_adult(water);
give_adult(lemonade);
give_adult(void);
let coffee = Some("coffee");
let nothing = None;
drink(coffee);
drink(nothing);
}
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
98
lOMoARcPSD|27610193
6.1.2 Panic
Panic is the error management feature that is the easiest to understand. It usually exits the program
after printing an error message and starting to free up the stack. Here, we categorically declare that
our error state is panic:
fn drink(beverage: &str) {
// You shouldn't drink too much sugary beverages.
if beverage == "lemonade" { panic!("AAAaaaaa!!!!"); }
println!("Some refreshing {} is all I need.", beverage);
}
fn main() {
drink("water");
drink("lemonade");
}
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
99
lOMoARcPSD|27610193
6.1.3 Result
Result is a more extravagant form of the Option type that portrays conceivable error rather than
conceivable nonappearance. (Anon., n.d)
That is, Result<T, E> could have one of two results:

Ok(T): An element T was found

Err(E): An error was found with element E
By show, the expected result is Ok while the unexpected result is Err.
Similar to Option, Result also has a variety of connected strategies. For instance, unwind () either
produces the element T or panics. There are many combinators available for case processing.
between the cross-overing Results and Options. (Anon., n.d)
You will undoubtedly come across strategies that yield the Result type while working with Rust,
such as the parse () strategy. Since it might not typically be possible to imagine parsing a string
into the other sort, parse () gives a Result indicating potentially disappointing expectations.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
100
lOMoARcPSD|27610193
We should see what happens when we effectively and fruitlessly parse () a string:
fn multiply(first_number_str: &str, second_number_str: &str) -> i32 {
// Let's try using `unwrap()` to get the number out. Will it bite us?
let first_number = first_number_str.parse::<i32>().unwrap();
let second_number = second_number_str.parse::<i32>().unwrap();
first_number * second_number
}
fn main() {
let twenty = multiply("10", "2");
println!("double is {}", twenty);
let tt = multiply("t", "2");
println!("double is {}", tt);
}
When parse() fails, an error is left behind for unwrap() to worry on. Additionally, the panic exits
our application and issues an awful error message. (Anon., n.d)
We should consider handling the error explicitly and being more clear about the return type in
order to improve the nature of our error message.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
101
lOMoARcPSD|27610193
6.1.4 Multiple error type
The past models have consistently been extremely advantageous; Results communicate with
different Results and Options associate with different Options.
Sometimes an Option needs to interface with a Result, or a Result<T, Error1> needs to
communicate with a Result<T, Error2>. In those cases, we need to deal with our distinctive error
types such that makes them composable and simple to interface with.
In the accompanying code, two cases of unwrap create distinctive error types. Vec::first returns an
Option, while parse::<i32> returns a Result<i32, ParseIntError>:
fn double_first(vec: Vec<&str>) -> i32 {
let first = vec.first().unwrap(); // Generate error 1
2 * first.parse::<i32>().unwrap() // Generate error 2
}
fn main() {
let numbers = vec!["42", "93", "18"];
let empty = vec![];
let strings = vec!["tofu", "93", "18"];
println!("The first doubled is {}", double_first(numbers));
println!("The first doubled is {}", double_first(empty));
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
102
lOMoARcPSD|27610193
// Error 1: the input vector is empty
println!("The first doubled is {}", double_first(strings));
// Error 2: the element doesn't parse to a number
}
6.1.5 Iterative over results
An Iter::map operation might fail, for example:
fn main() {
let strings = vec!["tofu", "93", "18"];
let numbers: Vec<_> = strings
.into_iter()
.map(|s| s.parse::<i32>())
.collect();
println!("Results: {:?}", numbers);
}
Ingore the failes items with filter_map()
filter_map calls a function and filters out the results that are None.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
103
lOMoARcPSD|27610193
fn main() {
let strings = vec!["tofu", "93", "18"];
let numbers: Vec<_> = strings
.into_iter()
.filter_map(|s| s.parse::<i32>().ok())
.collect();
println!("Results: {:?}", numbers);
}
Fail the entire operation with collect()
Result implements FromIter so that a vector of results (Vec<Result<T, E>>) can be
turned into a result with a vector (Result<Vec<T>, E>). Once an Result::Err is found,
the iteration will terminate.
fn main() {
let strings = vec!["tofu", "93", "18"];
let numbers: Result<Vec<_>, _> = strings
.into_iter()
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
104
lOMoARcPSD|27610193
.map(|s| s.parse::<i32>())
.collect();
println!("Results: {:?}", numbers);
}
Collect all valid and failures with partition
fn main() {
let strings = vec!["tofu", "93", "18"];
let (numbers, errors): (Vec<_>, Vec<_>) = strings
.into_iter()
.map(|s| s.parse::<i32>())
.partition(Result::is_ok);
println!("Numbers: {:?}", numbers);
println!("Errors: {:?}", errors);
}
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
105
lOMoARcPSD|27610193
When you look at results, we will note that everything is still wrapped in results. A little more
boilerplate is needed for this.
fn main() {
let strings = vec!["tofu", "93", "18"];
let (numbers, errors): (Vec<_>, Vec<_>) = strings
.into_iter()
.map(|s| s.parse::<i32>())
.partition(Result::is_ok);
let numbers: Vec<_> = numbers.into_iter().map(Result::unwrap).collect();
let errors: Vec<_> = errors.into_iter().map(Result::unwrap_err).collect();
println!("Numbers: {:?}", numbers);
println!("Errors: {:?}", errors);
}
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
106
lOMoARcPSD|27610193
6.1.6 Handling Errors using Do-Catch
You utilize a do-catch proclamation to deal with mistakes by running a square of code. Assuming
that a mistake is tossed by the code in the do provision, it's matched against the catch statements
to figure out which one of them can deal with the blunder.
Here is the overall type of a do-catch proclamation:
1. do {
2. try expression
3. statements
4. } catch pattern 1 {
5. statements
6. } catch pattern 2 where condition {
7. statements
8. } catch pattern 3 , pattern 4 where condition {
9. statements
10. } catch {
11. statements
12. }
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
107
lOMoARcPSD|27610193
6.1.7 Changing Error over to Option values
You use attempt? to deal with a mistake by changing it over to a discretionary worth. Assuming a
blunder is tossed while assessing the attempt? articulation, the worth of the articulation is nothing.
For instance, in the accompanying code x and y have a similar worth and conduct.
1. func someThrowingFunction() throws -> Int {
2. // ...
3. }
4.
5. let x = try? someThrowingFunction()
6.
7. let y: Int?
8. do {
9. y = try someThrowingFunction()
10. } catch {
11. y = nil
12. }
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
108
lOMoARcPSD|27610193
6.1.8 Bugs Versus exceptions
It is important to decide into which of these categories a certain problem falls. For example,
consider our old power function.
function power(base, exponent) {
var result = 1;
for (var count = 0; count < exponent; count++)
result *= base;
return result;
}
6.1.9 Error handling implementation
Figure 25: Error log
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
109
lOMoARcPSD|27610193
Figure 26: Try catch1
The code above is what it would have looked like without error handling because in the scenario
described above, a user might have accidentally entered a string value in place of an integer when
the system was asking for an integer instead. This would cause the system to malfunction as shown
in the above picture. So, let's see how I corrected this mistake.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
110
lOMoARcPSD|27610193
Figure 27: Try catch 2
So the above image can see using try catch method can avoid the error in this case we can alive
our system when user give any kind of input.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
111
lOMoARcPSD|27610193
6.2 Test report
A test report is a written account of the testing procedures and findings for a specific piece of
software or system. The report typically contains details on the testing methods employed, the
different kinds of tests carried out, the test results, and any problems or flaws found during the
testing process. An extensive grasp of the software's quality and readiness for release is what a test
report is meant to give stakeholders. Developers, testers, project managers, and other stakeholders
use test reports as a crucial component of the software development lifecycle to make choices
about the software.
Here are a few examples of what could be included in a test report:
1. Test Summary: This section provides an overview of the testing process, including the
testing objectives, scope, and key findings.
2. Testing Environment: This section describes the testing environment, including the
hardware, software, and network configurations used during the testing process.
3. Test Cases: This section provides a list of the test cases that were executed during the
testing process, including the expected and actual results.
4. Defects and Issues: This section provides a list of any defects or issues that were identified
during the testing process, including their severity, priority, and steps to reproduce them.
5. Test Metrics: This section provides quantitative data about the testing process, including
the number of test cases executed, the number of defects identified, and the test coverage
achieved.
6. Recommendations: This section provides recommendations for addressing any defects or
issues identified during the testing process and improving the quality of the software.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
112
lOMoARcPSD|27610193
These are just a few examples of what could be included in a test report. The specific contents of
the report will depend on the testing objectives, the testing methodology used, and the needs of the
stakeholders who will be reviewing the report.
6.2.1 Why test report is important.
Test reports are important for several reasons:
1. Communication: Test reports give stakeholders, such as developers, testers, project
managers, and company owners, a clear and succinct method to understand the testing
results. They assist in making sure that everyone working on the software development
process is in agreement regarding the software's quality and any problems that need to be
fixed.
2. Decision-making: Stakeholders can use test reports to gather the data they need to make
knowledgeable software choices. Stakeholders can determine whether the software is ready
for release based on the results of the testing process or whether more testing or
development is necessary.
3. Quality control: Test results offer a way to monitor the software's quality evolution.
Stakeholders can spot trends and patterns in the quality of the software by comparing test
results from various stages of the development process and taking appropriate corrective
action as necessary.
4. Compliance: Regulatory agencies or business standards like ISO or CMMI frequently
demand test reports. These studies aid in proving that the software development procedure
adheres to the necessary norms and regulations.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
113
lOMoARcPSD|27610193
In summary, test reports are important because they provide stakeholders with the information,
they need to make informed decisions about the software, ensure the quality of the software, and
comply with regulatory and industry standards.
6.2.2 What does test report contain
A test report typically contains the following information:
1. Introduction: This section provides an overview of the testing process, including the
objectives, scope, and approach used.
2. Testing Environment: This section describes the testing environment, including the
hardware, software, and network configurations used during the testing process.
3. Test Cases: This section provides a list of the test cases that were executed during the
testing process, including the expected and actual results.
4. Defects and Issues: This section provides a list of any defects or issues that were identified
during the testing process, including their severity, priority, and steps to reproduce them.
5. Test Metrics: This section provides quantitative data about the testing process, including
the number of test cases executed, the number of defects identified, and the test coverage
achieved.
6. Summary of Results: This section provides a summary of the testing results, including an
analysis of the defects and issues identified, and any recommendations for further testing
or development.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
114
lOMoARcPSD|27610193
7. Conclusions: This section provides a summary of the key findings of the test report, and
any conclusions or recommendations based on those findings.
Depending on the goals, scope, and methodology of the testing process as well as the requirements
of the stakeholders who will be evaluating the report, a test report's precise contents may change.
To give a thorough overview of the testing procedure and results, most test reports will include the
data listed above.
6.2.3 Test results screen shot for given scenario.
Figure 28: Test cycle
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
115
lOMoARcPSD|27610193
Figure 29: Functions
Figure 30: Defect density
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
116
lOMoARcPSD|27610193
Figure 31: Defect Fixed Ratio
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
117
lOMoARcPSD|27610193
7. Discuss how asymptotic analysis can be used to assess the
effectiveness of an algorithm.
7.1 Asymptotic analysis
As the size of an algorithm's input approaches infinity, asymptotic analysis is a method used in
computer science to assess an algorithm's effectiveness. It aids in assessing an algorithm's
efficiency and foretelling how it will scale as input size increases.
Analysis of an algorithm's worst-case behavior is the primary goal of asymptotic analysis. As a
result, it gives us an upper bound on the rate of growth of the algorithm's time complexity and
space complexity, which are the two major aspects that affect how effective the algorithm is.
Big O notation is used in asymptotic analysis to indicate the maximum time and space complexity
of an algorithm. The performance growth rate of an algorithm as the input size approaches infinite
can be expressed using the Big O notation.
Think about an algorithm that sorts an array with n items, for instance. As the input quantity (n)
grows, the algorithm's sorting time for the array will also grow. We can predict how fast the amount
of time needed to sort the array will increase as n grows by using asymptotic analysis.
We can state that the algorithm has an O(n2) time complexity if we observe that the amount of
time needed by the algorithm to sort an array of size n is proportional to n2. This indicates that the
time needed to sort the array will only rise quadratically as n increases. We can state that the
algorithm's time complexity is O if we discover that the amount of time needed by the algorithm
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
118
lOMoARcPSD|27610193
to sort an array of size n is proportional to n.(n). This means that the time needed to sort the array
will only rise linearly as n increases.
Asymptotic analysis is a powerful tool for analyzing the efficiency of algorithms and comparing
the performance of different algorithms for a given problem. It helps in choosing the most efficient
algorithm for a particular use case and optimizing the performance of existing algorithms.
7.2 Most pessimistic scenario and Average-Case Analysis
Most pessimistic scenario analysis and average-case analysis are two approaches to analyzing the
efficiency of algorithms.
Worst-case analysis is another name for the situation analysis that is the most pessimistic. It entails
examining an algorithm's behavior while assuming that the input is in the worst-case situation. The
worst-case scenario is the one in which the algorithm needs the most time or space to finish. We
can determine an upper bound on the algorithm's time and space complexity by considering the
worst-case situation. This higher bound ensures that the algorithm won't perform worse than a
specific threshold.
On the other hand, average-case analysis examines an algorithm's performance under the
presumption that the data is uniformly distributed and random. With the help of common inputs,
this method estimates how well the algorithm should work. In average-case analysis, we determine
the algorithm's typical time or area complexity across all feasible inputs. When the input data are
unpredictable and the spread of the input data is unknown, this method is helpful.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
119
lOMoARcPSD|27610193
Most pessimistic scenario analysis is typically more conservative and offers a more solid upper
limit on the algorithm's performance. On the other hand, average-case analysis offers a more
accurate assessment of the algorithm's real performance on typical inputs.
The constraints of both worst-case and average-case analyses must be kept in mind. The worstcase situation might not accurately depict the algorithm's typical behavior, and the best-case
scenario might not accurately depict how the algorithm responds to particular inputs. As a result,
it is frequently necessary to combine worst-case and average-case analysis to get a complete grasp
of an algorithm's effectiveness.
7.3 Calculation Efficiency and Asymptotic Analysis
To determine an algorithm's efficiency, one must determine how long and how much memory it
requires to complete a job for a specific input size. On the other hand, asymptotic analysis can be
used to forecast how an algorithm's efficiency will increase as the amount of the input increases
toward infinity.
While measuring an algorithm's efficiency for a particular input size can provide us with a precise
indication of how well it performs, it may not be very helpful to predict how the algorithm will
perform for bigger input sizes. This is where asymptotic analysis comes in, as it gives us a method
to forecast an algorithm's overall effectiveness as the input size increases.
Big O notation is used in asymptotic analysis to indicate the maximum time and space complexity
of an algorithm. A program's time complexity measures how long it takes to run as a function of
the size of the input, whereas its space complexity measures how much RAM it needs to run as a
function of the size of the input.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
120
lOMoARcPSD|27610193
Think about an algorithm that sorts an array with n items, for instance. We can state that an
algorithm has O(n2) time complexity if the amount of time it takes to sort an array is proportional
to n2. This indicates that the time needed to sort the array will only rise quadratically as n increases.
Similar to this, we can state that the algorithm's space complexity is O if the amount of space
needed by the algorithm to sort the array is proportional to n.(n).
Asymptotic analysis allows us to compare the effectiveness of various algorithms and identify the
one that is most appropriate for a particular issue. The actual performance of an algorithm may be
better or worse depending on the particular input data and the implementation of the algorithm,
and asymptotic analysis only gives an upper limit on the growth rate of an algorithm's efficiency.
Therefore, in order to obtain a more accurate estimate of an algorithm's performance, it is always
advised to also carry out real measurements of an algorithm's efficiency for a particular input size.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
121
lOMoARcPSD|27610193
7.3.1 Issue with timing code
Timing code is a popular method for gauging how effective an algorithm or program is. Timing
code, however, has a number of potential pitfalls that can produce unreliable or deceptive
outcomes. Here are a few typical synchronization code problems:
1. System load: The system load, which can change based on the other processes operating
on the system, can have an impact on how well a program performs. The timing code results
may be inaccurate and deceptive if other resource-intensive operations are running on the
system at the same time.
2. Warm-up time: When timing code, it's crucial to give enough warm-up time to make sure
that any JIT (Just-in-Time) compilation has taken place and the code has been completely
loaded into memory. Inaccurate findings can result from not allowing enough warm-up
time because early executions might take longer because of compilation or memory
allocation overhead.
3. Measurement overhead: The process of determining the amount of time it takes for an
algorithm to run can add extra overhead, which can skew the results. The operating
system's time-keeping device or the measurement code itself may be the source of this
overhead.
4. Hardware variability: The performance of a program can also be affected by the hardware
it is running on. For example, running the same code on different processors or with
different amounts of memory can lead to different performance results.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
122
lOMoARcPSD|27610193
5. Input data variability: The raw data that an algorithm is processing can also affect how well
it performs. Timing code may not correctly capture an algorithm's performance for a
particular set of inputs, producing inaccurate results.
It's crucial to measure the execution time several times and average the findings in order to address
these problems. Controlling system stress, warming up the code, and reducing measurement
overhead are also essential. To better understand the code's performance characteristics, it can also
be useful to test it on various hardware and input data sets.
7.3.2 Analysis Framework
A system, process, or problem may be analyzed and evaluated using a collection of tools, methods,
and guidelines known as an analysis framework. It offers a methodical strategy to comprehending
a system's parts and behaviors and can point out areas for development or optimization.
The following are the key components of an analysis framework:
1. Define the problem: Any analysis framework should start with a precise definition of the
issue or research topic. This entails determining the analysis's goals, objectives, and
requirements as well as any restrictions or limitations that might have an effect on the
analysis.
2. Gather data: The following stage is to compile pertinent data and information about the
issue. Data collection from different sources, such as surveys, interviews, or data analysis
tools, may be necessary.
3. Analyze the data: Following the collection of the data, it must be analyzed using a variety
of analytical methods, including statistical analysis, regression analysis, and machine
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
123
lOMoARcPSD|27610193
learning algorithms. Finding patterns, trends, and relationships in the data that can help us
better comprehend the issue is the goal of this step.
4. Identify solutions: The next stage is to find potential solutions or suggestions to deal with
the issue based on the findings of the analysis. To assess various scenarios and their
potential effects, this may entail using brainstorming, modeling, or simulation techniques.
5. Implement and monitor: The next stage after finding a solution is to put it into practice and
track its success over time. This might entail creating an execution strategy, keeping an eye
on the outcomes, and making changes as necessary.
6. Evaluate the results: Evaluating the findings of the analysis and the viability of the solution
is the last stage in the analysis framework. This entails evaluating how the problem has
been resolved in comparison to the initial goals and objectives, comparing the results to
those goals and objectives, and identifying areas that could use improvement.
Overall, an analysis framework provides a structured approach to analyzing and solving problems
and can be applied to a wide range of contexts and domains, such as business, engineering, health
care, and social sciences.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
124
lOMoARcPSD|27610193
7.3.3 Asymptotic notation
As the size of the input approaches infinity, asymptotic notation is a mathematical technique used
to express the growth rate of a function. To explain the effectiveness and complexity of algorithms,
it is frequently used in computer science and algorithm analysis.
There are several types of asymptotic notation, including:
1. Big O notation

Big O notation is a type of mathematical writing used to express the maximum growth rate
of a function. It is frequently used in computer science to characterize an algorithm's worstcase time complexity in terms of the size of its input.

If an algorithm, for instance, has a time complexity of O(n), where n is the size of the input,
this indicates that the algorithm's worst-case running time will not increase any faster than
a linear function of n. In other words, the algorithm's running time only grows maximally
linearly with the size of the input.

An algorithm's worst-case running time will not increase any quicker than a quadratic
function of n if it has a time complexity of O(n2). The algorithm's running time grows at
most quadratically as the input amount does.

"Order of" is what the "O" in Big O writing stands for. Therefore, when we say that an
algorithm has a time complexity of O(f(n)), we imply that as the input size approaches
infinity, the algorithm's running time grows at a rate on the order of f(n).

It's essential to remember that Big O notation does not specify the precise running time of
an algorithm; rather, it only gives an upper bound on the growth rate of a function.
Furthermore, Big O notation does not take into account constant factors or lower-order
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
125
lOMoARcPSD|27610193
terms, which means that two algorithms with the same time complexity could still operate
very differently in reality.
2. Omega notation:

The bottom limit of a function's growth rate is expressed using the mathematical notation
known as "omega notation." It is a standard practice in computer science to express an
algorithm's worst-case time complexity in terms of the size of its input.

If an algorithm, for instance, has a time complexity of (n), where n is the size of the input,
it indicates that its best-case running time increases no more slowly than a linear function
of n. In other words, the algorithm's execution time grows at least linearly as the size of the
input rises.

In a similar vein, if an algorithm has a time complexity of n2, it implies that its best-case
running time increases no more slowly than n's quadratic function. The algorithm's
execution time rises at least quadratically as the input size does.

Omega is represented by the Greek letter "omega" in writing. Because of this, when we
say that an algorithm has a time complexity of (f(n)), we mean that the rate of increase of
the algorithm's running time is at least on the order of f(n) as the input size approaches
infinity.

Omega notation does not specify the precise running time of an algorithm; rather, it only
gives a lower limit on the growth rate of a function. Omega notation does not take into
account constant factors or higher-order terms, which means that two algorithms with the
same time complexity could still operate very differently in practice.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
126
lOMoARcPSD|27610193
3. Theta notation:

The top and lower bounds of a function's growth rate are expressed using the mathematical
notation theta. In computer science, the size of an algorithm's input is frequently used to
characterize the average-case time complexity of an algorithm.

For instance, if an algorithm's time complexity is n, where n is the size of the input, it
implies that the algorithm's running time increases linearly with n. In other words, the
algorithm's running time increases at most linearly and at least linearly as the input size
grows.

In a similar vein, if an algorithm's time complexity is n2, it implies that its running time
increases at the same rate as n's quadratic function. The algorithm's running time rises at
most quadratically and at least quadratically as the input size increases.

The "Θ" in Theta notation stands for "theta". Therefore, when we say an algorithm has a
time complexity of Θ(f(n)), we mean that the growth rate of the algorithm's running time
is on the order of f(n) as the input size approaches infinity, both in the best and worst case
scenarios.

Compared to Big O or Omega notation alone, theta notation more accurately describes the
development rate of a function. Theta notation, however, may not always be appropriate
because an algorithm's best-case and worst-case temporal complexities may not always be
the same.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
127
lOMoARcPSD|27610193
8. Determine two ways in which the efficiency of an algorithm can be
measured, illustrating your answer with an example.
8.1 Algorithm Efficiency
The term "algorithm efficiency" describes how effectively an algorithm uses resources, usually
time and space. When solving an issue, an efficient algorithm uses the least amount of resources
possible, whereas an inefficient algorithm uses more resources than are required.
The effectiveness of an algorithm is frequently assessed in terms of its space and temporal
complexity in computer science. Time complexity is the amount of time an algorithm needs to
solve a problem as the size of the input increases, whereas space complexity is the amount of
memory an algorithm needs to solve a problem as the size of the input increases.
Because they can produce results more quickly, conserve computational resources, use less energy,
and allow the processing of bigger data sets more quickly, efficient algorithms are desirable. Many
fields of computer science, such as artificial intelligence, computer graphics, cryptography,
database systems, network protocols, and optimization, place a high priority on improving
algorithm efficiency
.
8.1.1 Time complexity
When the size of the data increases, an algorithm's time complexity measures how long it takes to
run. In other words, it explains how an algorithm's running time grows in proportion to the amount
of the input. The Big O notation is typically used to express the time complexity of an algorithm
and gives an upper bound on the rate of growth of the algorithm's running time.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
128
lOMoARcPSD|27610193
An algorithm's time complexity plays a significant role in deciding how effective it is. Because it
can handle larger inputs or finish tasks quicker, an algorithm with a lower time complexity will
typically be more effective than an algorithm with a higher time complexity.
For instance, the worst-case scenario for a linear search algorithm entails sequentially checking
each element of an input list until a match is discovered or the complete list is searched. This is
because a linear search algorithm has a time complexity of O(n). The target element in a sorted list
can be found using a binary search algorithm, which has a time complexity of O(log n), which
means that it can do so by splitting the search space in half at each stage. This results in a much
faster search time for big input sizes.
The time complexity of an algorithm should be taken into account when developing and analyzing
it to make sure it is suitable for the issue at hand and the anticipated input size. Algorithms with
lower time complexity are better suited for larger input sizes or when faster performance is
necessary, while algorithms with greater time complexity may be acceptable for small input sizes
or when only a small number of computations are needed.
8.1.2 Space complexity
The quantity of memory or storage an algorithm needs to run as the size of the input increases is
referred to as space complexity. The amount of memory required by the algorithm to keep its
internal data structures and intermediate results is specified.
Similar to time complexity, space complexity is typically expressed using Big O notation, which
sets a limit on how quickly the algorithm's memory utilization will increase. The quantity of extra
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
129
lOMoARcPSD|27610193
memory the algorithm needs above and beyond the size of the input itself is a common metric for
space complexity.
Since they use the least amount of memory to solve a problem, efficient algorithms generally have
low space complexity. An algorithm's ability to manage larger input sizes, use less expensive
hardware or cloud resources, and execute more quickly and reliably are just a few advantages that
can result from reducing an algorithm's space complexity.
A straightforward algorithm that adds up a list of numbers, for instance, has a space complexity of
O (1), which means that it only requires a fixed quantity of memory to store the sum as it is
computed. A recursive algorithm for computing the factorial of a number, however, has a space
complexity of O(n), which means that it must store intermediate results for each recursive call,
leading to a linear rise in memory utilization as the input size increases.
It is crucial to take space complexity into account when creating and analyzing algorithms and to
make sure that it is suitable for the issue at hand and the anticipated input size. Algorithms with
lower space complexity are better suited for larger input sizes or when memory usage must be kept
to a minimum, while algorithms with greater space complexity may be acceptable for small input
sizes or when memory usage is not a concern.
There are three asymptotic notations that are utilized to address the time complexity of an
algorithm. They are:
1. Θ Notation (theta)
2. Big O Notation
3. Ω Notation
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
130
lOMoARcPSD|27610193
o
Θ Notation (theta)
The Notation is used to visualize what is considered to be an algorithm's normal limit. For instance,
it defines an upper bound and a lower bound, and your algorithm will fall somewhere between
these two levels. This means that if a capacity is g(n), the theta portrayal will be displayed as (g(n))
and the link will be displayed as:
Θ(g(n)) = { f(n): there exist positive constants c1, c2 and n0
such that 0 ≤ c1g(n) ≤ f(n) ≤ c2g(n) for all n ≥ n0 }
The above articulation can be perused as theta of g(n) is characterized as set of the multitude of
capacities f(n) for which there exists some certain constants c1, c2, and n0 with the end goal that
c1*g(n) is not exactly or equal to f(n) and f(n) is not exactly or equal to c2*g(n) for all n that is
more noteworthy than or equal to n0.
For example:
if f(n) = 2n² + 3n + 1
and g(n) = n²
then for c1 = 2, c2 = 6, and n0 = 1, we can say that f(n) = Θ(n²)
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
131
lOMoARcPSD|27610193
Figure 32: Θ Notation (theta)
o
Ω Notation
The Ω documentation signifies the lower bound of an algorithm for example the time taken by the
algorithm can't be lower than this. At the end of the day, this is the quickest time in which the
algorithm will return an outcome. Its the time taken by the algorithm when given its best-case
input. Along these lines, on the off chance that a capacity is g(n), then, at that point, the omega
portrayal is displayed as Ω(g(n)) and the connection is displayed as:
Ω(g(n)) = { f(n): there exist positive constants c and n0
such that 0 ≤ cg(n) ≤ f(n) for all n ≥ n0 }
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
132
lOMoARcPSD|27610193
The above articulation can be perused as omega of g(n) is characterized as set of the multitude of
capacities f(n) for which there exist a few constants c and n0 with the end goal that c*g(n) is not
exactly or equal to f(n), for all n more noteworthy than or equal to n0.
For example:
if f(n) = 2n² + 3n + 1
and g(n) = n²
then for c = 2 and n0 = 1, we can say that f(n) = Ω(n²)
Figure 33: Ω Notation
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
133
lOMoARcPSD|27610193
o
Big O notation
The Big O documentation characterizes the upper bound of any algorithm for example you
algorithm can't take additional time than this time. All in all, we can say that the big O
documentation means the most extreme time taken by an algorithm or the most pessimistic
scenario time complexity of an algorithm. Thus, big O documentation is the most utilized
documentation for the time complexity of an algorithm. In this way, assuming a capacity is g(n),
then, at that point, the big O portrayal of g(n) is displayed as O(g(n)) and the connection is
displayed as:
O(g(n)) = { f(n): there exist positive constants c and n0
such that 0 ≤ f(n) ≤ cg(n) for all n ≥ n0 }
The above articulation can be perused as Big O of g(n) is characterized as a bunch of capacities
f(n) for which there exist a few constants c and n0 to such an extent that f(n) is more noteworthy
than or equal to 0 and f(n) is more modest than or equal to c*g(n) for all n more prominent than or
equal to n0.
For example
if f(n) = 2n² + 3n + 1
and g(n) = n²
then for c = 6 and n0 = 1, we can say that f(n) = O(n²)
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
134
lOMoARcPSD|27610193
Figure 34: Big O notation
Big O notation illustration of algorithms
The most popular notation for expressing an algorithm's temporal complexity is called Big O. We
will examine the big O notation of different algorithms in this blog section.
Example: Finding the amount of the main n numbers.
In this model, we need to observe the amount of first n numbers. For instance, assuming n = 4, our
output should be 1 + 2 + 3 + 4 = 10. Assuming n = 5, the ouput should be 1 + 2 + 3 + 4 + 5 = 15.
How about we try various solutions to this code and try to compare that large number of codes.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
135
lOMoARcPSD|27610193
O(1) solution
// function taking input "n"
int findSum(int n)
{
return n * (n+1) / 2; // this will take some constant time c1
}
In the above code, there is only one articulation and we know that an assertion requires some
investment for its execution. The essential thought is that assuming the assertion is taking constant
time, then, at that point, it will set aside a similar amount of effort for all the information size and
we denote this as O(1).
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
136
lOMoARcPSD|27610193
O(n) solution
int findSum(int n)
{
int sum = 0; // -----------------> it takes some constant time "c1"
for(int i = 1; i <= n; ++i) // --> here the comparision and increment will take place
n
times(c2*n) and the creation of i takes place with some constant time
sum = sum + i; // -----------> this statement will be executed n times i.e. c3*n
return sum; // ------------------> it takes some constant time "c4"
}
In this solution, we will run a loop from 1 to n and we will add these qualities to a variable named
"aggregate".
The big O notation of the above code is O(c0*n) + O(c), where c and c0 are constants. So, the
overall time complexity can be composed as O(n).
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
137
lOMoARcPSD|27610193
O(n²) solution
// function taking input "n"
int findSum(int n)
{
int sum = 0; // ---------------------> constant time
for(int i = 1; i <= n; ++i)
for(int j = 1; j <= i; ++j)
sum++; // -------------------> it will run [n * (n + 1) / 2]
return sum; // ----------------------> constant time
}
In this solution, we will augment the worth of total variable "I" times for example for I =1, the
total variable will be augmented once for example total = 1. For I = 2, the total variable will be
augmented twice. So, how about we see the solution.
The big O notation of the above algorithm is O(c1*n²) +O( c2*n) + O(c3). Since we take the higher
order of growth in big O. So, our expression will be decreased to O(n²).
So far, we have seen 3 solutions to an issue of a similar nature. Which method would you prefer
to use to find the total number of first "n" numbers? If your response is an O(1) solution, we have
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
138
lOMoARcPSD|27610193
one bonus part for you at the end of this blog post. Because the algorithm's execution time will be
constant regardless of the size of the information, we would lean toward the O(1) answer.
We learned how to analyze an algorithm's effectiveness using time and area complexity. Therefore,
there is essentially a compromise between time and space. If time is less than it usually is, room
will also be larger.
Different methods are used to evaluate algorithms. We examine the algorithm's effectiveness
through both time and space research. Sometimes it's necessary to look at how much memory or
room is being used. For instance, when managing vast amounts of data or developing embedded
devices. Furthermore, time complexity/efficiency shows that the quicker a program or function
completes a job, the better.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
139
lOMoARcPSD|27610193
9. Conclusion
We summarize each module's key ideas and go over its subjects once more in these concluding
notes. You should have gained a deeper understanding of programming from this lesson, with a
focus on the item-centered approach to programming. It ought to encourage you to think about
programming in terms of what you want to do to solve a problem or illustrate a situation rather
than just the features of the programming language you're using, and then how you would go about
doing that in your chosen programming language. You "invent your own instructions," or write
methods, and you "invent your own types," or write classes, to organize a program. Most of the
time, after considering the situation you're trying to portray, you'll determine what kind of
instructions you need. You will then engage in programming on two levels: The code that gives
these types and instructions is known as the implementation, whereas your own custom types and
instructions are used in the application. More intricate code can be further divided into
implementation and application components.
Design specification for data structures that describes the legitimate operations that can be carried
out on the structures as well as how a memory stack functions and how it is used to execute
determined function calls in a computer. Reports on the test outcomes, error handling, and a
challenging ADT implementation are all included in the paper. This paper shows how to assess an
algorithm's effectiveness using asymptotic analysis. Finally, the author offered two approaches for
assessing an algorithm's effectiveness, using an illustration to support your answer.
This subject covers a lot of material, so if you learn everything there is to know about it, it might
be difficult to comprehend. But since this is a practical part, you can use the executable code that
has been provided to test your own theories. That is the most efficient way to study this material,
create your own code or modify already-existing code, and see how what is covered in these notes
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
140
lOMoARcPSD|27610193
is used in practice. Like many practical abilities, they become simpler the more you use them.
When you use them, what seems difficult to describe in words turns out to be much simpler.
M.S.MARYAM RUQSHA /COL00088920 – DATA STRUCTURES & ALGORITHMS
Downloaded by TEST TEST (purpose30321@gmail.com)
141