This document describes a course on data structures and algorithms. The course covers fundamental algorithms like sorting and searching as well as data structures including arrays, linked lists, stacks, queues, trees, and graphs. Students will learn to analyze algorithms for efficiency, apply techniques like recursion and induction, and complete programming assignments implementing various data structures and algorithms. The course aims to enhance students' skills in algorithm design, implementation, and complexity analysis. It is worth 4 credits and has prerequisites in computer programming. Student work will be graded based on assignments, exams, attendance, and a final exam.

1. Course Title: Data Structures and
Algorithms
Course code: CS211
Credit Hours: 4(3+1)
Prerequisite: Introduction to Computer
Programming
Course objectives:
Detailed study of the basic notions of the design of
algorithms and the underlying data structures.
Several measures of complexity are introduced.
Emphasis on the Algorithms development, Testing
complexity, and efficiency of algorithms.
Learning outcomes:
Fundamental algorithms design principles such as
Divide and Conquer, Different sorting and searching
algorithms are introduced and explored through case
studies to demonstrate the design of efficient
solutions to computational problems. On completion
of the module a student should be able to:

2.  Identify the fundamental strategies in algorithmic
design
 Distinguish which strategy is appropriate to solve
a given problem
 Classify different algorithmic strategies
 Analyze a given algorithm and assess its
efficiency
 Apply techniques of proof by induction to verify
certain properties of algorithms.
 Coursework will enhance a student's algorithm
design and program implementation skills.
Course Outlines :
Introduction to Data Structures and Algorithms;
Complexity Analysis; Arrays; Sorting Algorithms:
Insertion Sort, Selection Sort, Bubble Sort, Shell
Sort, Heap Sort, Quick Sort, Merge Sort, Radix Sort,
Bucket Sort; Linked Lists: Singly Linked Lists,
Doubly Linked Lists, Circular List; Stacks, Queues,
and Priority Queue; Recursion: Function call and
Recursion Implementation, Tail Recursion, Non-tail
Recursion, Indirect Recursion, Nested Recursion,

3. Backtracking. Trees: Binary Trees, Binary Heap,
Binary Search. Tree Traversal, Insertion, Deletion,
and Balancing a Tree; Heap; B-Tree; Spanning Tree,
Splay Trees; Graphs: Representation, Traversal,
Shortest Path, and Cycle Detection; Isomorphic
Graphs; Graph Traversal Algorithms; Hashing;
Memory Management and Garbage Collection.
LAB Work:
1 Write a program to search an element in a two
dimensional array
2 Using iteration and recursion concepts write
programs for finding the element in the array
using the Binary search method.
3 Write a program to perform following
operations on tables by user defined
functions: Addition, Subtraction,
Multiplication, and Transpose.
4 Write a program using iteration and recursion
concepts for quick sort.
5 Write a program to implement various
operations on strings.
6 Write a program for swapping two numbers
using call by value and call by reference
strategies.
7 Write a program to implement Binary search
tree.

4. 8 Write a program to create a Linked List and
perform operations such as insert, delete,
update and reverse.
9 Write a program to simulate various sorting
and searching algorithms.
10 Write a program to simulate various Graph
traversing techniques.
11 Write a program to simulate various tree
traversal techniques.
12 Implement data structures in C++
Reference Materials (Latest Editions of the
following books):
1. Data Structures and Algorithm Analysis, Mark
Allen Weiss, Florida International University,
Addison-Wesley
2. Algorithms, Robert Sedgewick, Princeton
University Publisher: Addison- Wesley Professional
3. Data Structures: Abstraction and Design Using
Java, Koffman and Wolfgang, Wiley;
4. Data Structures and Algorithms in C++, Adam
Drozdek, Course Technology;

5. Grading Policy:
1.Assignment /Presentation/ Quizzes /Group
Discussions 15%
2.Attendance (Minimum class attendance 75% of
the total lectures ) 05%
3.Mid Term Examination
30%
4.Final Examination
50%
Data Structure:
Data :
• The collection of raw material or facts and
figures about any object is called data.
• e.g

6. • Student data
• Name, Age, Rno, Class, Section, Gender ,
Address, Phone no, Blood group,
Data Structure
• Organization of data into computer memory is
called data structure.
• Data structure deals with “How data is organized
in memory”.
• Data may be organized in many different ways:
• The logical or mathematical model of particular
organization of data is called a data structure.
• The choice of a particular data model depends
on two considerations.
• First it must be rich enough in structure to mirror
the actual relationships of the data in real world.
• The structure should be simple enough that one
.can effectively process the data when necessary.
Classification of Data Structure

7. • Linear
• Non linear
Linear
• The organization of data in which each node
except first and last have only one proceeding
and succeeding node is called linear data
structure
•
• Arrays
• Stacks
• Queues
• Lists, etc
Non Linear
• When the data is stored in the computer memory
in hierarchical way or in non linear form, then it
is called non linear data structure
• e.g
• Trees

8. • Files
• Graphs
Algorithms:
• An algorithm is any well-defined computational
procedure that takes some values, or set of
values, as input and produces some value, or set
of values, as output. An algorithm is thus a
sequence of computational steps that transform
the input into output.
• It can be described in a natural language,
pseudocode, a flow- chart, or even a
programming language.

9. Criteria/Characteristics of Algorithms
• Finiteness
• Definiteness - no ambiguity /unambiguous
• Input
• Output
• Effectiveness
• Efficient
• Concise and Compact
• Sequence No.
• Correctness
Finiteness
• An algorithm must terminate after a finite
number of steps and further each step must be
executable in finite amount of time.
• In order to establish a sequence of steps as an
algorithm, it should be established that it
terminates (in finite number of steps) on all
allowed inputs.

10. Definiteness (no ambiguity , clarity )
• Each steps of an algorithm must be precisely
defined and it should be unambiguous.
Inputs
• An algorithm must have input values from a
specified set.
• An algorithm has zero or more but only finite
number of inputs.
Output:
• An algorithm must produce some values called
output.
• An algorithm has one or more outputs.
• The requirement of at least one output is
obviously essential, because, otherwise we
cannot know the answer/ solution provided by
the algorithm.
• The outputs have specific relation to the inputs,
where the relation is defined by the algorithm.

11. Effectiveness
• Effectiveness is the capability of producing a
desired result.
• An algorithm should be effective/useful.
Efficient
• An algorithm should not use unnecessary
memory locations.
Concise and compact
• An algorithm should be concise and compact.
Sequence No.
• Each step of algorithm must have a sequence
number.
Correctness
• Each step of an algorithm must be correctly
defined.

12. Need for Data Structures
 Data structures organize data  more efficient
programs.
 More powerful computers  more complex
applications.
 More complex applications demand more
calculations.
Efficiency
 A solution is said to be efficient if it solves the
problem within its resource constraints.
– Space
– Time
– The cost of a solution is the amount of
resources that the solution consumes.

13. Selecting a Data Structure
Select a data structure as follows:
1.Analyze the problem to determine the resource
constraints a solution must meet.
2.Determine the basic operations that must be
supported. Quantify the resource constraints for
each operation.
3.Select the data structure that best meets these
requirements
Some Questions to Ask
• Are all data inserted into the data structure at the
beginning, or are insertions interspersed with
other operations?
• Can data be deleted?
• Are all data processed in some well-defined
order, or is random access allowed?

14. Data Structure Philosophy
 Each data structure has costs and benefits.
 Rarely is one data structure better than another
in all situations.
 A data structure requires:
– space for each data item it stores,
– time to perform each basic operation,
– programming effort.

15. Arrays:
 Elementary data structure that exists as built-in
in most programming languages.
An array is a collection of items stored at contiguous
memory locations. The idea is to store multiple items
of the same type together. This makes it easier to
calculate the position of each element by simply
adding an offset to a base value, i.e., the memory
location of the first element of the array (generally
denoted by the name of the array).
main( int argc, char** argv )
{
int x[6];
int j;
for(j=0; j < 6; j++)
x[j] = 2*j;
}

16.  Array declaration: int x[8];
 An array is collection of cells of the same type.
 The collection has the name ‘x’.
 The cells are numbered with consecutive
integers.
 To access a cell, use the array name and an
index:
x[0], x[1], x[2], x[3], x[4], x[5]
Array Layout
Array cells are contiguous in computer memory.
The memory can be thought of as an array.
X[0]
X[1]
X[2]
X[3]

17. X[4]
X[5]
X[6]
X[7]
What is Array Name?
 ‘x’ is an array name but there is no variable
x. ‘x’ is not an lvalue.
 For example, if we have the code
int a, b;
then we can write
b = 2;
a = b;
a = 5;

18.  But we cannot write
2 = a;
 ‘x’ is not an lvalue
int x[6];
int n;
x[0] = 5;
x[1] = 2;
x = 3; // not allowed
x = a + b; // not allowed
x = &n; // not allowed

19. Dynamic Arrays
 You would like to use an array data
structure but you do not know the size
of the array at compile time.
 You find out when the program
executes that you need an integer array
of size n=20.
 Allocate an array using the new
operator:
int* y = new int[20]; // or int* y = new
int[n]
y[0] = 10;
y[1] = 15; // use is the same

20.  ‘y’ is a lvalue; it is a pointer that holds
the address of 20 consecutive cells in
memory.
 It can be assigned a value. The new
operator returns as address that is
stored in y.
 We can write:
y = &x[0];
y = x; // x can appear on the
right
// y gets the address of
the
// first cell of the x array
 We must free the memory we got
using the new operator once we are
done with the y array.
delete[ ] y;


21.  We would not do this to the x array
because we did not use new to create
it.
There is a substantial difference
between declaring a normal array
and allocating dynamic memory
for a block of memory using new.
The most important difference is
that the size of a regular array
needs to be a constant
expression, and thus its size has
to be determined at the moment
of designing the program, before
it is run, whereas the dynamic
memory allocation performed
by new allows to assign memory
during runtime using any variable
value as size.

22. The LIST Data Structure
 The List is among the most generic of data
structures.
 Real life:
a.shopping list,
b.groceries list,
c.list of people to invite to dinner
d.List of presents to get
 A list is collection of items that are all of the
same type (grocery items, integers, names)
 The items, or elements of the list, are stored in
some particular order
 It is possible to insert new elements into various
positions in the list and remove any element of
the list
 List is a set of elements in a linear order.
For example, data values a1, a2, a3, a4 can be
arranged in a list:
(a3, a1, a2, a4)

23. In this list, a3, is the first element, a1 is the
second element, and so on
 The order is important here; this is not just a
random collection of elements, it is an ordered
collection
List Operations
Useful operations
• createList(): create a new list (presumably
empty)
• copy(): set one list to be a copy of another
• clear(); clear a list (remove all elments)
• insert(X, ?): Insert element X at a particular
position in the list
• remove(?): Remove element at some position in
the list
• get(?): Get element at a given position
• update(X, ?): replace the element at a given
position with X
• find(X): determine if the element X is in the list
• length(): return the length of the list.
List Operations

24.  We need to decide what is meant by “particular
position”; we have used “?” for this.
There are two possibilities:
1.Use the actual index of element: insert after
element 3, get element number 6. This
approach is taken by arrays
2.Use a “current” marker or pointer to refer to
a particular position in the list.
List Operations
 If we use the “current” marker, the following
four methods would be useful:
 start(): moves to “current” pointer to the
very first element.
 tail(): moves to “current” pointer to the very
last element.
 next(): move the current position forward
one element
 back(): move the current position backward
one element