DS FOR ALL engineering students

1. B.Tech II Year I Sem
Data Structures
Mr.N.PRASAD, M.Tech (SE),
Assistant Professor,
Department of CSE

2. UNIT – I
Introduction to Data Structures, abstract data types, Linear list – singly linked list implementation,
insertion, deletion and searching operations on linear list, Stacks- Operations, array and linked
representations of stacks, stack applications, Queues- operations, array and linked representations.
UNIT - II
Dictionaries: linear list representation, skip list representation, operations - insertion, deletion and
searching. Hash Table Representation: hash functions, collision resolution-separate chaining, open
addressing- linear probing, quadratic probing, double hashing, rehashing, extendible hashing.
SYLLABUS

3. UNIT – II
Search Trees: Binary Search Trees, Definition, Implementation, Operations- Searching,
Insertion and Deletion, B- Trees, B+ Trees, AVL Trees, Definition, Height of an AVL Tree,
Operations – Insertion, Deletion and Searching, Red –Black, Splay Trees.
UNIT – IV
Graphs: Graph Implementation Methods. Graph Traversal Methods. Sorting: Quick Sort, Heap
Sort, External Sorting- Model for external sorting, Merge Sort.
UNIT - V
Pattern Matching and Tries: Pattern matching algorithms-Brute force, the Boyer –Moore
algorithm, the Knuth-Morris-Pratt algorithm, Standard Tries, Compressed Tries, Suffix tries.

4. TEXT BOOK:
1. Fundamentals of Data Structures in C, 2 nd Edition, E. Horowitz, S. Sahni
and Susan Anderson Freed, Universities Press.
2. Data Structures using C – A. S.Tanenbaum, Y. Langsam, and M.J.
Augenstein, PHI/Pearson Education.
REFERENCE BOOKS:
1. 1. Data Structures: A Pseudocode Approach with C, 2 nd Edition, R. F. Gilberg and
B.A.Forouzan, Cengage Learning.

5. CO-1: To build the basic knowledge to handle operations like insertions, deletions,
searching, and traversing mechanisms in linear data structures.
CO-2: Understand Dictionaries, skip list and Hashing Techniques.
CO-3: Ability to have knowledge on general tree structures, search trees, AVL-trees,
B-Trees, B+ Trees, Red-Black Trees, Splay Trees.
CO-4: Apply suitable algorithms for graph traversing and sorting techniques.
CO-5: Implement and know the application of algorithms for pattern matching and
Tries.

6. Data Structures
 Data Structure is a particular way of storing and organizing data in the
memory of the computer so that these data can easily be retrieved and
efficiently utilized in the future when required.
 The scope of a particular data model depends on two factors:
1. First, it must be loaded enough into the structure to reflect the
definite correlation of the data with a real-world object.
2. Second, the formation should be so straightforward that one can
adapt to process the data efficiently whenever necessary.

7. Data Structure
Data structure is most fundamental building block concept in computer science.
To build a software system we use data structure.
Definition:
Data structure is a particular way of organizing data in a computer so that it can be used effectively.
Data structure is logical or mathematical organization of data; it describes how to store the data
and access data from memory.

8. Online movie ticket booking
Web browsing
Railway ticket booking Music player
Google map
Data Structure

9. Data Structures
 Some examples of Data Structures are Arrays, Linked Lists, Stack, Queue,
Trees, etc. Data Structures are widely used in almost every aspect of
Computer Science, i.e., Compiler Design, Operating Systems, Graphics,
Artificial Intelligence, and many more.
 Data Structures are the main part of many Computer Science Algorithms
as they allow the programmers to manage the data in an effective way. It
plays a crucial role in improving the performance of a program or
software, as the main objective of the software is to store and retrieve the
user's data as fast as possible.

10. Classification of Data Structures
 We can classify Data Structures into two categories:
 1. Primitive Data Structure
 2. Non-Primitive Data Structure

11. Data Structures
Primitive Data Structures
 Primitive Data Structures are the data structures consisting of the numbers
and the characters that come in-built into programs.
 These data structures can be manipulated or operated directly by machine-
level instructions.
 Basic data types like Integer, Float, Character, and Boolean come under
the Primitive Data Structures.
 These data types are also called Simple data types, as they contain
characters that can't be divided further

12. Data Structures
Non-Primitive Data Structures
 Non-Primitive Data Structures are those data structures derived from
Primitive Data Structures.
 These data structures can't be manipulated or operated directly by
machine-level instructions.
 The focus of these data structures is on forming a set of data elements that
is either homogeneous (same data type) or heterogeneous (different data
types).
 Based on the structure and arrangement of data, we can divide these data
structures into two sub-categories -

13. Data Structures
1.Linear Data Structures
2.Non-Linear Data Structures
Linear Data Structures
A data structure that preserves a linear connection among its data elements
is known as a Linear Data Structure. The arrangement of the data is done
linearly, where each element consists of the successors and predecessors
except the first and the last data element. However, it is not necessarily true
in the case of memory, as the arrangement may not be sequential.
Based on memory allocation, the Linear Data Structures are further
classified into two types:

14. Data Structures
1.Static Data Structures: The data structures having a fixed size are
known as Static Data Structures. The memory for these data structures is
allocated at the compiler time, and their size cannot be changed by the user
after being compiled; however, the data stored in them can be altered.
The Array is the best example of the Static Data Structure as they have a
fixed size, and its data can be modified later.
2.Dynamic Data Structures: The data structures having a dynamic size are
known as Dynamic Data Structures. The memory of these data structures is
allocated at the run time, and their size varies during the run time of the
code. Moreover, the user can change the size as well as the data elements
stored in these data structures at the run time of the code.
Linked Lists, Stacks, and Queues are common examples of dynamic data
structures

15. Non-Linear Data Structures
 In Non-Linear data structure, the data items are not in sequence.
 In the non-linear data structure the data elements are not stored in a
sequential manner rather the elements are hierarchically related.
 Here, the insertion and removal of data are not feasible in a linear manner.
There exists a hierarchical relationship between the individual data items.
 Types of Non-Linear Data Structures: Trees and Graphs

16. Abstract Data Type
Abstract Data type (ADT) is a type (or class) for objects whose behavior is defined by a
set of values and a set of operations. The definition of ADT only mentions what
operations are to be performed but not how these operations will be implemented. It
does not specify how data will be organized in memory and what algorithms will be
used for implementing the operations. It is called “abstract” because it gives an
implementation-independent view.
The process of providing only the essentials and hiding the details is known as
abstraction.

17. List ADT
The data is generally stored in key sequence in a list which has a head structure
consisting of count, pointers and address of compare function needed to compare the
data in the list.
The data node contains the pointer to a data structure and a self-referential
pointer which points to the next node in the list.
The List ADT Functions is given below:
get() – Return an element from the list at any given position.
insert() – Insert an element at any position of the list.
remove() – Remove the first occurrence of any element from a non-empty list.
removeAt() – Remove the element at a specified location from a non-empty list.
replace() – Replace an element at any position by another element.
size() – Return the number of elements in the list.
isEmpty() – Return true if the list is empty, otherwise return false.
isFull() – Return true if the list is full, otherwise return false.

18. Stack ADT
View of stack
In Stack ADT Implementation instead of data being stored in each node, the
pointer to data is stored.
The program allocates memory for the data and address is passed to the stack
ADT.
The head node and the data nodes are encapsulated in the ADT. The calling
function can only see the pointer to the stack.
The stack head structure also contains a pointer to top and count of number of
entries currently in stack.
push() – Insert an element at one end of the stack called top.
pop() – Remove and return the element at the top of the stack, if it is not empty.
peek() – Return the element at the top of the stack without removing it, if the
stack is not empty.
size() – Return the number of elements in the stack.
isEmpty() – Return true if the stack is empty, otherwise return false.
isFull() – Return true if the stack is full, otherwise return false.

19. Queue ADT
View of Queue
The queue abstract data type (ADT) follows the basic design of the stack abstract data
type.
Each node contains a void pointer to the data and the link pointer to the next element
in the queue. The program’s responsibility is to allocate memory for storing the data.
enqueue() – Insert an element at the end of the queue.
dequeue() – Remove and return the first element of the queue, if the queue is not
empty.
peek() – Return the element of the queue without removing it, if the queue is not
empty.
size() – Return the number of elements in the queue.
isEmpty() – Return true if the queue is empty, otherwise return false.
isFull() – Return true if the queue is full, otherwise return false.

20. Linked List
• Linked List can be defined as collection of objects called nodes that are
randomly stored in the memory.
• A node contains two fields i.e. data stored at that particular address and
the pointer which contains the address of the next node in the memory.
• The last node of the list contains pointer to the null.

21. Linked List
Uses of Linked List
• The list is not required to be contiguously present in the memory. The node
can reside any where in the memory and linked together to make a list. This
achieves optimized utilization of space.
• list size is limited to the memory size and doesn't need to be declared in
advance.
• Empty node can not be present in the linked list.
• We can store values of primitive types or objects in the singly linked list.
Why use linked list over array?
Till now, we were using array data structure to organize the group of elements
that are to be stored individually in the memory. However, Array has several
advantages and disadvantages which must be known in order to decide the
data structure which will be used throughout the program.

22. Linked List
Array contains following limitations:
1. The size of array must be known in advance before using it in the program.
2.Increasing size of the array is a time taking process. It is almost impossible to
expand the size of the array at run time.
3. All the elements in the array need to be contiguously stored in the memory.
Inserting any element in the array needs shifting of all its predecessors.
Linked list is the data structure which can overcome all the limitations of an
array. Using linked list is useful because,
1.It allocates the memory dynamically. All the nodes of linked list are non-
contiguously stored in the memory and linked together with the help of
pointers.
2. Sizing is no longer a problem since we do not need to define its size at the
time of declaration. List grows as per the program's demand and limited to
the available memory space.

23. Singly linked list or One way chain
• Singly linked list can be defined as the collection of ordered set of elements.
• The number of elements may vary according to need of the program.
• A node in the singly linked list consist of two parts: data part and link part.
• Data part of the node stores actual information that is to be represented by
the node while the link part of the node stores the address of its immediate
successor.
• One way chain or singly linked list can be traversed only in one direction. In
other words, we can say that each node contains only next pointer,
therefore we can not traverse the list in the reverse direction.
• Consider an example where the marks obtained by the student in three
subjects are stored in a linked list as shown in the figure.

24. Singly linked list or One way chain
In the above figure, the arrow represents the links. The data part of every node
contains the marks obtained by the student in the different subject. The last
node in the list is identified by the null pointer which is present in the address
part of the last node. We can have as many elements we require, in the data
part of the list.

25. Operations on Singly Linked List
There are various operations which can be performed on singly linked list. A list of all
such operations is given below.
Node Creation
1. struct node
2. {
3. int data;
4. struct node *next;
5. };
6. struct node *head, *ptr;
7. ptr = (struct node *)malloc(sizeof(struct node *));

26. Insertion
The insertion into a singly linked list can be performed at different positions.
Based on the position of the new node being inserted, the insertion is
categorized into the following categories.
SN Operation Description
1
Insertion at be
ginning
It involves inserting any element at the front of the list. We just need to a
few link adjustments to make the new node as the head of the list.
2
Insertion at en
d of the list
It involves insertion at the last of the linked list. The new node can be
inserted as the only node in the list or it can be inserted as the last one.
Different logics are implemented in each scenario.
3
Insertion after
specified node
It involves insertion after the specified node of the linked list. We need to
skip the desired number of nodes in order to reach the node after which
the new node will be inserted. .

27. SN Operation Description
1 Deletion at beginning It involves deletion of a node from the beginning of the list. This is the
simplest operation among all. It just need a few adjustments in the node
pointers.
2 Deletion at the end of the
list
It involves deleting the last node of the list. The list can either be empty or
full. Different logic is implemented for the different scenarios.
3 Deletion after specified no
de
It involves deleting the node after the specified node in the list. we need
to skip the desired number of nodes to reach the node after which the
node will be deleted. This requires traversing through the list.
4 Traversing In traversing, we simply visit each node of the list at least once in order to
perform some specific operation on it, for example, printing data part of
each node present in the list.
5 Searching In searching, we match each element of the list with the given element. If
the element is found on any of the location then location of that element
is returned otherwise null is returned. .
Deletion and Traversing

28. Linked List in C:
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *next;
};
struct node *head;
void beginsert ();
void lastinsert ();
void randominsert();
void begin_delete();
void last_delete();
void random_delete();
void display();
void search();
void main ()
{
int choice =0;
while(choice != 9)
{
printf("nn*********Main Menu*********n");
printf("nChoose one option from the following list ...n");
printf("n=======================================n");
printf("n1.Insert in beginingn2.Insert at lastn
3.Insert at any random locationn 4.Delete from
Beginning n 5.Delete from lastn
6.Delete node after specified locationn
7.Search for an elementn8.Shown9.Exitn");
printf("nEnter your choice?n");
scanf("n%d",&choice);

29. Linked List in C:
switch(choice)
{
case 1:
beginsert();
break;
case 2:
lastinsert();
break;
case 3:
randominsert();
break;
case 4:
begin_delete();
break;
case 5:
last_delete();
break;
case 6:
random_delete();
break;
case 7:
search();
break;
case 8:
display();
break;
case 9:
exit(0);
break;
default:
printf("Please enter valid choice..");
}
}
}

30. Linked List in C:
void beginsert()
{
struct node *ptr;
int item;
ptr = (struct node *) malloc(sizeof(struct node *));
if(ptr == NULL)
{
printf("nOVERFLOW");
}
else
{
printf("nEnter valuen");
scanf("%d",&item);
ptr->data = item;
ptr->next = head;
head = ptr;
printf("nNode inserted");
}

31. Linked List in C:
void lastinsert()
{
struct node *ptr,*temp;
int item;
ptr = (struct node*)malloc(sizeof(struct node));
if(ptr == NULL)
{
printf("nOVERFLOW");
}
else
{
printf("nEnter value?n");
scanf("%d",&item);
ptr->data = item;
if(head == NULL)
{
ptr -> next = NULL;
head = ptr;
printf("nNode inserted");
}
else
{
temp = head;
while (temp -> next != NULL)
{
temp = temp -> next;
}
temp->next = ptr;
ptr->next = NULL;
printf("nNode inserted");
}
}
}

32. Linked List in C:
void randominsert()
{
int i,loc,item;
struct node *ptr, *temp;
ptr = (struct node *) malloc (sizeof(struct node));
if(ptr == NULL)
{
printf("nOVERFLOW");
}
else
{
printf("nEnter element value");
scanf("%d",&item);
ptr->data = item;
printf("
nEnter the location after which you want to insert ");
scanf("n%d",&loc);
for(i=0;i<loc;i++)
{
temp = temp->next;
if(temp == NULL)
{
printf("ncan't insertn");
return;
}
}
ptr ->next = temp ->next;
temp ->next = ptr;
printf("nNode inserted");
}
}