UNIT - 1

INTRODUCTION TO DATA STRUCTURES:-

Computer science includes the study of data, its representation, and its processing by computers. Hence, it is essential to
study about the terms associated with data and its representation. The term data structure refers to the organization of
data elements and the interrelationships among them.
->Data: Data is nothing but a piece of information. Data input, data manipulation, and data output are the functions of
computers. Hence all information taken as input, processed within a computer, or provided as output to the user is nothing
but data. It can be a number, a string, or a set of many numbers and strings.
Atomic and Composite Data:
Atomic data is the data that we choose to consider as a single, non-decomposable entity. Ex: The integer 1234 may be
considered as a single integer value.
Composite data can be broken down into subfields that have meaning.
Ex: A student’s record consists of Roll_Number, Name, Branch, Year, and so on. Atomic data is known as scalar data because
of its numeric properties.
Composite data is also referred to as structured data.
->Data Type: Data type refers to the kind of data a variable may store. Data type is a term that specifies the type of data
that a variable may hold in the programming language.
Built-in Data Types:
In general, languages have their built-in data types.
Ex: int, float, char ………
Using these built-in data types, we can design (define) our own data types by means of structures, unions, and classes.

User-defined Data Types:

Suppose we want to maintain a record of 100 students with the following fields in each record: roll number, name of
student, and percentage of marks of the students. Then we use the C++ class as follows.
class Student
{
private:
int roll;
char name[20];
float percentage;
public:
void GetRecord();
void PrintRecord();
void SearchRecord();
}

-->Data Structure: Data structures refer to data and representation of data objects within a program, that is, the
implementation of structured relationships. A data structure is a collection of atomic and composite data types into a set
with defined relationships.
A data structure is
1. a combination of elements, each of which is either as a data type or another data structure

2. a set of associations or relationships (structures) involving the combined elements.

->Abstract Data Type: An ADT is the one in which the set of operations is defined at a formal, logical level, without being
restricted by the operational details. An ADT is a data declaration packaged together with the operations that are
meaningful for the data type. We encapsulate the data and the operations on this data and hide them from the user.

An ADT includes declaration of data, implementation of operations, and encapsulation of data and operations.
Consider the concept of a queue. At least three data structures will support a queue. We can use an array, a linked list, or a
file. If we place our queue in an ADT, users should not be aware of the structure we use. We are aware of the importance of
hiding the implementation. The user need not know the data structure to be able to use an ADT. Allowing the application
program to directly reference the data structure is a common fault in many applications that prevent the ADT from being
fully portable to other applications.
We want a data specification method that has the following features:
Abstract It should help the programmer organize data by focusing on its logical properties rather than on the
implementation details, which in turn allows the user to hide the complexity of a task.
Safe It should control the manipulation of the representation of data so that malfunctioning can be avoided.
Modifiable It should make it relatively easy to modify the representation.
Reusable The data structure should be such that it is a reusable product for others.

 TYPES OF DATA STRUCTURES:-

We defined a data structure as a way of organizing data that specifies a set of data elements, that is, a data object.
And a set of operations that are applied to this data object.

These two sets form a mathematical construct that may be implemented using a particular programming language. The
data structure is independent of their implementation. The various types of data structures are as follows.
1. Primitive and non-primitive
2. Linear and non-linear
3. Static and dynamic
4. Persistent and ephemeral
5. Sequential and direct access
1. Primitive and non-primitive:
Primitive data structures define a set of primitive elements that do not involve any other elements as its subparts
Ex: Data structures defined for integers and characters. These are generally primary or built-in data types in programming
languages.
Non-primitive data structures are those that define a set of derived elements such as arrays. Arrays in C++ consist of a set of
similar type of elements. Class and structure are other examples of non-primitive data structures, which consist of a set of
elements that may be of different data types and functions to operate on.

2. Linear and Non-linear:

A data structure is said to be linear if its elements form a sequence or a linear list. In a linear data structure, every
data element has a unique successor and predecessor. There are two basic ways of representing linear structures in
memory. One way is to have the relationship between the
elements by means of pointers (links), called linked lists. The other way is using sequential organization, that is, arrays.
Non-linear data structures are used to represent the data containing hierarchical or network relationship among the
elements. Trees and graphs are examples of non-linear data structures. In non-linear data structures, every data element
may have more than one predecessor as well as successor. Elements do not form any particular linear sequence. The
following Fig. depicts both linear and non-linear data structures.

3. Static and Dynamic: A data structure is referred to as a static data structure if it is created before program
execution begins (also called during compilation time). The variables of static data structure have user-specified
names. An array is a static data structure.
In many applications, it is desirable to be able to start a program with the smallest amount of memory necessary and then
allocate extra memory as the need arises. This facility is provided by many programming languages and in C++, through the
operator new. These functions allow programmers to allocate memory during execution.
A data structure that is created at run-time is called dynamic data structure. The vari-ables of this type are not always
referenced by a user-defined name. These are accessed indirectly using their addresses through pointers.
A linked list is a dynamic data structure when realized using dynamic memory management and pointers, whereas an array
is a static data structure. Non-linear data structures are generally implemented in the same way as linked lists. Hence, trees
and graphs can be implemented as dynamic data structures.

4. Persistent and Ephemeral: Data structures comprise a set of operations and a set of data to operate on. The
operations that process the data may modify the data. This may create two versions of a data structure namely the
recently modified (also called as updated) data structure and the previous version, which can be saved before
performing any operation on it
A data structure that supports operations on the most recent version as well as the previous version is termed as a
persistent data structure. A persistent data structure is partially persistent if any version can be accessed but only the most
recent one can be updated; it is fully persistent if any version can be both accessed and updated.

An ephemeral data structure is one that supports operations only on the most recent version.
The distinction between ephemeral and persistent data structure is essentially the distinction between functional (also
called effect free) and conventional imperative (also called effect full) programming paradigms.
The functional data structures are persistent and the imperative data structures are ephemeral.

5. Sequential Access and Direct Access: This classification is with respect to the access operations associated with
data structures. Sequential access means that to access the nth element, we must access the preceding (n - 1) data
elements.
Ex: A linked list
Direct access means that any element can be accessed without accessing its predecessor or successor; we can directly
access the nth element.
Ex: An array

Linear & Non-linear Data Structure....

⮚ Difference between Linear and Non-Linear Data structures:

S. Key Linear Data Structures Non-linear Data Structures

No

1 Data Element In linear data structure, data elements are In non-linear data structure, data elements are
Arrangement sequentially hierarchically
connected and each element is traversable connected and are present at various levels.
through a single run.

2 Levels In linear data structure, all data elements In non-linear data structure, data elements are
are present at a single level. present at multiple levels.

3 Implementation Linear data structures are easier to Non-linear data structures are difficult to
Complexity implement. understand and
implement as compared to linear data
structures.

4 Traversal Linear data structures can be traversed Non-linear data structures are not easy to
completely in a single run. traverse and needs multiple runs to be
traversed completely.

5 Memory Linear data structures are not very Non-linear data structures uses memory very
utilization memory friendly and are not utilizing efficiently.
memory efficiently.

6 Examples Array, List, Queue, Stack. Graph,Tree.

  Access Modifiers or Access Specifiers in a class are used to assign the accessibility to the class
members, i.e., they set some restrictions on the class members so that they can’t be directly accessed by the
outside functions.
There are 3 types of access modifiers available in C++:
1. Public
2. Private
3. Protected
1. Public: All the class members declared under the public specifier will be available to everyone. The data members and
member functions declared as public can be accessed by other classes and functions too. The public members of a class can
be accessed from anywhere in the program using the direct member access operator (.) with the object of that class.

// C++ program to demonstrate public access modifier

#include<iostream>
using namespace std;

class Circle
{
public:
double radius;
double compute_area()
{
return 3.14*radius*radius;
}

};

int main()
{
Circle obj;

// accessing public datamember outside class

obj.radius = 5.5;

cout << "Radius is: " << obj.radius << "\n";

cout << "Area is: " << obj.compute_area();
return 0;
}

2. Private: The class members declared as private can be accessed only by the member functions inside the class. They are
not allowed to be accessed directly by any object or function outside the class. Only the member functions or the friend
functions/ friend class are allowed to access the private data members of the class.

// C++ program to demonstrate private access modifier

#include<iostream>
using namespace std;

class Circle
{
private:
double radius;
public:
double compute_area()
 { // member function can access private
// data member radius
return 3.14*radius*radius;
}

};

int main()
{
Circle obj;
obj.radius = 1.5; // trying to access private data member directly outside the class - Error
cout << "Area is:" << obj.compute_area();
return 0;
}

3. Protected: The protected access modifier is similar to the private access modifier in the sense that it can’t be accessed
outside of its class unless with the help of a friend class. The difference is that the class members declared as Protected can
be accessed by any subclass (derived class) of that class as well.
Note: This access through inheritance can alter the access modifier of the elements of base class in derived class depending
on the mode of Inheritance.
Example:
CPP

// C++ program to demonstrate protected access modifier

#include <bits/stdc++.h>
using namespace std;
class Parent // base class
{
protected:
int id_protected;
};

class Child : public Parent // sub class or derived class from public base class
{
public:
void setId(int id)
{

id_protected = id; // Child class can access the inherited protected data members of base class

void displayId()
{
cout << "id_protected is: " << id_protected << endl;
}};
int main()
{
Child obj1;

// member function of the derived class can

// access the protected data members of the base class

obj1.setId(81);
 obj1.displayId();
return 0;
}

 What is 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.

 Abstract Data Types in C++

Now that we’ve seen the concept of abstract data types (ADTs), we proceed to examine the mechanisms C++ provides for
defining an ADT. Unlike C, C++ allows the data and functions of an ADT to be defined together. It also enables an ADT to
prevent access to internal implementation details, as well as to guarantee that an object is appropriately initialized when it
is created.
Our convention in this course is to use the word struct to refer to C-style ADTs, as well as to use the struct keyword to define
them. We use the word class to refer to C++ ADTs and use the class keyword to define them. We will discuss the technical
difference between the two keywords momentarily.
A C++ class includes both member variables, which define the data representation, as well as member functions that
operate on the data. The following is a Triangle class in the C++ style:
class Triangle {
double a;
double b;
double c;

public:
Triangle(double a_in, double b_in, double c_in);

double perimeter() const {

return this->a + this->b + this->c;
}

void scale(double s) {
this->a *= s;
this->b *= s;
this->c *= s;
}
};

The class has member variables for the length of each side, defining the data representation. We defer discussion of the
public: and Triangle(...) lines for now. Below those lines are member functions for computing the perimeter of a triangle and
scaling it by a factor.
The following is an example of creating and using a Triangle object:

int main()
{
Triangle t1(3, 4, 5);
t1.scale(2);
cout << t1.perimeter() << endl;
}

 What is a Class in C++?

A class is a user-defined data type, which holds its own data members and member functions, which can be accessed and
used by creating an instance of that class. A C++ class is like a blueprint for an object.
For Example: Consider the Class of Cars. There may be many cars with different names and brands but all of them will share
some common properties like all of them will have 4 wheels, Speed Limit, Mileage range, etc. So here, the Car is the class,
and wheels, speed limits, and mileage are their properties.
 A Class is a user-defined data type that has data members and member functions.
 Data members are the data variables and member functions are the functions used to manipulate these variables
together, these data members and member functions define the properties and behaviour of the objects in a Class.
 In the below example of class Car, the data member will be speed, color, etc, and member functions can be brakes,
accelerate, etc.
But we cannot use the class as it is. We first have to create an object of the class to use its features. An Object is an instance
of a Class.

Class Car{ // The class

public: // Access specifier
int speed; // Attribute (int variable)
string color; // Attribute (string variable)

void accelerate( )
{
speed += 10;
}
void brake( )
{
speed -= 5;
}
};

int main()
{
Car myCar; // Create an object of Car

myCar.color = “red”;
myCar.accelerate( );
myCar.accelerate( );
myCar.brake( );
cout << “My Car is “ << myCar.color << “and is going “ << myCar.speed << “mph.” << "\n";
return 0;
}
In C++, an array is a data structure that is used to store multiple values of similar data types in a contiguous memory
location.
For example, if we have to store the marks of 4 or 5 students then we can easily store them by creating 5 different variables
but what if we want to store marks of 100 students or say 500 students then it becomes very challenging to create that
numbers of variable and manage them. Now, arrays come into the picture that can do it easily by just creating an array of
the required size.

Properties of Arrays in C++

 An Array is a collection of data of the same data type, stored at a contiguous memory location.
 Indexing of an array starts from 0. It means the first element is stored at the 0th index, the second at 1st, and so on.
 Elements of an array can be accessed using their indices.
 Once an array is declared its size remains constant throughout the program.
 An array can have multiple dimensions.
 The size of the array in bytes can be determined by the sizeof operator using which we can also find the number of
elements in the array.
 We can find the size of the type of elements stored in an array by subtracting adjacent addresses.
Array Declaration in C++
In C++, we can declare an array by simply specifying the data type first and then the name of an array with its size.
data_type array_name[Size_of_array];
Example
int arr[5];
Here,
 int: It is the type of data to be stored in the array. We can also use other data types such as char, float, and double.
 arr: It is the name of the array.
 5: It is the size of the array which means only 5 elements can be stored in the array.

Initialization of Array in C++

In C++, we can initialize an array in many ways but we will discuss some most common ways to initialize an array. We can
initialize an array at the time of declaration or after declaration.
1. Initialize Array with Values in C++
We have initialized the array with values. The values enclosed in curly braces ‘{}’ are assigned to the array. Here, 1 is stored
in arr[0], 2 in arr[1], and so on. Here the size of the array is 5.
int arr[5] = {1, 2, 3, 4, 5};
2. Initialize Array with Values and without Size in C++
We have initialized the array with values but we have not declared the length of the array, therefore, the length of an array
is equal to the number of elements inside curly braces.
int arr[] = {1, 2, 3, 4, 5};
3. Initialize Array after Declaration (Using Loops)
We have initialized the array using a loop after declaring the array. This method is generally used when we want to take
input from the user or we cant to assign elements one by one to each index of the array. We can modify the loop conditions
or change the initialization values according to requirements.
for (int i = 0; i < N; i++) {
arr[i] = value;
}
4. Initialize an array partially in C++
Here, we have declared an array ‘partialArray’ with size ‘5’ and with values ‘1’ and ‘2’ only. So, these values are stored at the
first two indices, and at the rest of the indices ‘0’ is stored.
int partialArray[5] = {1, 2};
5. Initialize the array with zero in C++
We can initialize the array with all elements as ‘0’ by specifying ‘0’ inside the curly braces. This will happen in case of zero
only if we try to initialize the array with a different value say ‘2’ using this method then ‘2’ is stored at the 0th index only.
int zero_array[5] = {0};
Accessing an Element of an Array in C++
Elements of an array can be accessed by specifying the name of the array, then the index of the element enclosed in the
array subscript operator []. For example, arr[i].
Example 1: The C++ Program to Illustrate How to Access Array Elements

// C++ Program to Illustrate How to Access Array Elements

#include <iostream>
using namespace std;
int main()
{
int arr[3];
// Inserting elements in an array
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
// Accessing and printing elements of the array
cout << "arr[0]: " << arr[0] << endl;
cout << "arr[1]: " << arr[1] << endl;
cout << "arr[2]: " << arr[2] << endl;
return 0;
}

 Types of Arrays in C++

There are 3 types of an array in C++ :
 One-dimensional array
 Two-dimensional array
 Multidimensional array
 One-Dimensional Array:
In this type of array, it stores elements in a single dimension. And, In this array, a single specification is required to describe
elements of the array.

The diagram above shows that it arranged all the elements row-wise in a single dimension, one after the other.
Now, take an example of a one-dimensional array.
In this example, you are printing the elements 1,7,9,4,5 using for loop, and depicted below is the output of this example.

 Two-Dimensional Array:
In this type of array, two indexes describe each element, the first index represents a row, and the second index represents a
column.

Fig: Two-dimensional array

The elements are arranged row-wise and column-wise; in a two-dimensional array, there are ‘i’ number of rows and ‘j’
number of columns. The above figure is a representation of a 3 x 3 matrix, which means there are three rows and three
columns in the array.

Example of a two-dimensional array.

 Fig: Example of a two-dimensional array

In this example, you are printing a two-dimensional array of three rows and three columns; you need to use two for loops.
The first loop, i.e., i loop, runs for the row from 0 to 3, and the second loop, i.e., j loop, runs for the column from 0 to 3.
And below is the output of this example.

 Multidimensional Array:
The simplest example of a multidimensional array is a 2-d array; a two-dimensional array also falls under the category of a
multidimensional array. This array can have any number of dimensions.
The syntax for declaring a multidimensional array is:
Syntax:
Datatype array_name [size 1][size 2] . . . . . [size n];
Here size1 size2 up to so on size n describes the number of dimensions; in the case of a 2-d array, there are only two
dimensions, a multidimensional array can have any number of dimensions.
Example:
int array[5][10][4];
  C++ Strings
A string is a collection of characters. There are two types of strings commonly used in C++ :
 Strings that are objects of string class (The Standard C++ Library String Class)
 C-strings (C-style Strings)

C-strings
In C programming, the collection of characters is stored in the form of arrays. This is also supported in C++ programming.
Hence, it's called C-strings.
C-strings are arrays of type char terminated with a null character, that is, \0 (ASCII value of null character is 0).

How to define a C-string?

char str[] = "C++";
In the above code, str is a string and it holds 4 characters.
Although "C++" has three characters, the null character \0 is added to the end of the string automatically.

Alternative ways of defining a string

char str[4] = "C++";

char str[] = {'C','+','+','\0'};

Example 1: C++ String to Read a Word

C++ program to display a string entered by user.
#include <iostream>
using namespace std;

int main()
{
char str[100];

cout << "Enter a string: ";

cin >> str;
cout << "You entered: " << str << endl;

cout << "\nEnter another string: ";

cin >> str;
cout << "You entered: " << str << endl;

return 0;
}
Run Code
Output
Enter a string: C++
You entered: C++

Enter another string: Programming is fun.

You entered: Programming
Note:In the second example, only "Programming" is displayed instead of "Programming is fun".
This is because the extraction operator >> works as scanf() in C and considers a space " " as a terminating character.
Example 2: C++ String to read a line of text
C++ program to read and display an entire line entered by the user.
#include <iostream>
using namespace std;
int main()
{
char str[100];
cout << "Enter a string: ";
cin.get(str, 100);
cout << "You entered: " << str << endl;
return 0;
}
Run Code
Output
Enter a string: Programming is fun.
You entered: Programming is fun.
To read the text containing blank space, cin.get function can be used. This function takes two arguments.
The first argument is the name of the string (address of the first element of the string), and the second argument is the
maximum size of the array.
In the above program, str is the name of the string and 100 is the maximum size of the array.

String Object
In C++, you can also create a string object for holding strings.
Unlike using char arrays, string objects have no fixed length and can be extended as per your requirement.

Example 3: C++ string using string data type

#include <iostream>
using namespace std;
int main()
{
// Declaring a string object
string str;
cout << "Enter a string: ";
getline(cin, str);

cout << "You entered: " << str << endl;

return 0;
}
Run Code
Output
Enter a string: Programming is fun.
You entered: Programming is fun.
In this program, a string str is declared. Then, the string is asked from the user.
Instead of using cin>> or cin.get() function, you can get the entered line of text using getline().
getline() function takes the input stream as the first parameter, which is cin and str as the location of the line to be stored.
Passing String to a Function
Strings are passed to a function in a similar way arrays are passed to a function.
#include <iostream>
using namespace std;
void display(char *);
void display(string);

int main()
{
string str1;
char str[100];

cout << "Enter a string: ";

getline(cin, str1);

cout << "Enter another string: ";

cin.get(str, 100, '\n');

display(str1);
display(str);
return 0;
}

void display(char s[])

{
cout << "Entered char array is: " << s << endl;
}

void display(string s)
{
cout << "Entered string is: " << s << endl;
}
Run Code
Output
Enter a string: Programming is fun.
Enter another string: Really?
Entered string is: Programming is fun.
Entered char array is: Really?
In the above program, two strings are asked to enter. These are stored in str and str1 respectively, where str is a char array
and str1 is a string object.
Then, we have two functions display() that outputs the string onto the string.
The only difference between the two functions is the parameter.
The first display() function takes the char array as a parameter, while the second takes the string as a parameter.
This process is known as function overloading. Learn more about Function Overloading.

 C Style String Functions:

C++ supports a wide range of functions that manipulate null-terminated strings. These functions are defined in <string.h>
header file.

Sr.No Function & Purpose

strcpy(s1, s2);
1
Copies string s2 into string s1.
 strcat(s1, s2);
2
Concatenates string s2 onto the end of string s1.

strlen(s1);
3
Returns the length of string s1.

strcmp(s1, s2);
4
Returns 0 if s1 and s2 are the same; less than 0 if s1<s2; greater than 0 if s1>s2.

strchr(s1, ch);
5
Returns a pointer to the first occurrence of character ch in string s1.

strstr(s1, s2);
6
Returns a pointer to the first occurrence of string s2 in string s1.
Example
Following example makes use of few of the above-mentioned functions −
#include <iostream>
#include <cstring>
using namespace std;
int main ()
{
char str1[10] = "Hello";
char str2[10] = "World";
char str3[10];
int len ;

// copy str1 into str3

strcpy( str3, str1);
cout << "strcpy( str3, str1) : " << str3 << endl;

// concatenates str1 and str2

strcat( str1, str2);
cout << "strcat( str1, str2): " << str1 << endl;

// total lenghth of str1 after concatenation

len = strlen(str1);
cout << "strlen(str1) : " << len << endl;

return 0;
}
When the above code is compiled and executed, it produces result something as follows −
strcpy( str3, str1) : Hello
strcat( str1, str2): HelloWorld
strlen(str1) : 10

 String Functions using String Class:

String is an object of the <string> class, and hence, it has a variety of functions that users can utilize for a variety of
operations. Some of these functions are as follows –
 Function Description

length() This function returns the length of the string.

swap() This function is used to swap the values of 2 strings.

size() Used to find the size of string

resize() This function is used to resize the length of the string up to the given number of characters.

find() Used to find the string which is passed in parameters

push_back() This function is used to push the character at the end of the string

pop_back() This function is used to pop the last character from the string

clear() This function is used to remove all the elements of the string.

This function is used to search for a certain substring inside a string and returns the position of
find()
the first character of the substring.

This function is used to replace each element in the range [first, last) that is equal to old value
replace()
with new value.

substr() This function is used to create a substring from a given string.

compare() This function is used to compare two strings and returns the result in the form of an integer.

erase() This function is used to remove a certain part of a string.

Length of a String
The length of a string is the number of characters present in the string. Hence, the string "apple" has a length of 5
characters and the string "hello son" has a length of 9 characters (including empty spaces). This can be accessed using the
length() method in <string> header file.
Syntax
The syntax is explained as follows −
int len = string_1.length();
 Example: String Length
#include <iostream>
#include <string>
using namespace std;

int main()
{
string x="hey boy";
cout<<x.length()<<endl;
return 0;
}
Output
7
 String Concatenation
String concatenation is a way to add two strings together. This can be done using two ways −
Addition Operator
The addition operator is used to add two elements. In case of strings, the addition operator concatenates the two strings.
This is clearly explained in the following example −
Example:
#include <iostream>
#include <string>
using namespace std;

int main()
{
string x = "10";
string y = "20";
cout<<x+y<<endl;
return 0;
}
Output
1020
 Using string append() method
C++ is an object oriented programming language, and hence a string is actually an object, which contain functions that can
perform certain operations on strings. We can use string append() method to append one string to another.
The syntax of this operation is as follows −
Syntax
string_1.append(string_2);
The usage of this method is depicted clearly in the following example −
Example
#include <iostream>
#include <string>
using namespace std;

int main() {
string x="hey boy";
string y=" now";
x.append(y);
cout<<x<<endl;

return 0;
}
Output
hey boy now