DS Module 1.pptx

MODULE -1
Introduction to
Data Structures

MO D U L E 1
Introduction:
 Data Structures
 Classifications (Primitive & Non Primitive)
 Data structure Operations

MO D U L E 1
Array Operations:
 Traversing, Inserting , Deleting , Searching and sorting
 Multidimensional Arrays
 Polynomials
 Sparse Matrices
Strings:
 Basic Terminology
 Storing
 Operations and Pattern Matching algorithms.
 Programming Examples.

INTRODUCTION
 Data may be organized in many different ways.
(Data are simply values or sets of values)
 The logical or mathematical model of a particular
organization of data is called a data structure.
 Data Structure is a way of collecting and organizing data
in such a way that we can perform operations on these
data in an effective way.
 Data Structures is about rendering data elements in
terms of some relationship, for better organization and
storage.

INTRODUCTION
 The study of data structures includes the following three
steps:
1. Logical or mathematical description of the structure.
2. Implementation of the structure on a computer.
3. Quantitative analysis of the structure which includes
determining the amount of memory needed to store the
structure and the time required to process the structure.

INTRODUCTION
 Example: We have player's name “Virat" and age 32.
Here " Virat " is of String data type and 32 is of
integer data type.
 We can organize this data as a record like Player record.
Now we can collect and store player's records in a file or
database as a data structure. For example: "Gayle" 30,
"Sachin" 31, “Pointing" 33.
 In simple language, Data Structures are structures
programmed to store ordered data so that various
operations can be performed on it easily.

INTRODUCTION
Primitive Data Structures
 Primitive data types are the data types available in most
of the programming languages.
 These data types are used to represent single value.
 It is a basic data type available in most of the
programming language.

INTRODUCTION
 Based on the structure and arrangement of data, non-
primitive data structures is further classified into
1. Linear Data Structure
2. Non-linear Data Structure
 Data structure where data elements are arranged
sequentially or linearly where the elements are attached
to its previous and next adjacent in what is called
a linear data structure.
 In linear data structure, single level is involved.

INTRODUCTION
 Therefore, we can traverse all the elements in single run
only.
 Linear data structures are easy to implement because
computer memory is arranged in a linear way.
 Its examples are array, stack, queue, linked list etc.

INTRODUCTION
Arrays:
 The array is a type of data structure that stores elements
of the same type.
 These are the most basic and fundamental data
structures.
 Data stored in each position of an array is given a
positive value called the index of the element.
 The index helps in identifying the location of the
elements in an array.

INTRODUCTION
Stack:
 An element may be inserted or deleted at one end which
is known as Top of the stack.
 The data structure follows the rule of LIFO (Last In-
First Out) where the data last added element is removed
first.
 Push operation - adding an element of data on a stack,
pop operation - deleting the data from the stack.

INTRODUCTION
Queue
 This structure is almost similar to the stack as the data
is stored sequentially.
 The difference is that the queue data structure follows
FIFO which is the rule of First In-First Out where
the first added element is to exit the queue first.
 Front and rear are the two terms to be used in a queue.

INTRODUCTION
Linked list:
 Linked lists are the types where the data is stored in the
form of nodes which consist of an element of data and a
pointer.
 The use of the pointer is that it points or directs to the
node which is next to the element in the sequence.
 The data stored in a linked list might be of any form,
strings, numbers, or characters.
 Both sorted and unsorted data can be stored in a linked
list along with unique or duplicate elements.

INTRODUCTION
Non-Linear Data Structure
 Data structures where data elements are not arranged
sequentially or linearly are called non-linear data
structures.
 In a non-linear data structure, single level is not involved.
 Therefore, we can’t traverse all the elements in single run
only.
 Non-linear data structures are not easy to implement in
comparison to linear data structure.
 It utilizes computer memory efficiently in comparison to a
linear data structure. Its examples are trees and graphs.

INTRODUCTION
Trees:
 A tree data structure consists of various nodes linked together.
 The structure of a tree is hierarchical that forms a relationship
like that of the parent and a child.
 The structure of the tree is formed in a way that there is one
connection for every parent-child node relationship.
 Only one path should exist between the root to a node in the
tree.
 Various types of trees are present based on their structures
like AVL tree, binary tree, binary search tree etc.

INTRODUCTION
Graph:
 Graphs are those types of non-linear data structures
which consist of a definite quantity of vertices and edges.
 The vertices or the nodes are involved in storing data and
the edges show the vertices relationship.
 The difference between a graph to a tree is that in a
graph there are no specific rules for the connection of
nodes.
 Real-life problems like social networks, telephone
networks etc. can be represented through the graphs.

INTRODUCTION
Data Structures Operations
1. Traversing: Accessing each record/node exactly once so
that certain items in the record may be processed.
(This accessing and processing is sometimes called
“visiting” the record.)
2. Searching: Finding the location of the desired node
with a given key value or finding the locations of all
such nodes which satisfy one or more conditions.
3. Inserting: Adding a new node/record to the structure.
4. Deleting: Removing a node/record from the structure.

INTRODUCTION
The following two operations, which are used in special
situations:
1. Sorting: Arranging the records in some logical order
(e.g., alphabetically according to some NAME key, or in
numerical order according to some NUMBER key, such
as social security number or account number)
2. Merging: Combining the records in two different sorted
files into a single sorted file.

Abstract Data Type
• Abstract Data type (ADT) is a type (or class) for objects whose
behaviour 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.

List ADT Functions
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.

Stack ADT
• 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.

Queue ADT
• 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.

Features of ADT:
• Abstraction: The user does not need to know the
implementation of the data structure.
• Better Conceptualization: ADT gives us a better
conceptualization of the real world.
• Robust: The program is robust and has the ability to
catch errors.

Algorithm : Complexity: Space –
Time Tradeoffs
An Algorithm is a well defined list of steps for solving
a particular problem.
• Time & Space are major measures of the efficiency
of an algorithm.
• The complexity of algorithm is function which gives
the running time or space in terms of the input size.
• Choosing best algorithms & data structures
involves time-space tradeoff.
• By increasing the amount of storing the data can
reduce the time needed for processing the data.

Examples for Complexity.
Linear Search:
• Search each record of the file, one at a time, until
finding the given name.
• Time required to execute the algorithm is proportional
to the no. of comparisons.
• The avg no. of comparisons will be equal to n/2
• Therefore complexity of the linear search algorithm is
C(n)= n/2.
Binary Search:
• Compare the name with the name in the middle of the
list, this tells which half of the list contains Name.
• Continue process till find the name
• Complexity of Binary search algorithm is C(n) = log2 n.

Algorithm Notation
Algorithm ia a finite step by step list f well defined
instructions for solving particular problem.

Steps to write algorithm:
1. Paragarph - tells about problem statement.
2. Identifying no.
3.Steps, Control, Exit
4. Comments
5. Variable Names
6. Assignment Statements
7. Input & Output

Complexity of Algorithms
Efficiency of an Algorithm: Depends on Time &
Space measures.
Time measured by counting the no. of key
operations.
Space is measured by counting the maximum of
memory needed by the algorithm.
Space is simply multiple of the data size.
time not only depends on input size but also on the
particular data.
Worst case - Max value of f(n) for any possible
input.
Aveage case - the expected value f(n).

Asymptotic Notation
O big oh - Upper bound of function
Big Omega - lower bound
theta - Average bound

INTRODUCTION
Review of arrays:
 AnArray is an ordered set of similar data items.
 All the data items of an array are stored in consecutive memory
locations.
 The data items of an array are of same type and each data items
can be accessed using the same name but different index value.
 An array is a set of pairs, <index, value > such that each index has
a value associated with it.
 It can be called as corresponding or a mapping.

INTRODUCTION
 Array is a collection of elements of same data type.
 The elements are stored sequentially one after the other in
memory.
Examples:
1. List of employees in an organization.
2. List of products and their cost sold by a store.
3. Test scores of a class of students.
 Any element in an array can be accessed by using
→ name of the array.
→ position of elementC
iH
nET
thH
eAN
aC
rray.

INTRODUCTION
 Each element of the array has its own storage location, which can
be referenced like any other variable.
 The elements of an array are stored in consecutive storage
locations in memory and identified by the name of the array
followed by a number in brackets.
 These numbers start at 0.
 int a[5]={10, 60, 80, 40, 50};
 The five elements of a are represented as a[0], a[1], a[2], a[3] and
a[4].
 So what is the value of a[2]? 80.

INTRODUCTION
 The number written in the square brackets 0,1,2,3,4 is called an
index or subscript.
 The index of all arrays in C are numbered starting with 0 and
increase each time by 1.
 Consider an array of 5 integers : int n[5] = {35,40,20,57,19};
 Here n[0] = 35 , n[1] = 40 , n[2] = 20 , n[3] = 57 and n[4] = 19
n[0] n[1] n[2] n[3] n[4]

INTRODUCTION
Rules :
1. The array should be declared with some data type.
2. All the arrays elements should be of same data type.
3. The size of the array is finite and it should be specified at the
time of its declaration.
4. Only one element can be added or removed from the array at a
time.
5. The index of the first element is always zero.
6. Each element is accessed using the name of the array but with
different indexes.

INTRODUCTION
memory.
 Arrays are classified into three types:
1. Single dimensional Arrays / One dimensional array.
2. Two dimensional Arrays.
3. Multidimensional Arrays.
 Single dimensional array is one in which the array variable uses
single index and single pair of square brackets to store
multiple values of similar data types.
 Like any other variable, arrays must be declared before they
are used so that the compiler can allocate space for them in

INTRODUCTION
datatype variable_name[SIZE];
 Here data type can be like int or char or float.
 Size is the maximum number of elements that can be stored
inside the array.
 Examples:
float height[50];
int group[10];
char name[10];
 After array is declared, the elements needs to be initialised.
Otherwise they will containC
H
gE
aT
H
rbA
N
agC
e values.
 The general form of array declaration is:

INTRODUCTION
 An array can be initialized at either of the following stages :
1. At compile time.
2. At run time.
At compile time :
The initialization is done during declaration or anywhere inside the
program before running a program.
 The general form of initialization of arrays is :
Datatype variable_name[SIZE] = { list of values };
 Examples:
int number[3] = {0, 0, 0}
float total[5] = {0.0, 15.75, -10}

INTRODUCTION
 The different methods of compile time initialization are:
a) Initialization with size.
b) Initialization without size.
c) Partial initialization.
d) Initializing all values zero.
Initialization with size:
 We can initialize values to all the elements of the array.
Syntax: data_type array_name[size]={list of values};
 Examples:
float temperature[5]={29.5, 30.7, 35.6, 45.7, 19.5};

INTRODUCTION
Initialization without size:
 Here we don’t have to specify the size of array provided.
 We will be initializing the values in beginning itself.
Syntax: data_type array_name[ ]={list of values};
 Size will be automatically created based on the number of
elements.
 Examples:
int marks[ ]={ 95,35, 67, 87};
float temperature[ ]={29.5, 30.7, 35.6, 45.7, 19.5};

INTRODUCTION
Partial initialization:
 If we not specify the all the elements in the array, the unspecified
elements will be initialized to zero.
 Example: int a[5]={10,12,20};
 Here a[3] and a[4] will be initialized to zero.
Initializing all the elements zero:
 If we want to store zero to all the elements in the array then we
can do so by initializing all the elements to zero.
 Examples:
int marks[4]={0};
float temperature[5]={0};
 Here all the 4 elements in array marks and all the 5 elements in
array temperature will be equal to zero.

INTRODUCTION
2.At run time:
 The initialization is done during run time or program
execution.
This approach is usually applied for initializing large arrays.
Example:
printf(“Enter the marks”);
for(i=0; i<4; i++)
{
scanf(“ %d”, &marks[i]);
}
 Every iteration of for loop will help us to fill values into marks
array.
 (marks[0]=95, marks[1]=35, marks[2]=67, marks[3]=87)

INTRODUCTION
CharacterArray:
 If the elements of array is made up of characters, the array is
said to be character array.
Declaration of character array:
char name[size];
Example: char message[20];
Using a constant as array size:
 The constant can also be used to define the array size.
 But the constants must have been defined earlier before the
usage of the constants in the array index.
#define NUM 150 //Header file to define values.
int test[NUM];

INTRODUCTION
 If the memory address of list[i] need to compute by the compiler,
then the size of the int would get by sizeof (int), then memory
address of list[i] is as follows:
list[i] = α + i * sizeof (int)
 α is base address.

INTRODUCTION
MultidimensionalArrays:
 Array with two or more indexes are called multidimensional
arrays.
 Many applications require that data be stored in more than one
dimension.
 int a[10][10];
 int a[10][5][20];
 int a[5][5]----[n];

INTRODUCTION
Structures:
 A Structure is a collection of one or more variables of similar
or dissimilar data types, grouped together under a single name.
 A structure is a derived data type containing multiple variable of
homogeneous or heterogeneous data types.
 Example: it can represent set of attributes such as studentname,
rollno, marks in a student database.
 The structure is defined using the keyword struct followed by an
identifier.
 This identifier is called struct_tag.

INTRODUCTION
struct struct_tag
{
type var_1;
type var_2;
------------
------------
type var_n;
} ;
 The word struct is a keyword in C.
 The item identified as struct_tag is called a tag/Identifier and
identifies the structure later in the program.
 Each type1, - - - - - - type n can be any data type in C.

INTRODUCTION
 The item var_1, var_2, - - - - - var_n are the members of the
structure.
struct student
{
char name[20];
int rollnumber;
float marks;
};

INTRODUCTION
Defining a Structure:
 Structures must be defined first for their format that may be used
later to declare structure variables.
 Consider a book database consisting of bookname, author, number
of pages and price.
Struct book_bank
{
char title[20];
char author[15];
int pages;
float price;
};

INTRODUCTION
 The keyword struct declares a structures to hold details of four
fields - title, author, pages and price.
 These fields are called structure elements
members. book_bank is called structure tag.
Declaring Structure Variables:
or structure
 After defining a structure format we have declare variables of that
type.
 A Structure variable declaration is similar to the declaration of
variables of any other data types.

INTRODUCTION
 It includes the following elements.
1. The keyword struct
2. The structure tag name.
3. List of variable names separated by commas.
4. Aterminating semicolon.
Example : struct bookbank book1, book2, book3;
declares
book1, book2 and book3 as variables of type struct bookbank.

INTRODUCTION
struct bookbank
{
char title[20];
char author[15];
int pages;
float price;
}; struct bookbank book1, book2, book3;
It can also be done like given below:
struct bookbank
{
char title[20];
char author[15];
int pages;
float price;
}book1, book2, book3;

INTRODUCTION
 The keyword struct declares a structures to hold details of four
fields - title, author, pages and price.
 These fields are called structure elements
members. book_bank is called structure tag.
Things to Remember:
or structure
1. The template is terminated with a semicolon.
2.Even though the entire definition is considered as a statement,
each member is declared independently for its name and type in a
separate statement inside the template.

INTRODUCTION
Declaring Structure Variables:
 After defining a structure format we have declare variables of that
type.
 A Structure variable declaration is similar to the declaration of
variables of any other data types.
 It includes the following elements.
1. The keyword struct
2. The structure tag name.
3. List of variable names separated by commas.
4. Aterminating semicolon.

INTRODUCTION
CHETHAN C
Example : struct bookbank book1, book2, book3;
declares
book1, book2 and book3 as variables of type struct bookbank.
struct bookbank
{
char title[20];
char author[15];
int pages;
float price;
};
struct bookbank book1, book2, book3;
 It can also be done like given below:
struct bookbank
{
char title[20];
char author[15];
int pages;
float price;
}book1, book2, book3;

INTRODUCTION
Structure Initialization:
 Assigning the values to the structure member fields is structure
initialization.
 The syntax of initializing structure variables is similar to that of
arrays i.e. all the elements will be enclosed within braces { } and
are separated by commas.
 The syntax is:
struct struct_tag variable = { v1, v2, v3 ------- vn};
 Example: struct student cse = {“Raju”, 18, 87.5};

INTRODUCTION
Structure Definition:
struct employee
{
char name[20];
int salary;
int id;
};
Structure Declaration
struct employee emp1, emp2;
Structure Initialization:
struct employee emp1 = {“Yash”, 20000, 1000};
struct employee emp2 = { “Radhika”, 10050, 200};

INTRODUCTION
Rules to be remembered while initializing structure variables:
1. We cannot initialize individual members inside the structure template.
2. The order of values enclosed in braces must match the order of
members in the structure definition.
3. It is permitted to have a partial initialization. We can initialize only the
first few members and leave the remaining blank.
4. The uninitialized members should be only at the end of the list.
5. The uninitialized members will be assigned default values as follows:
Zero for integer and floating point numbers.
‘0’for character and strings.

INTRODUCTION
Accessing Members of Structures :
 The member of structure is identified and accessed using the dot operator (.)
 The dot operator connects the member name to the name of its containing
structure.
 The general syntax is :
struct_variable.membername;
 Consider the following structure:
struct employee
{
char name[10];
float salary ;
int id ;
};
 struct employee E1 = {“RAMA”, 10950.0, 2001};
 struct employee E2 = {“KRISH”, 11950.0, 2002};

INTRODUCTION
Reading the values for various members of structures :
 The values of members of structure variables can be read using scanf
or gets or getc and dot operator
gets(E1.name); or scanf(“%s”, E1.name);
scanf(“%f”, &E1.salary);
scanf(“%d”, &E1.id);
 gets(E1.name); //reads name of the employee 1
 scanf(“%f”,&E1.salary); //reads the salary of employee 1
 scanf(“%d”,&E2.id); //reads the employee 2 id

INTRODUCTION
Displaying the various members of Structures:
 The values of members of structure variable can be displayed using
the printf and dot operator
printf(“%sn”, E1.name); //prints the name of the employee 1
printf(“%fn”, E2.salary); //prints the salary of the employee 2
printf(“%dn”, E2.id); //prints the id of the employee 2.
 What will the following statement do?
printf(“%fn”, E1.salary);
 It will print the salary of the employee 1.

INTRODUCTION
Memory Representation of Structure:
 When structure is declared the sum of memory required for each members
will get allocated contiguously.
 Consider the employee structure:
struct employee
{
char name[10];
float salary ;
int id ;
};
struct employee E1 = { “RAMA”, 10950.0, 2001};
 For the structure employee the total amount of memory of 16 Bytes will get
allocated.

INTRODUCTION
 10 Bytes for name, 4 Bytes for Salary and 2 Bytes for id.

INTRODUCTION
Nested Structures:
 Astructure can be a member of another structure.
 A structure which includes another structure is called nested
structure.
 Anested structure can be created in 2 ways:
1. Structure is defined separately and a variable of structure can be
placed inside the definition of another structure definition.
2. By placing the complete definition of one structure inside the
definition of one more structure.

INTRODUCTION
Example 1:
struct date
{
int dd;
int mm;
int yyyy;
};
struct Employee
{
char empname[20];
int empid;
float salary;
struct date doj;
}
In the above example the date structure is nested within employee structure.

INTRODUCTION
Example 2:
struct Employee
{
char empname[20];
int empid;
float salary;
struct date
{
int dd;
int mm;
int yyyy;
}doj;
};

INTRODUCTION
Accessing nested structure:
Syntax:
OuterStructureVariable.InnerStructureVariable.InnerStructuremember
 To access the member of date structure, we need to first create a variable
of employee structure.
struct Employee E1;
 Now we can access member of date structure as follows:
E1.doj.dd ;
E1.doj.mm;
E1.doj.yyyy;

INTRODUCTION
Programming Example for Nested Structure:
#include<stdio.h>
struct date
{
int dd;
int mm;
int yyyy;
};
struct employee
{
char empname[20];
int empid;
float salary;
struct date doj;
};

INTRODUCTION
void main()
{
struct employee e1;
e1.doj.dd= 10;
e1.doj.mm=1;
e1.doj.yyyy=2015;
printf("Date of Joining of employee = %dn", e1.doj.dd);
printf("Month of Joining of employee = %dn", e1.doj.mm);
printf("Year of joining of employee = %dn", e1.doj.yyyy);
}

INTRODUCTION
Array of Structures:
 Just like how we have array of integers we can also have an array of structures.
 Example: If we want to store the information of 10 students consisting of name and
usn.
 The structure definition can be written as shown below:
struct student
{
char name[20];
int usn;
};
 To store the information of 10 students the structure variable has to be declared as
follows:
struct student s[10];
 The general syntax for structure array declaration is :
struct structurename structurevariable[size];

INTRODUCTION
Programming Example forArray of Structures:
#include<stdio.h>
struct student
{
char name[20];
int usn;
float marks;
};
int main()
{
struct student s[20];
int i,n;
printf("Enter the number of studentsn");
scanf("%d",&n);

INTRODUCTION
for(i = 0; i < n; i++ )
{
printf("Enter details of student %dn", i+1);
printf("Enter namen");
scanf("%s", s[i].name);
printf("Enter usnn");
scanf("%d", &s[i].usn);
printf("Enter marksn");
scanf("%f", &s[i].marks);
}
for(i =0; i<n; i++)
{
printf("student %d name is %sn", i+1, s[i].name);
printf("student %d USN is %dn", i+1, s[i].usn);
printf("student %d marks is %fn", i+1, s[i].marks);
}
}

INTRODUCTION
Type Definition:
 The typedef is a keyword using which the programmer can create a new
datatype name for an already existing datatype name.
 So typedef is to used redefine or rename the name of an existing data
type.
 This is same like defining alias names.
 Syntax:
typedef datatype newname_1, newname_2, ------- newname_n;
 The new names that are given by the user for the already existing data types are
called user defined data types.
Example 1:
typedef int Percentage, USN;
 In this example, Percentage and USN are user defined datatypes. Using this any
number of integer variables under the datatypes Percentage & USN can be created.

INTRODUCTION
Example 2:
typedef float salary;
 Here salary is a user defined dataype. Using this any number of floating
variables under the datatypes salary can be created.
Example 1:
typedef int Percentage , USN;
Percentage p1, p2, p3;
USN u1,u2,u3;
Example 2:
typdef intArray[100];
Array s;
Here s is an integer array of size 100

INTRODUCTION
Example 3:
typedef char String[100];
String s;
Here s is a string of size 100.
Example:Using 'typedef definition', computing simple interest.
#include <stdio.h>
//Principal is the new name for float
//time is the new name for int datatype
//roi is the new name for float datatype
typedef float Principal ;
datatype
typedef int time;
typedef float roi;
int main( )
{
Principal p;
time t;
roi r;
//p is of datatype principal
//t is of datatype time
//r is of datatype roi

INTRODUCTION
float si;
printf("Enter p,t and rn");
scanf("%f%d%f",&p,&t,&r);
si = (p*t*r)/100;
printf("SI = %fn", si);
}
Type Defined Structure:
 Also known as defining Structure Data types using typedef.
 The C programming language provides a keyword called typedef, which is
used to give a datatype a new name.
 The structure defined using the keyword typedef is called type defined
structure.

INTRODUCTION
The syntax of the typedefined structure:
typdef struct
{
data_type1 member1;
data_type2 member2;
----------------------
} struct_ID ;
Example:
typedef struct
{
char name[10];
int USN;
float marks;
} Student ;
 Here Student is the new datatype using which variables can be declared like :
Student S1, S2, S3;

INTRODUCTION
The typedef structure can also be defined as illustrated below :
struct employee
{
char name[10];
int Empid;
float Salary;
}
typedef struct employee EMPLOYEE;
EMPLOYEE e1, e2, e3;
 employee is now renamed as EMPLOYEE.

INTRODUCTION
Programming Example : Structure using typedef
typedef struct student
{
int id;
char name[20];
float percentage;
} status;
int main()
{
status record;
record.id=1;
strcpy(record.name, "Raju");
record.percentage = 86.5;
printf(" Id is: %d n", record.id);
printf(" Name is: %s n", record.name);
printf(" Percentage is: %f n", record.percentage);
}
CHETHAN C

INTRODUCTION
Programming Example : Structure using typedef
typedef struct employee
{
char name[50];
int salary;
}emp;
void main( )
{
emp e1;
printf("Enter Employee recordn");
printf("Employee namen");
scanf("%s", e1.name);
printf("Enter Employee salaryn");
scanf("%d", &e1.salary);
printf("student name is = %sn", e1.name);
printf("salary is = %dn", e1.salary);
}
CHETHAN C

INTRODUCTION
Structure and Functions:
 Just like how the normal variables can be passed to the functions, it is also
possible to pass structure variables to functions.
 Structure variable can be passed to functions using two techniques:
1. Passing actual value as an argument. (Pass by Value)
2. Passing the address of an argument. (Pass by reference)
Passing structure by value:
 The entire structure is passed as a function argument.
 When the structure is passed as a function argument, it is passed using call by
value method.
 If structure is passed by value, changes made in structure variable in function
definition(called function) doesn’t reflect in original structure variable in the
calling function CHETHAN C

INTRODUCTION
Example:
struct student
{
char name[50];
int usn;
float marks;
};
void display(struct student stu);
 In this example, the structure variable s1 is passed as an argument of
display(s1) function.
 The value of the members variables are displayed in disp(struct student
stu) function.
CHETHAN C

INTRODUCTION
void main()
{
struct student s1;
printf("Enter student namen");
scanf("%s",s1.name);
printf("Enter student usnn");
scanf("%d",&s1.usn);
printf("Enter student marksn");
scanf("%f",&s1.marks);
display(s1);
}
void display(struct student stu)
{
printf("Name is %sn", stu.name);
printf("USN is %dn", stu.usn);
printf("Marks is %fn", stu.marks);
}
CHETHAN C

INTRODUCTION
Passing the address of the entire structure/Pass by reference:
 The address of the structure variable is passed to the function
while passing it as reference.
 We pass the address using the pointers.
 Accessing the members of the structures using pointers is done by
( )arrow operator.
 If structure is passed by reference, change made in structure
variable in function definition reflects in original structure
variable in the calling function.
CHETHAN C

INTRODUCTION
struct student
{
char name[50];
int usn;
};
void display(struct student *stu);
void main()
{
struct student s1;
printf("Enter the student namen");
scanf("%s",s1.name);
printf("Enter USNn");
scanf("%d",&s1.usn);
display(&s1);
printf("In main Functionn");
printf("Name is: %sn", s1.name);
printf("USN is : %dn", s1.usn);
}
CHETHAN C

INTRODUCTION
void display(struct student *stu)
{
strcpy(stu->name, "xyz");
stu->usn=30;
printf("In Display Functionn");
printf("Name is: %sn", stu->name);
printf("USN is : %dn", stu->usn);
}
 When the name and usn are changed in the display( ) function,
the changes are reflected even in the main( ) function.

INTRODUCTION
Self Referential Structures:
 Self Referential structures are those structures that have
one or more pointers which point to the same type of
structure, as their member.

INTRODUCTION
struct structure_name
{
datatype datatype_name;
structure_name * pointer_name;
}
 In other words, structures pointing to the same type of
structures are self-referential in nature.
Example:
struct node
{
int data;
struct node *next;
};

INTRODUCTION
Example:
struct node
{
int data1;
char data2;
struct node* link;
};
int main()
{
struct node ob;
}

INTRODUCTION
 In the above example ‘link’ is a pointer to a structure of
type ‘node’.
 Hence, the structure ‘node’ is a self-referential structure
with ‘link’ as the referencing pointer.
Types of Self Referential Structures
 Self Referential Structure with Single Link
 Self Referential Structure with Multiple Links

INTRODUCTION
Self Referential Structure with Single Link:
 These structures can have only one self-pointer as their
member.
 The connection formed is shown in the following figure.

INTRODUCTION
Self Referential Structure with Multiple Links:
 Self referential structures with multiple links can have more
than one self-pointers.
 Many complicated data structures can be easily constructed
using these structures.
 Such structures can easily connect to more than one nodes at
a time.

INTRODUCTION
 In the above example we can see that ‘ob1’, ‘ob2’ and
‘ob3’ are three objects of the self referential structure
‘node’.
 They are connected using their links in such a way that
any of them can easily access each other’s data.
 This is the beauty of the self referential structures.
 The connections can be manipulated according to the
requirements of the programmer.

INTRODUCTION
Advantages:
 The self-referential structures are beneficial in many
applications that involves linked data members, such as
trees and lists.
 Unlike a static data structure such as an array where
the size of the array limits the number of elements that
can be inserted into the array, the self- referential
structure can dynamically be contracted or expanded.
 Operations such as insertion or deletion of nodes in a
self-referential structure involve simple alteration of the
pointers present within them.

INTRODUCTION
Unions
 Union is an user defined datatype in C.
 It is a collection of variables of different datatypes in the
same memory location.
 A union is a user-defined type similar to structs in C
except for one key difference.
 Unlike structure members which are stored in separate
memory locations, all the members of union must share
the same memory space.

INTRODUCTION
To define a union:
 We use the union keyword to define unions.
union car
{
char name[50];
int price;
};
Create union variables:
 When a union is defined, it creates a user-defined type.
 However, no memory is allocated.
 To allocate memory for a given union type and work
with it, we need to create variables.

INTRODUCTION
union car
{
char name[50];
int price;
};
int main()
{
union car car1, car2, *car3;
}
Another way of creating union variables is:
union car
{
char name[50];
int price;
} car1, car2, *car3;

INTRODUCTION
Union Declaration:
 A union declaration is similar to a structure, but the
fields of a union must share their memory space.
 This means that only one field of the union is "active" at
any given time.

INTRODUCTION
Access members of a union
 We use the . (dot) operator to access members of a
union.
And to access pointer variables, we use the -> operator.
In the above example,
• To access price for car1, car1.price is used.
•To access price using car3, either (*car3).price or car3-
>price can be used.

INTRODUCTION
Similarities between Structure and Union
 ‘.’ (dot) operator is used for accessing members.
 Both are user-defined data types used to store data of
different types as a single unit.
 Their members can be objects of any type, including other
structures and unions or arrays.
 Both structures and unions support only assignment (=)
and sizeof() operators.
 A structure or a union can be passed by value to functions
and returned by value by functions. The argument must have
the same type as the function parameter.

INTRODUCTION
POINTERS
 A pointer is a variable which contains the address in
memory of another variable.
 The two most important operator used with the pointer
type are
1 . & : The unary operator & which gives the address of a
variable
2. * : The indirection or dereference operator * gives the
content of the object pointed to by a pointer.

INTRODUCTION
 Consider the following declaration of two variables a and b:
int a = 25;
int b = 45;
 The value of a and b can be accessed and printed as shown below:
printf(“Value of a =%dn”, a);
printf(“Value of b =%dn”, b);
 But what if we need the address of a and b ?
 In order to access the address of the variables we can use the address
operator (&) as below:
printf(“Address of a = %d n”, &a);
printf(“Address of b = %dn”, &b);

INTRODUCTION
Declaration
 Pointer variables should be declared before they are used.
 The syntax to declare a pointer variable is:
datatype *identifier;
int i, *pi;
i is the integer variable and pi is a pointer to an integer
pi = &i;
&i returns address of i and assigns it as the value of pi

INTRODUCTION
The steps to be followed to use pointers:
1. Declare a data variable.
2. Declare a pointer variable.
3. Initialize a pointer variable.
4. Access data using pointer variable.
Initialization of Pointer variables:
Ex: int x;
Ex: int *p;
Ex: p = &x;
Ex: y= *p
 It is the process of assigning an address to the pointer variable.
 Consider the following declaration statements :
int a;
int *p ;
 After declaration the variable a gets allocated in some memory location
(address) say 1000 and the pointer p gets the address 3000.

INTRODUCTION
CHETHAN C
After initialization, the variable a holds the value 65 and the
variable p holds the value of address of a :

INTRODUCTION
 The process of accessing the value of the variables indirectly by
pointer pointing to the address of variable is called indirection.
Accessing Variables Through Pointers:
 The contents of variable can be accessed by de-referencing a
pointer.
 If a pointer p is pointing to a variable num, then its value can be
accessed by just saying *p.
 Here * operator acts as the dereference operator.

INTRODUCTION
Multiple Pointers:
 Asingle variable can be accessed using multiple pointers.
 Multiple pointers has to declared and all the pointers has to be
initialized to single variable.
Example:
#include<stdio.h>
void main()
{
int num=1004;
int *p1,*p2,*p3;
p1 = &num;
p2 = &num;
p3 = &num;

INTRODUCTION
printf("The value of num = %dn", num);
printf("The value of num = %dn", *p1);
}
 Three pointers (*p1,*p2 and *p3) are used to access the value of
single variable num.
Output:
The value of num = 1004

INTRODUCTION
NULLPointer:
 Apointer pointing to nowhere in memory is called NULL Pointer.
 It will not be containing the address of any object or function.
 Null pointers are initialized to NULL.
Example:
int *p = NULL;
#include <stdio.h>
int main()
{
int *ptr = NULL;
printf("The value of ptr is %u", ptr);
}
Output:
The value of ptr is 0

INTRODUCTION
Dangling Pointer:
 The pointer which does not contain valid address or pointing to
no existing memory location is called dangling pointer.
 They contain garbage values.
 Dangling pointer arises when an object is de-allocated, without
modifying the value of the pointer so that the pointer still points
to the memory location of the de-allocated memory.
 The problem of dangling pointer can be avoided by initializing it
to NULL.
 After de-allocating memory, initialize pointer to NULL so that
pointer will be no longer dangling.
 Assigning NULL value means pointer is not pointing to any
memory location.

INTRODUCTION
Pointer and arrays:
 In C, the pointers can be used to create and handle arrays.
 The operations that can be performed on arrays and its elements
are:
• Traversing array using a pointer
• Accessing array element
• Reading an array
• Printing an array
 The name of the array is actually a pointer representing the
address of memory location of first element of array.

INTRODUCTION
 Example: Consider the following declaration
int a[5] = {10,20,30,40,50} ;
Assuming memory layout of the array a and its elements are:
 The name of the array a is a pointer to integer and holds the
address of first element a[0] i.e a = &a[0] = 1000.

INTRODUCTION
 The relationship of arrayname a (pointer) and different elements is given
below :
a = &a[0];
a+1 = &a[1]
a+2 = &a[2]
a+3 = &a[3]
a+4 = &a[4]
 In general &a[i] is same as a+ i ;
 The data in those address can be obtained using the indirection operator * as :
*&a[i]
*(a+i)
*(i+a)
*&i[a];
(or)
(or)
(or)

INTRODUCTION
Array of Pointers:
 Array of pointers is a collection of multiple pointers of particular
data type.
 Each element of such array will be capable to point and hold the
address of set variables whose data type is of same type.
 Consider a declaration
int *pi[3];
 pi is array of pointers which can hold three pointers of integer
type –
*pi[0], *pi[1] and *pi[2].

INTRODUCTION
Program to show how values of a, b and c is accessed and printed using array of
pointers:
#include<stdio.h>
int main()
{
int *pi[3], a, b, c;
printf(“Enter the values of a ,b and c n”);
scanf(“%d%d%d”, &a, &b, &c);
pi[0] = &a;
pi[1]=&b;
pi[2]= &c;
printf(“The Entered value of a,b and cn”);
printf(“%d%d%dn”, *pi[0],*pi[1],*pi[2]);
}
 pi[0], pi[1] and pi[2] holds the address of variables a, b and c
respectively.
 *pi[0], *pi[1] and *pi[2] holds the values of a, b and c respectively.

INTRODUCTION
Pointer to Pointer :
 Consider the declaration :
int **p;
 p is a pointer to pointer to integer.
 These types of pointers are called as double pointer or pointer to
pointer.
 Single pointers are used to store the address of normal variables.
 Double pointer is to store the address of pointer variables.
Example:
int a = 101;
int *p1;
int **pd;
p1 = &a;
pd =&p1;

INTRODUCTION
 The address of normal variable a is stored in p1.
 Address of pointer variable p1 is stored in pd.
 Assuming the address of a as 5000, address of pointer p1 as 8000
and address of double pointer pd as 9000, we have the memory
representation as :

INTRODUCTION
Pointer to pointer program:
#include<stdio.h>
void main()
{
int a = 101;
int *p1;
int **pd;
p1 = &a;
pd = &p1;
//address of a is in p1
//address of p1 is in pd
printf(“%dn”, a);
printf(“%dn”, p1);
printf(“%dn”, pd);
//Prints value in a
//Prints address of a.
//Prints address of p1
}

INTRODUCTION
Advantages of pointers:
 Pointers make the programs simple and reduce their length.
 Pointers are helpful in allocation and de-allocation of memory
during the execution of the program thus reduces the execution
time of the program.
 Provides an alternate way to access array elements.
 Pointers allows us to perform dynamic memory allocation and
deallocation.
 Pointers helps us to build complex data structures like linked list,
stack, queues, trees, graphs etc.

INTRODUCTION
Disadvantages of pointers:
 Uninitialized pointers might cause segmentation fault.
 Pointers are slower than normal variables.
 If pointers are updated with incorrect values, it might lead to
memory corruption.

INTRODUCTION
Dynamic MemoryAllocation:
 Since C is a structured language, it has some fixed rules
for programming - One of them includes changing the
size of an array.
 An array is a collection of items stored at contiguous
memory locations.
 The length (size) of the array is 9.
 But what if there is a requirement to change this length
(size).

INTRODUCTION
Example:
 If there is a situation where only 5 elements are needed to be entered in
this array, the remaining 4 indices are just wasting memory in this
array.
 So there is a requirement to lessen the length (size) of the array from 9
to 5.
 Think all 9 indices filled. But there is a need to enter 3 more elements
in this array.
 In this case, 3 indices more are required. So the length (size) of the
array needs to be changed from 9 to 12.
 This procedure is referred to as Dynamic MemoryAllocation in C.

INTRODUCTION
 Therefore, Dynamic Memory Allocation can be defined as a
procedure in which the size of a data structure (like Array) is
changed during the runtime.
 The memory allocation is done either before or at the time of
program execution. There are two types of memory allocations:
1. Compile-time or Static Memory Allocation
2. Run-time or Dynamic MemoryAllocation

INTRODUCTION
Static MemoryAllocation:
 Static Memory is allocated for declared variables by the compiler.
 The address can be found using the address of operator and can be
assigned to a pointer.
 The memory is allocated during compile time.
Dynamic MemoryAllocation:
 Memory allocation done at the time of execution(run time) is known as
dynamic memory allocation.
 In the Dynamic allocation of memory space is allocated by using
certain functions when the value is returned by functions and assigned
to pointer variables.

INTRODUCTION
 C provides 4 library functions defined under <stdlib.h> header
file to facilitate dynamic memory allocation.
 They are:
1. malloc() - allocates single block of requested memory.
2. calloc() - allocates multiple block of requested memory.
3. realloc() - reallocates the memory occupied by malloc() or
calloc() functions.
4. free() - frees the dynamically allocated memory.

INTRODUCTION
malloc():
 The “malloc” or “memory allocation” method in C is used to
dynamically allocate a single large block of memory with the
specified number of bytes.
 It returns a pointer of type void which can be cast into a
pointer of any form.
 Syntax:
ptr = (cast-type*) malloc(byte-size)
 Example:
ptr = (int*) malloc(100 * sizeof(int));

INTRODUCTION
 Since the size of int is 4 bytes, this statement will allocate 400 bytes of
memory.
 And, the pointer ptr holds the address of the first byte in the allocated
memory.
 The expression results in a NULL pointer if the memory cannot be
allocated. (If space is insufficient, allocation fails and returns a NULL
pointer.)

INTRODUCTION
calloc() :
 “calloc” or “contiguous allocation” method in C is used to
dynamically allocate the specified number of blocks of memory
of the specified type.
 It is similar to malloc() but has two different points :
1. The malloc() function allocates memory and leaves the memory
uninitialized whereas the calloc() function allocates memory
and initializes all bits to zero.
2. It has two parameters or arguments.

INTRODUCTION
Syntax:
ptr = (cast-type*)calloc(n, element-size);
 n is the no. of elements and element-size is the size of each
element.
Example:
ptr = (float*) calloc(25, sizeof(float));
 This statement allocates contiguous space in memory for 25
elements each with the size of the float.

INTRODUCTION
realloc():
 “realloc” or “re-allocation” is used to dynamically change the
memory allocation of a previously allocated memory.
 In other words, if the memory previously allocated with the help
of malloc() or calloc() is insufficient, realloc() can be used to
dynamically re-allocate memory.
 Re-allocation of memory maintains the already present value and
new blocks will be initialized with the default garbage value.

INTRODUCTION
Syntax:
ptr = realloc(ptr, newSize);
 ptr is reallocated with new size 'newSize'

INTRODUCTION
free() :
 “free” is used to dynamically de-allocate the memory.
 The memory allocated using functions malloc() and calloc() is
not de-allocated on their own. Hence the free() method is used,
whenever the dynamic memory allocation takes place.
 It helps to reduce wastage of memory by freeing it.
 Syntax:
free(ptr);
 This will cause the space in memory pointer by ptr to be
deallocated.

INTRODUCTION
Representation of Linear Arrays in Memory:
 A linear array is a list of a finite number ‘n’ of
homogeneous data element such that
a.The elements of the array are referenced respectively by
an index set consisting of n consecutive numbers.
b.The element of the array are respectively in successive
memory locations.
 The number n of elements is called the length or size of
the array.

INTRODUCTION
 The length or the numbers of elements of the array can
be obtained from the index set by the formula:
When LB = 0,
Length = UB – LB + 1
When LB = 1,
Length = UB
 UB is the largest index called the Upper Bound
 LB is the smallest index, called the Lower Bound

INTRODUCTION
Representation of linear arrays in memory
 Let LA be a linear array in the memory of the computer.
 The memory of the computer is simply a sequence of
address location as shown below:
LOC (LA [K]) = address of the element LA [K] of the array LA

INTRODUCTION
 The elements of LA are stored in successive memory
cells.
 The computer does not keep track of the address of every
element of LA but must to keep track only the address
of the first element of LA denoted by, Base (LA)
called the base address of LA.
 Using the base address of LA, the computer calculates
the address of any element of LA by the formula :
L O C (LA[K]) = Base(LA) + w(K – lower bound)
w is the number of words per memory cell for the array LA.

INTRODUCTION
Dynamically Allocated Arrays
 While writing programs, if we find ourselves in a
situation where we cannot determine how large an array
to use, then a good solution to this problem is to defer
this decision to run time and allocate the array when we
have a good estimate of the required array size.
 The arrays can be dynamically allocated using malloc(),
calloc(), realloc() functions.

INTRODUCTION
Creation of One Dimensional Array dynamically
int i, n, *list;
printf(“Enter the number of numbers to generate:”);
scanf(“%d”, &n);
if(n<1)
{
printf (“Improper value of nn”);
exit();
}
malloc (list, n*sizeof(int));

INTRODUCTION
Creation of Two Dimensional Array dynamically
int make2dArray(int rows, int cols)
{
int x, i;
malloc(x, rows * sizeof (x));
for (i= 0;i<rows; i++)
malloc(x[i], cols * sizeof(x));
return x;
}

ARRAY OPERATIONS
Array Operations:
 Traversing
 Insertion
 Deletion
 Sorting
 Searching

STRINGS
 Each programming languages contains a character set
that is used to communicate with the computer.
 The character set is:
Alphabet: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
Digits: 0 1 2 3 4 5 6 7 8 9
S pecial characters: + - /* ( ) , . $ = ‘ _
 String: A finite sequence S of zero or more Characters
is called string.

STRINGS
 Astring is an array of characters.
 Strings in C are classified into two types:
1. String literals
2. String variables
 String literals are also known as string constants.
 The sequence of characters enclosed within two double quotes
is called string constant.
 The string constant is stored in consecutive bytes in memory
and the compiler places the null character at end to denote the
end of string.

STRINGS
 In other words, A string is terminated by null character which is
denoted by the escape sequence ‘0‘.
 Consider the string “SVCE
 The delimiter ‘0’ represents that the string has ended in the
memory.
Declaration of Strings:
The general form of declaration of a string variable is :
char stringname[size];
 The size determines the number of characters in the string name
including the null character.

STRINGS
 Example: char hero [21];
 Size 21 means it can store up to 20 characters plus the null
character.
 Entire storage location name is divided in to 21 boxes called
bytes, each of which holds one character.
Each character is element of data type char.
char s[ ] = {“dog”};
char t[ ] = {“house”};
Using these declarations, the C compiler will allocate just enough
space to hold each word including the null character.

STRINGS
 C library supports a number of string manipulation functions
and are stored in header file “string.h”.
 Major String functions are:
1. strcpy() - copies one string over another.
2. strlen() - finds the length of a string.
3. strcmp() - compare two strings.
4. strcat() - concatenates two strings.

STRINGS
Substring: A string Y is called substring of a string S if there exist
string X and Z such that
S = X // Y // Z
 If X is an empty string, then Y is called an Initial substring of
S and Z is an empty string then Y is called a terminal substring
of S.
 Example:
‘BE OR NOT’is a substring of ‘TO BE OR NOT TO BE’
‘THE’is an initial substring of ‘THE END’

STRINGS
Storing Strings
Strings are stored in three types of structures
1. Fixed length structures
2. Variable length structures with fixed maximum
3. Linked structures.
Record Oriented Fixed length structures
 In fixed length structures each line of print is viewed
as a record, where all have the same length i.e., where
each record accommodates the same number of
characters.

STRINGS
 Example: Suppose the input consists of the program.
Using a record oriented fixed length storage medium,
the input data will appear in memory as pictured
below.

STRINGS
 If new record needs to be inserted, then it requires that
all succeeding records be moved to new memory
location.
 This disadvantages can be easily overcome by using a
linear array POINT which gives the address of
successive record, so that the records need not be
stored in consecutive locations in memory.
 Inserting a new record will require only an updating of
the array POINT.

STRINGS
The main advantages of this method are
1. The ease of accessing data from any given record.
2. The ease of updating data in any given record.
(as long as the length of the new data does not exceed the record
length)
The main disadvantages are
1.Time is wasted reading an entire record if most of the storage
consists of inessential blank spaces.
2. Certain records may require more space than available.
3.When the correction consists of more or fewer characters
than the original text, changing a misspelled word requires
record to be changed.

STRINGS
Variable length structures with fixed maximum:
 The storage of variable-length strings in memory cells
with fixed lengths can be done in two general ways
1.Using a marker, such as two dollar signs ($$), to signal
the end of the string [Records with Sentinals]
2.List the length of the string—as an additional item in
the pointer array. [Records whose lengths are listed]

STRINGS
Advantages:
 These ways of storing strings will save space and are
sometimes used in secondary memory when records are
relatively permanent and require little changes.
Disadvantages:
 These types of methods of storage are usually inefficient
when the strings and their lengths are frequently being
changed.

STRINGS
Linked Storage:
 A linked list is a linear collection of data elements, called
nodes. Each node is divided into two parts:
 The first part contains the information of the element(data).
 The second part called the link field or nextpointer field,
contains the address of the next node in the list.

STRINGS
Strings using linked lists may be Stored as follows:
 Each memory cell is assigned one character or a fixed
number of charactersand a link contained in the cell
the next
gives the address of the cell containing
character or group of character in the string.
 Example : Storing TO B E OR NOT TO B E

STRINGS
String Operations:
1. Substring
2. Indexing
3. Concatenation
4. Length
Substring:
 Accessing a substring from a given string requires three
pieces of information:
(1)The name of the string or the string itself
(2)The position of the first character of the substring in the
given string
(3)The length of the substring or the position of the last
character of the substring.

STRINGS
Syntax:
SUBSTRING (string, initial, length)
The syntax denote the substring of a string S beginning in
a position K and having a length L.
Example:
SUBSTRING ('TO B E OR NOT TO BE’, 4, 9) = 'BE OR NOT’
SUBSTRING ('THE END', 4, 4) = ' END'

STRINGS
Indexing
 Indexing also called pattern matching refers to finding the
position where a string pattern P first appears in a given
string text T.
 This operation is called INDEX
Syntax:
INDEX (text, pattern)
 If the pattern P does not appears in the text T, then INDEX
is assigned the value 0.
 The arguments “text” and “pattern” can be either string
constant or string variable.

STRINGS
Concatenation:
Let S1 and S2 be string.
The concatenation of S1 and S2 which is denoted by S1//S2 denoting
string consisting of the characters of S1 followed by the character of
S2.
Example:
If S1 = 'MARK' and S2= ‘TWAIN'
S 1 /
/S 2 = ‘MARKTWAIN’
Concatenation is performed in C language using strcat() function as
shown below
strcat (S1, S2);
Concatenates string S1 and S2 and stores the result in S1

STRINGS
Length
 The number of characters in a string is called its length.
Syntax:
LENGTH (string)
Example:
LENGTH (‘computer’) = 8
 String length is determined in C language using the strlen()
function, as shown below:
X = strlen ("sunrise");
 Strlen() function returns an integer value 7 and assigns it
to the variable X

STRINGS
Pattern MatchingAlgorithms
 One of the primary applications of computers is in the field of word
processing.
 This usually involves some type of pattern matching which is to check
to see if a particular word “S” appears in a given text “T”.
 The Pattern Searching algorithms are also referred to as String
SearchingAlgorithms.
 These algorithms are useful in the case of searching a string within
another string.
 Pattern matching is the problem of deciding whether or not a given
string pattern Pappears in a string text T.

STRINGS
 The length of P does not exceed the length of T.

STRINGS
Pattern Matching Algorithms:
1. First Pattern Matching Algorithm
2. Second Pattern Matching Algorithm
First Pattern Matching Algorithm
 The comparison is done by a given pattern P with each
of the substrings of T, moving from left to right until a
match is found.
WK = SUBSTRING (T, K, L E N GT H (P))
WK denote the substring of T having the same length as P
and beginning with the Kth character of T.

STRINGS
 First compare P, character by character with the first
substring, W1.
 If all the characters are the same, then P = W1 and so P
appears in T and INDEX (T, P) = 1.
 If it is found that some character of P is not the same as
the corresponding character of W1. Then P ≠ W1
 Immediately move on to the next substring, W2
compare P with W2.
 If P ≠ W2 then compare P with W3 and so on.
i.e,

STRINGS
 This process will stop when P is matched with some
substring WK and so P appears in T and INDEX(T,P) = K
or
 when all the WK are completed with no match and hence
P does not appear in T.
 The maximum value MAX of the subscript K is equal to
LENGTH(T) -LENGTH(P) +1.

STRINGS
 Algorithm contains two loops, one inside the other.
 The outer loop runs through each successive R-character
substring WK = T[K] T[K + 1] ... T[K+R-l] of T.
 The inner loop compares P with WK, character by character.
 If any character does not match, then control transfers to
Step 5, which increases K and then leads to the next
substring of T.
 If all the R characters of P do match those of some WK then
P appears in T and K is the INDEX of P in T.
 If the outer loop completes all of its cycles but P does not
appear in T and so INDEX = 0.

STRINGS
Second Pattern Matching Algorithm:
 This uses a table which is derived from a particular pattern
P but is independent of the text T.
 Example : Let P = aaba
 aaba can be split into 5 substrings. (Empty, a, aa, aab, aaba)
Let Qi denote the initial substring of P of length i.
Q0 = (empty string)
Q1 = a
Q2 = aa
Q3 = aab
Q4 = aaba = P

STRINGS
 This algorithm contains the table that is used for the
pattern P = aaba

STRINGS
The graph is obtained with the table as follows.
 First, a node in the graph corresponding to each initial substring
Qi of P.
 The Q's are called the states of the system, and Q0 is called the
initial state.
 There is an arrow (a directed edge) in the graph corresponding to
each entry in the table.
 If f(Qi, t) = Qj then there is an arrow labeled by the character t
from Qi to Qj
 Example:
f(Q2, b) = Q3 so there is an arrow labeled b from Q2 to Q3
 For notational convenience, all arrows labeled x are omitted, which
must lead to the initial state Qo.

STRINGS
 The second pattern matching algorithm for the pattern P =
aaba.
 Let T = T1 T2 T3 ... TN denote the n-character-string text
which is searched for the pattern P.
 Beginning with the initial state Q0 and using the text T, we
will obtain a sequence of states S1, S2, S3, ... as follows.
 Let S1 = Q0 and read the first character T1.
 The pair (S1, T1) yields a second state S2; that is, F(S1, T1)
= S2,
 Read the next character T2, The pair (S2, T2) yields a state
S3, and so on.

STRINGS
There are two possibilities:
 Some state SK = P, the desired pattern.
In this case, P does appear in T and its index is
K - LENGTH(P).
 No state S1, S2, ... , S N +1 is equal to P.
In this case, P does not appear in T.

DS Module 1.pptx

More Related Content

What's hot

Similar to DS Module 1.pptx

Recently uploaded

DS Module 1.pptx