Visit : www.EasyEngineeering.

net

EC6301 OBJECT ORIENTED PROGRAMMING AND DATA STRUCTURES L T P C 3 0 0 3

UNIT I DATA ABSTRACTION & OVERLOADING 9

Overview of C++ – Structures – Class Scope and Accessing Class Members – Reference
Variables – Initialization – Constructors – Destructors – Member Functions and Classes –
Friend Function – Dynamic Memory Allocation – Static Class Members – Container Classes and
Integrators – Proxy Classes – Overloading: Function overloading and Operator Overloading.

UNIT II INHERITANCE & POLYMORPHISM 9

Base Classes and Derived Classes – Protected Members – Casting Class pointers and Member
Functions – Overriding – Public, Protected and Private Inheritance – Constructors and
Destructors in derived Classes – Implicit Derived – Class Object To Base – Class Object
Conversion – Composition Vs. Inheritance – Virtual functions – This Pointer – Abstract Base
Classes and Concrete Classes – Virtual Destructors – Dynamic Binding.

UNIT III LINEAR DATA STRUCTURES 10

Abstract Data Types (ADTs) – List ADT – array-based implementation – linked list
implementation –– singly linked lists –Polynomial Manipulation - Stack ADT – Queue ADT -
Evaluating arithmetic expressions

UNIT IV NON-LINEAR DATA STRUCTURES 9

Trees – Binary Trees – Binary tree representation and traversals – Application of trees: Set
representation and Union-Find operations – Graph and its representations – Graph Traversals –
Representation of Graphs – Breadth-first search – Depth-first search - Connected components.

UNIT V S SORTING and SEARCHING 8

Sorting algorithms: Insertion sort - Quick sort - Merge sort - Searching: Linear search –Binary
Search
TOTAL: 45

TEXT BOOKS:
1. Deitel and Deitel, “C++, How To Program”, Fifth Edition, Pearson Education, 2005.
2. Mark Allen Weiss, “Data Structures and Algorithm Analysis in C++”, Third Edition, Addison-
Wesley, 2007.

REFERENCES:
1. Bhushan Trivedi, “Programming with ANSI C++, A Step-By-Step approach”, Oxford University
Press, 2010.
2. Goodrich, Michael T., Roberto Tamassia, David Mount, “Data Structures and Algorithms in
C++”, 7th Edition, Wiley. 2004.
3. Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein, "Introduction
to Algorithms", Second Edition, Mc Graw Hill, 2002.
4. Bjarne Stroustrup, “The C++ Programming Language”, 3rd Edition, Pearson Education, 2007.
5. Ellis Horowitz, Sartaj Sahni and Dinesh Mehta, “Fundamentals of Data Structures in C++”,
Galgotia Publications, 2007.

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

CONTENTS

S.NO TOPICS PAGE NO

UNIT- I

DATA ABSTRACTION & OVERLOADING

1 Overview of C++ 1

2 Structures Class Scope and Accessing Class Members 2

3 Reference Variables 4

4 Initialization 6

5 Constructors 8

6 Destructors 9

7 Member Functions and Classes 10

8 Friend Function 15

9 Dynamic Memory Allocation 17

10 Static Class Members 19

11 Container Classes and Integrators 23

12 Proxy Classes 27

13 Overloading: 30
13.1 Function overloading and
13.2 Operator Overloading.

UNIT- II
INHERITANCE AND POLYMORPHISM
14 Base Classes and Derived Classes 31

15 Protected Members 33

16 Casting Class pointers and Member Functions 35

17 Overriding 36

18 Public 38

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

19 Protected and Private Inheritance 39

20 Constructors and Destructors in derived Classes 40

21 Implicit Derived 41

22 Class Object To Base 42

23 Class Object Conversion 42

24 Composition Vs. Inheritance 43

25 Virtual functions 44

26 This Pointer 45

27 Abstract Base Classes and Concrete Classes 46

28 Virtual Destructors 47

UNIT III
LINEAR DATA STRUCTURES
29 3.1 Abstract Data Types (ADTs) 48

30 3.2 List ADT 49

3.2.1. Possible Operations on a List
3.2.2. List ADT Implementation 1

31 3.3 Array-based implementation 50

3.4 linked list implementation
32 3.5 singly linked lists 51

33 3.6 Polynomial Manipulation 52

34 3.7 Stack ADT 53

3.7.1. The stack ADT and its applications
3.7.2. Applications of stacks
3.7.3. Implementations of the stack ADT
3.7.3.1. Using static arrays
3.7.3.2. Using dynamic linked lists

35 3.8 Queue ADT 64

3.8.1. The queue ADT and its applications
3.8.2. Applications of queues

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

3.8.3. Implementations of the queue ADT

3.8.3.1. Using static arrays

36 9 Evaluating arithmetic expressions 65

UNIT- IV
NON-LINEAR DATA STRUCTURES
37 4.1. Trees 66

38 4.2. Binary Trees

38 4.3. Binary tree representation and traversals

39 4.4. Application of trees

4.4.1. Set representation and Union
40 4.5. Find operations

41 4.6. Graph and its representations

42 4.7. Graph Traversals

43 4.8. Representation of Graphs

UNIT- V
SORTING and SEARCHING
44 5.1. Sorting algorithms 84
5.7.1. Characteristics

45 5.2. Insertion sort 85

5.2.1. Pseudo code for Insertion Sort
46 5.3. Quick sort 86
5.3.1. Pseudo code for Quick Sort
47 5.4. Merge sort 88
5.4.1. Pseudo code for Merge Sort
48 5.5. Searching 90

49 5.6. Linear search 96

5.6.1. Implementation
50 5.7. Binary Search 97
5.7.1. Characteristics
APENDIX
51 Glossary 98

52 Question Bank with Answer 107

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

53 Question Bank 187

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

.
UNIT- I

DATA ABSTRACTION & OVERLOADING

1 Overview of C++
2 Structures Class Scope and Accessing Class Members
3 Reference Variables
4 Initialization
5 Constructors
6 Destructors
7 Member Functions and Classes
8 Friend Function
9 Dynamic Memory Allocation
10 Static Class Members
11 Container Classes and Integrators
12 Proxy Classes
13 Overloading:
13.1 Function overloading and
13.2 Operator Overloading.

1. Overview of C++:

The compilation process

When you write a program in C++, your first step is to create a file that contains the text
of the program, which is called a source file. Before you can run your program, you
need to translate the source file into an executable form. The first step in that process is
to invoke a program called a compiler, which translates the source file into an object file
containing the corresponding machine-language instructions. This object file is then
combined with other object files to produce an executable file that can be run on the
system. The other object files typically include predefined object files, called libraries,
that contain the machine-language instructions for various operations commonly required
by programs. The process of combining all the individual object files into an executable
file is called linking.

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

2 The structure of a C++ program

A comment istext that is ignored by the compiler but which nonetheless conveys
information to other programmers. A comment consists of text enclosed between the markers /*
and */ and may continue over several lines.

The lines beginning with #include such as

#include "genlib.h"
#include <iostream>
#include <iomanip>
indicate that the compiler should read in definitions from a header file. The inclusion of
a header file indicates that the program uses facilities from a library, which is a
collection of prewritten tools that perform a set of useful operations.
Program-level definitions
consttype name = value ;
constint LOWER_LIMIT = 0;
constint UPPER_LIMIT = 12;
A function is a unit of code that (1) performs a specific operation and (2) is identified by
name. intRaiseIntToPower(int n, int k); is an example of a function prototype, a declaration
that tells the compiler the information it needs to know about a function to generate the proper
code when that function is invoked.

The main program

Every C++ program must contain a function with the name main. This function specifies
the starting point for the computation and is called when the program starts up. When main has
finished its work and returns, execution of the program ends.
The next line in the body of RaiseIntToPoweris
2

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

result = 1;
This statement is a simple example of an assignment statement, which sets the variable on the
left of the equal sign to the value of the expression on the right.

3 Variables
Data values in a program are usually stored in variables. In C++, if you want to use avariable to
hold some information, you must declare that variable before you use it.
Declaring a variable establishes the following properties:

1.3.1 • Name. Every variable has a name, which is formed according to the rules described in
the section entitled ―Naming conventions‖ later in this chapter. You use the name in the
program to refer to the variable and the value it contains.
Type.Each variable in a C++ program is constrained to hold values of a particular
data type. C++ includes several predefined types and also allows you to define new types of your
own.
1.3.2• Lifetime. Depending on how they are declared, some variables persist throughout the
entire program, while others are created and destroyed dynamically as the program moves
through various levels of function call.
1.3.3• Scope. The declaration of a variable also controls what parts of the program have access to
the variable, which is called its scope.
The standard syntax for declaring a variable is
typenamelist;
int result;
int result;
result = 0;

4. Initializion

An initial value specified as part of a declaration is called an initializer.

The names used for variables, functions, types, constants, and so forth are collectively known as
identifiers. In C++, the rules for identifier formation are
1. The name must start with a letter or the underscore character (_).
2. All other characters in the name must be letters, digits, or the underscore. No spaces
or other special characters are permitted in names.
3. The name must not be one of the reserved keywords
Most variables are declared with the body of a function. Such variables are called local
variables. The scope of a local variable extends to the end of the block in which it is declared.
The lifetime of a local variable is the time during which that function is active. When the
function is called, space for each local variable is allocated for the duration of that function call.
When the function returns, all its local variables disappear. If a variable declaration appears
outside any function definition, that declaration introduces a global variable. The scope of a
global variable is the remainder of the file in which it is declared. Its lifetime continues
throughout the entire execution of a program. Global variables are therefore able to store values
that persist across function calls.
3

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

A data type is defined by two properties: a domain, which is the set of values that belong
to that type, and a set of operations, which defines the behavior of that type. The type int, which
corresponds to the standard representation of an integer on the computer system you are using.
C++ defines three integer types— short, int, and long
The internal size of an integer cannot decrease as you move from short to into long. A compiler
designer for C++ could, for example, decide to make short and int the same size but could not
make intsmaller than short.
• The maximum value of type intmust be at least 32,767 (215–1).
• The maximum value of type long must be at least 2,147,483,647 (231–1).
Numbers that include a decimal fraction are called floating-point numbers, which are
used to approximate real numbers in mathematics. As with integers, C++ defines three different
floating-point types: float, double, and long double.
The most primitive elements of text data are individual characters, which are represented in
C++ using the predefined data type char.
Characters are most useful when they are collected together into sequential units. In
programming, a sequence of characters is called a string.
it is often necessary to test a particular condition that affects the subsequent behavior of your
code. Typically, that condition is specified using an expression whose value is either true or
false. This data type—for which the only legal values are true and false—is called Boolean data,
In C++, the Boolean type is called bool and its domain consists of the values true and
false. all input and output operations—which are often referred to collectively as I/O
operations—are performed by calling functions provided as part of a library.

int main() {
cout<< "This program averages three numbers." <<endl;
cout<< "1st number: ";
double n1 = GetReal();
cout<< "2nd number: ";
double n2 = GetReal();
cout<< "3rd number: ";
double n3 = GetReal();
double average = (n1 + n2 + n3) / 3;
cout<< "The average is " << average <<endl;
return 0;
}

In C++, an expression is composed of terms and operators. An

operator
is a character (or sometimes a short sequence of characters) that indicates a computational
operation.

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

is re-written as

The point of listing all the operators in a single table is to establish how they relate to one
another in terms of precedence, which is a measure of how tightly an operator binds to its
operands in the absence of parentheses.
It is, however, important to note that the – operator occurs in two forms. When it is
written between two operands, it is a binary operator representing subtraction. When it is
written in front of a single operand, as in is -b, it is a unary operator representing negation. If
two operators have the same precedence, they are applied in the order specified by Their
associativity, which indicates whether that operator groups to the left or to the right.
Most operators in C++ are left-associative, which means that the leftmost operator is evaluated
first. A few operators—primarily the assignment operator, which is discussed in more detail later
in this chapter—are right-associative, which mean that they are evaluated from right to left.

Mixing types in an expression

If C++ encounters an operator whose operands are of different numeric types, the compiler
automatically converts the operands to a common type by determining which of the two
operand types appears closest to the top
The operation of discarding a decimal fraction is called truncation.

Type casts
a unary operator that consists of the desired type followed by the value you wish to convert in
parentheses
The assignment operator
In C++, assignment of values to variables is built into the expression structure. The =
operator takes two operands, just like + or *. The left operand must indicate a value that
can change, which is typically a variable name. When the assignment operator is
executed, the expression on the right-hand side is evaluated, and the resulting value is
then stored in the variable that appears on the left-hand side.
Assignments that are written as part of larger expressions are called embedded assignments.
n1 = (n2 = (n3 = 0));
The expression n3 = 0 is evaluated, which sets n3 to 0 and then passes 0 along as the value of the
assignment expression. That value is assigned to n2, and the result is then assigned to n1.
Statements of this sort are called multiple assignments. C++ allows you to combine assignment
with a binary operator to produce a form called a shorthand assignment. For any binary
operator op, the statement
variable op= expression;

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Increment and decrement operators

Beyond the shorthand assignment operators, C++ offers a further level of abbreviation for
two particularly common programming operations—adding or subtracting 1 from a variable.
Adding 1 to a variable is called incrementing it subtracting 1 is called decrementingit. To
indicate these operations in an extremely compact form, C++ uses the operators ++ and --. For
example, the statement x++;
The first form, in which the operator follows the operand, is called the postfix form, the
second, the prefix form.
x++ Calculates the value of x first, and then increments it. The value returned to the surrounding
expression is the original value beforethe increment operation is performed. ++x Increments the
value of x first, and then uses the new value as the value of the ++ operation as a whole.
Procedures and functions enable you to divide a large programming problem into smaller pieces
that are individually easy to understand. The process of dividing a problem into manageable
pieces, called decomposition, is a fundamental programming strategy.
The use of reference parameters makes it possible for functions to change values in the
frame of their caller. This mechanism is referred to as call by reference.
C++ allows you to specify more than one definition for a function name or an operator in
the same scope, which is called function overloading and operator overloading respectively.
An overloaded declaration is a declaration that had been declared with the same name as a
previously declared declaration in the same scope, except that both declarations have different
arguments and obviously different definition (implementation).
When you call an overloaded function or operator, the compiler determines the most
appropriate definition to use by comparing the argument types you used to call the function or
operator with the parameter types specified in the definitions. The process of selecting the most
appropriate overloaded function or operator is called overload resolution.

3 Overloading:

13.1 Function overloading in C++:

You can have multiple definitions for the same function name in the same scope. The
definition of the function must differ from each other by the types and/or the number of
arguments in the argument list. You can not overload function declarations that differ only by
return type.
Following is the example where same function print() is being used to print different data
types:
#include<iostream>
usingnamespacestd;
classprintData
{
public:
voidprint(inti){
cout<<"Printing int: "<<i<<endl;
}
voidprint(double f){
cout<<"Printing float: "<< f <<endl;
6

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

}
voidprint(char* c){
cout<<"Printing character: "<< c <<endl;
}
};
int main(void)
{
printDatapd;
// Call print to print integer
pd.print(5);
// Call print to print float
pd.print(500.263);
// Call print to print character
pd.print("Hello C++");
return0;
}
When the above code is compiled and executed, it produces the following result:
Printingint:5
Printingfloat:500.263
Printing character:Hello C++

4. Operators overloading in C++:

You can redefine or overload most of the built-in operators available in C++. Thus a programmer
can use operators with user-defined types as well.
Overloaded operators are functions with special names the keyword operator followed by the
symbol for the operator being defined. Like any other function, an overloaded operator has a
return type and a parameter list.

Boxoperator+(constBox&);
declares the addition operator that can be used to add two Box objects and returns final Box
object. Most overloaded operators may be defined as ordinary non-member functions or as
class member functions. In case we define above function as non-member function of a class
then we would have to pass two arguments for each operand as follows:

Boxoperator+(constBox&,constBox&);
Following is the example to show the concept of operator over loading using a member function.
Here an object is passed as an argument whose properties will be accessed using this object, the
object which will call this operator can be accessed using this operator as explained below:

#include<iostream>
usingnamespacestd;
classBox
{
7

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

public:
doublegetVolume(void)
{
return length * breadth * height;
}
voidsetLength(doublelen)
{
length=len;
}
voidsetBreadth(doublebre)
{
breadth=bre;
}
voidsetHeight(doublehei)
{
height=hei;
}
// Overload + operator to add two Box objects.
Boxoperator+(constBox& b)
{
Boxbox;
box.length=this->length +b.length;
box.breadth=this->breadth +b.breadth;
box.height=this->height +b.height;
return box;
}
private:
double length;// Length of a box
double breadth;// Breadth of a box
double height;// Height of a box
};
// Main function for the program
int main()
{
BoxBox1;// Declare Box1 of type Box
BoxBox2;// Declare Box2 of type Box
BoxBox3;// Declare Box3 of type Box
double volume =0.0;// Store the volume of a box here
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
8

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Box2.setHeight(10.0);
// volume of box 1
volume=Box1.getVolume();
cout<<"Volume of Box1 : "<< volume <<endl;
// volume of box 2
volume=Box2.getVolume();
cout<<"Volume of Box2 : "<< volume <<endl;
// Add two object as follows:
Box3=Box1+Box2;
// volume of box 3
volume=Box3.getVolume();
cout<<"Volume of Box3 : "<< volume <<endl;
return0;
}

When the above code is compiled and executed, it produces the following result:
Volume of Box1:210
Volume of Box2:1560
Volume of Box3:5400

A container class is a class designed to hold and organize multiple instances of another class.
There are many different kinds of container classes, each of which has various advantages,
disadvantages, and restrictions in their use. By far the most commonly used container in
programming is the array, which you have already seen many examples of. Although C++
has built-in array functionality, programmers will often use an array container class instead
because of the additional benefits it provides. Unlike built-in arrays, array container classes
generally provide dynamically resizing (when elements are added or removed) and do
bounds-checking. This not only makes array container classes more convenient than normal
arrays, but safer too.
Container classes typically implement a fairly standardized minimal set of functionality. Most
well-defined containers will include functions that:
Create an empty container (via a constructor)
Insert a new object into the container
Remove an object from the container
Report the number of objects currently in the container
Empty the container of all objects
Provide access to the stored objects
Sort the elements (optional)
Sometimes certain container classes will omit some of this functionality. For example,
arrays container classes often omit the insert and delete functions because they are slow and the
class designer does not want to encourage their use.
Container classes generally come in two different varieties.

Value containers are compositions that store copies of the objects that they are holding (and
thus are responsible for creating and destroying those copies).
9

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

6. Reference containers are aggregations that store pointers or references to other objects (and
thus are not responsible for creation or destruction of those objects).
Unlike in real life, where containers can hold whatever you put in them, in C++,
containers typically only hold one type of data. For example, if you have an array of integers, it
will only hold integers. Unlike some other languages, C++ generally does not allow you to mix
types inside a container. If you want one container class that holds integers and another that
holds doubles, you will have to write two separate containers to do this (or use templates, which
is an advanced C++ feature). Despite the restrictions on their use, containers are immensely
useful, and they make programming easier, safer, and faster.

An array container class

In this example, we are going to write an integer array class that implements most of the
common functionality that containers should have. This array class is going to be a value
container, which will hold copies of the elements its organizing.

First, let’s create the IntArray.h file:

#ifndef INTARRAY_H
#define INTARRAY_H
class IntArray
{
};
#endif

Our IntArray is going to need to keep track of two values: the data itself, and the size of the
array. Because we want our array to be able to change in size, we’ll have to do some dynamic
allocation, which means we’ll have to use a pointer to store the data.

#ifndef INTARRAY_H
#define INTARRAY_H
class IntArray
{
private:
intm_nLength;
int *m_pnData;
};
#endif

Now we need to add some constructors that will allow us to create IntArrays. We are
going to add two constructors: one that constructs an empty array, and one that will allow us to
construct an array of a predetermined size.

10

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

#ifndef INTARRAY_H
#define INTARRAY_H

class IntArray
{
private:
intm_nLength;
int *m_pnData;
public:
IntArray()
{
m_nLength = 0;
m_pnData = 0;
}
IntArray(intnLength)
{
m_pnData = new int[nLength];
m_nLength = nLength;
}
};
#endif
We’ll also need some functions to help us clean up IntArrays. First, we’ll write a
destructor, which simply deallocates any dynamically allocated data. Second, we’ll write a
function called Erase(), which will erase the array and set the length to 0.
~IntArray()
{
delete[] m_pnData;
}
void Erase()
{
delete[] m_pnData;
// We need to make sure we set m_pnData to 0 here, otherwise it will
// be left pointing at deallocated memory!
m_pnData = 0;
m_nLength = 0;
}
Now let’s overload the [] operator so we can access the elements of the array. We should
bounds check the index to make sure it’s valid, which is best done using the assert() function.
We’ll also add an access function to return the length of the array.

#ifndef INTARRAY_H
#define INTARRAY_H
11

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

#include <assert.h> // for assert()

class IntArray
{
private:
intm_nLength;
int *m_pnData;
public:
IntArray()
{
m_nLength = 0;
m_pnData = 0;
}
IntArray(intnLength)
{
m_pnData = new int[nLength];
m_nLength = nLength;
}
delete[] m_pnData;
}
void Erase()
{
delete[] m_pnData;
// We need to make sure we set m_pnData to 0 here, otherwise it will
// be left pointing at deallocated memory!
m_pnData = 0;
m_nLength = 0;
}
int& operator[](intnIndex)
{
assert(nIndex>= 0 &&nIndex<m_nLength);
return m_pnData[nIndex];
}
intGetLength() { return m_nLength; }
};
#endif

8. Static members of a C++ class

We can define class members static using static keyword. When we declare a member of a class
as static it means no matter how many objects of the class are created, there is only one copy of
the static member.
A static member is shared by all objects of the class. All static data is initialized to zero when the
first object is created, if no other initialization is present. We can't put it in the class definition
but it can be initialized outside the class as done in the following example by re-declaring the
static variable, using the scope resolution operator :: to identify which class it belongs to.
Let us try the following example to understand the concept of static data members:

12

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

~IntArray()
{
#include<iostream>
usingnamespacestd;
classBox
{
public:
staticintobjectCount;
// Constructor definition
Box(double l=2.0,double b=2.0,double h=2.0)
{
cout<<"Constructor called."<<endl;
length= l;
breadth= b;
height= h;
// Increase every time object is created
objectCount++;
}
doubleVolume()
{
return length * breadth * height;
}
private:
double length;// Length of a box
double breadth;// Breadth of a box
double height;// Height of a box
};
// Initialize static member of class Box
intBox::objectCount=0;
int main(void)
{
BoxBox1(3.3,1.2,1.5);// Declare box1
BoxBox2(8.5,6.0,2.0);// Declare box2
// Print total number of objects.
cout<<"Total objects: "<<Box::objectCount<<endl;
return0;
}
When the above code is compiled and executed, it produces the following result:
Constructor called.
Constructor called.
Total objects:2

Static Function Members:

13

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

By declaring a function member as static, you make it independent of any particular object of
the class. A static member function can be called even if no objects of the class exist and the
static functions are accessed using only the class name and the scope resolutionoperator ::.
A static member function can only access static data member, other static member functions
and any other functions from outside the class.
Static member functions have a class scope and they do not have access to the this pointer of
the class. You could use a static member function to determine whether some objects of the
class have been created or not.
Let us try the following example to understand the concept of static function members:

#include<iostream>
usingnamespacestd;
classBox
{
public:
staticintobjectCount;
// Constructor definition
Box(double l=2.0,double b=2.0,double h=2.0)
{
cout<<"Constructor called."<<endl;
length= l;
breadth= b;
height= h;
// Increase every time object is created
objectCount++;
}
doubleVolume()
{
return length * breadth * height;
}
staticintgetCount()
{
returnobjectCount;
}
private:
double length;// Length of a box
double breadth;// Breadth of a box
double height;// Height of a box
};
// Initialize static member of class Box
intBox::objectCount=0;
int main(void)
{
// Print total number of objects before creating object.
cout<<"Inital Stage Count: "<<Box::getCount()<<endl;
14

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

BoxBox1(3.3,1.2,1.5);// Declare box1

BoxBox2(8.5,6.0,2.0);// Declare box2
// Print total number of objects after creating object.
cout<<"Final Stage Count: "<<Box::getCount()<<endl;
return0;
}
When the above code is compiled and executed, it produces the following result:
InitalStageCount:0
Constructor called.
Constructor called.
FinalStageCount:2

10. Dynamic memory allocation

Operators new and new[]
Dynamic memory is allocated using operator new. new is followed by a data type specifier
and, if a sequence of more than one element is required, the number of these within
brackets []. It returns a pointer to the beginning of the new block of memory allocated. Its
syntax is:
pointer = new type
pointer = new type [number_of_elements]
The first expression is used to allocate memory to contain one single element of type type.
The second one is used to allocate a block (an array) of elements of type type,
where number_of_elements is an integer value representing the amount of these. For
example:
1
2
int * foo;
foo = newint [5];
In this case, the system dynamically allocates space for five elements of type int and returns a
pointer to the first element of the sequence, which is assigned to foo (a pointer).
Therefore, foo now points to a valid block of memory with space for five elements of
type int.

Here, foo is a pointer, and thus, the first element pointed to by foo can be accessed either with
the expressionfoo[0] or the expression *foo (both are equivalent). The second element can be
accessed either with foo[1] or *(foo+1), and so on...
15

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

There is a substantial difference between declaring a normal array and allocating dynamic
memory for a block of memory using new. The most important difference is that the size of a
regular array needs to be a constant expression, and thus its size has to be determined at the
moment of designing the program, before it is run, whereas the dynamic memory allocation
performed by new allows to assign memory during runtime using any variable value as size.
The dynamic memory requested by our program is allocated by the system from the memory
heap. However, computer memory is a limited resource, and it can be exhausted. Therefore,
there are no guarantees that all requests to allocate memory using operator new are going to
be granted by the system.
C++ provides two standard mechanisms to check if the allocation was successful:
One is by handling exceptions. Using this method, an exception of type bad_alloc is thrown
when the allocation fails. Exceptions are a powerful C++ feature explained later in these
tutorials. But for now, you should know that if this exception is thrown and it is not handled by a
specific handler, the program execution is terminated.
This exception method is the method used by default by new, and is the one used in a
declaration like:
foo = newint [5]; // if allocation fails, an exception is thrown

The other method is known as nothrow, and what happens when it is used is that when a
memory allocation fails, instead of throwing a bad_alloc exception or terminating the program,
the pointer returned by new is a null pointer, and the program continues its execution normally.
This method can be specified by using a special object called nothrow, declared in
header <new>, as argument fornew:
foo = new (nothrow) int [5];
In this case, if the allocation of this block of memory fails, the failure can be detected by
checking if foo is a null pointer:

int * foo;
foo = new (nothrow) int [5];
if (foo == nullptr) {
// error assigning memory. Take measures.
}

This no throw method is likely to produce less efficient code than exceptions, since it implies
explicitly checking the pointer value returned after each and every allocation. Therefore, the
exception mechanism is generally preferred, at least for critical allocations. Still, most of the
coming examples will use the nothrow mechanism due to its simplicity.

Operators delete and delete[]

In most cases, memory allocated dynamically is only needed during specific periods of time
within a program; once it is no longer needed, it can be freed so that the memory becomes
available again for other requests of dynamic memory. This is the purpose of operator delete,
whose syntax is:
delete pointer;
delete[] pointer;
16

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

The first statement releases the memory of a single element allocated using new, and the
second one releases the memory allocated for arrays of elements using new and a size in
brackets ([]).
The value passed as argument to delete shall be either a pointer to a memory block previously
allocated with new, or a null pointer (in the case of a null pointer, delete produces no effect).

// rememb-o-matic
#include <iostream>
#include <new>
usingnamespacestd;
int main ()
{
inti,n;
int * p;
cout<<"How many numbers would you like to type? ";
cin>>i;
p= new (nothrow) int[i];
if (p == nullptr)
cout<<"Error: memory could not be allocated";
else
{
for (n=0; n<i; n++)
{
cout<<"Enter number: ";
cin>> p[n];
}
cout<<"You have entered: ";
for (n=0; n<i; n++)
cout<< p[n] <<", ";
delete[] p;
}
return 0;
}

How many numbers would you like to type? 5

Enter number : 75
Enter number : 436
Enter number : 1067
Enter number : 8
Enter number : 32
You have entered: 75, 436, 1067, 8, 32,
Notice how the value within brackets in the new statement is a variable value entered by the
user (i), not a constant expression:
p= new (nothrow) int[i];
There always exists the possibility that the user introduces a value for i so big that the system
17

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

cannot allocate enough memory for it. For example, when I tried to give a value of 1 billion
to the "How many numbers" question, my system could not allocate that much memory for
the program, and I got the text message we prepared for this case (Error: memory could not
be allocated).
It is considered good practice for programs to always be able to handle failures to allocate
memory, either by checking the pointer value (if nothrow) or by catching the proper exception.

11. Dynamic memory in C

C++ integrates the operators new and delete for allocating dynamic memory. But these were
not available in the C language; instead, it used a library solution, with the
functions malloc, calloc, realloc and free, defined in the header <cstdlib> (known
as <stdlib.h> in C). The functions are also available in C++ and can also be used to allocate
and deallocate dynamic memory.
Note, though, that the memory blocks allocated by these functions are not necessarily
compatible with those returned by new, so they should not be mixed; each one should be
handled with its own set of functions or operators.
A friend function of a class is defined outside that class' scope but it has the right to access all
private and protected members of the class. Even though the prototypes for friend functions
appear in the class definition, friends are not member functions.
A friend can be a function, function template, or member function, or a class or class template, in
which case the entire class and all of its members are friends.
To declare a function as a friend of a class, precede the function prototype in the class
definition with keyword friend as follows:
class Box
{
double width;
public:
double length;
friend void printWidth( Box box );
voidsetWidth( double wid );
};

To declare all member functions of class ClassTwo as friends of class ClassOne, place a
following declaration in the definition of class ClassOne: friend class ClassTwo;
Consider the following program:
#include <iostream>
using namespace std;
class Box
{
double width;
public:
friend void printWidth( Box box );
voidsetWidth( double wid );
};
// Member function definition
18

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

void Box::setWidth( double wid )

{
width = wid;
}
// Note: printWidth() is not a member function of any class.
voidprintWidth( Box box )
{
/* Because printWidth() is a friend of Box, it can
directly access any member of this class */

cout<< "Width of box : " <<box.width<<endl;

}
// Main function for the program
int main( )
{
Box box;
// set box width without member function
box.setWidth(10.0);
// Use friend function to print the wdith.
printWidth( box );
return 0;
}

When the above code is compiled and executed, it produces the following result:
Width of box : 10

A member function of a class is a function that has its definition or its prototype within the
class definition like any other variable. It operates on any object of the class of which it is a
member, and has access to all the members of a class for that object.
Let us take previously defined class to access the members of the class using a member
function instead of directly accessing them:
class Box
{
public:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
doublegetVolume(void);// Returns box volume
};
Member functions can be defined within the class definition or separately using scope
resolution operator, ::. Defining a member function within the class definition declares the
function inline, even if you do not use the inline specifier. So either you can
define Volume() function as below:
class Box
19

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

{
public:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
doublegetVolume(void)
{
return length * breadth * height;
}
};
If you like you can define same function outside the class using scope resolution operator,
:: as follows:
double Box::getVolume(void)
{
return length * breadth * height;
}

Here, only important point is that you would have to use class name just before :: operator. A
member function will be called using a dot operator (.) on a object where it will manipulate
data related to that object only as follows:
Box myBox; // Create an object
myBox.getVolume(); // Call member function for the object
Let us put above concepts to set and get the value of different class members in a class:
#include <iostream>
using namespace std;
class Box
{
public:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
// Member functions declaration
doublegetVolume(void);
voidsetLength( double len );
voidsetBreadth( double bre );
voidsetHeight( double hei );
};
// Member functions definitions
double Box::getVolume(void)
{
return length * breadth * height;
}
void Box::setLength( double len )
{
length = len;
}
20

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

void Box::setBreadth( double bre )

{
breadth = bre;
}
void Box::setHeight( double hei )
{
height = hei;
}
// Main function for the program
int main( )
{
Box Box1; // Declare Box1 of type Box
Box Box2; // Declare Box2 of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// volume of box 1
volume = Box1.getVolume();
cout<< "Volume of Box1 : " << volume <<endl;
// volume of box 2
volume = Box2.getVolume();
cout<< "Volume of Box2 : " << volume <<endl;
return 0;
}
When the above code is compiled and executed, it produces the following result:
Volume of Box1 : 210
Volume of Box2 : 1560

12. The Class Constructor:

A class constructor is a special member function of a class that is executed whenever we
create new objects of that class.
A constructor will have exact same name as the class and it does not have any return type at
all, not even void. Constructors can be very useful for setting initial values for certain
member variables.
Following example explains the concept of constructor:
#include <iostream>
using namespace std;
class Line
{
public:
21

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

voidsetLength( double len );

doublegetLength( void );
Line(); // This is the constructor
private:
double length;
};
// Member functions definitions including constructor
Line::Line(void)
{
cout<< "Object is being created" <<endl;
}
void Line::setLength( double len )
{
length = len;
}
double Line::getLength( void )
{
return length;
}
// Main function for the program
int main( )
{
Line line;
// set line length
line.setLength(6.0);
cout<< "Length of line : " <<line.getLength() <<endl;
return 0;
}
When the above code is compiled and executed, it produces the following result:
Object is being created
Length of line : 6

Parameterized Constructor:
A default constructor does not have any parameter, but if you need, a constructor can have
parameters. This helps you to assign initial value to an object at the time of its creation as
shown in the following example:
#include <iostream>
using namespace std;
class Line
{
public:
voidsetLength( double len );
doublegetLength( void );
Line(double len); // This is the constructor
private:
double length;
22

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

};
// Member functions definitions including constructor
Line::Line( double len)
{
cout<< "Object is being created, length = " <<len<<endl;
length = len;
}
void Line::setLength( double len )
{
length = len;
}
double Line::getLength( void )
{
return length;
}
// Main function for the program
int main( )
{
Line line(10.0);
// get initially set length.
cout<< "Length of line : " <<line.getLength() <<endl;
// set line length again
line.setLength(6.0);
cout<< "Length of line : " <<line.getLength() <<endl;
return 0;
}
When the above code is compiled and executed, it produces the following result:
Object is being created, length = 10
Length of line : 10
Length of line : 6
Using Initialization Lists to Initialize Fields:
In case of parameterized constructor, you can use following syntax to initialize the fields:
Line::Line( double len): length(len)
{
cout<< "Object is being created, length = " <<len<<endl;
}
Above syntax is equal to the following syntax:
Line::Line( double len)
{
cout<< "Object is being created, length = " <<len<<endl;
length = len;
}
If for a class C, you have multiple fields X, Y, Z, etc., to be initialized, then use can use same
syntax and separate the fields by comma as follows:
C::C( double a, double b, double c): X(a), Y(b), Z(c)
{
23

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

....
}

The Class Destructor:

A destructor is a special member function of a class that is executed whenever an object of
it's class goes out of scope or whenever the delete expression is applied to a pointer to the
object of that class.
A destructor will have exact same name as the class prefixed with a tilde (~) and it can
neither return a value nor can it take any parameters. Destructor can be very useful for
releasing resources before coming out of the program like closing files, releasing memories
etc.
Following example explains the concept of destructor:
#include <iostream>
using namespace std;
class Line
{
public:
voidsetLength( double len );
doublegetLength( void );
Line(); // This is the constructor declaration
~Line(); // This is the destructor: declaration
private:
double length;
};
// Member functions definitions including constructor
Line::Line(void)
{
cout<< "Object is being created" <<endl;
}
Line::~Line(void)
{
cout<< "Object is being deleted" <<endl;
}
void Line::setLength( double len )
{
length = len;
}
double Line::getLength( void )
{
return length;
}
// Main function for the program
int main( )
{
Line line;
// set line length
24

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

line.setLength(6.0);
cout<< "Length of line : " <<line.getLength() <<endl;
return 0;
}
When the above code is compiled and executed, it produces the following result:
Object is being created
Length of line : 6
Object is being deleted
Variables Initialization
A variable can be considered as a box that can hold a single value. However, initially the content
of a variable (or a box) is empty. Therefore, before one can use a variable, it must receive a
value. Do not assume the compiler or computer will put some value, say 0, into a variable.
There are at least three ways to put a value into a variable:
initializing it when the program is run
using an assignment statement
reading a value from keyboard or other device with a READ statement.
The way of initializing a variable is very similar to the use of PARAMETER attribute. More
precisely, do the following to initial a variable with the value of an expression:
add an equal sign (=) to the right of a variable name
to the right of the equal sign, write an expression. It is important to note that all names
in the expression must constants or names of constants.
Initializing a variable is only done exactly once when the computer loads your program into
memory for execution. That is, all initializations are done before the program starts its execution.
The use of un-initialized variables may cause unexpected result.
Examples:
The following example initializes variables Offset to 0.1, Length to 10.0, and tolerance to
1.E-7.
REAL :: Offset = 0.1, Length = 10.0, tolerance = 1.E-7

The following example initializes variables State1 to "MI", State2 to "MN",

and State3 to "MD".
CHARACTER(LEN=2) :: State1 = "MI", State2 = "MN", State3 = "MD"
The following example first defines three named integer constants
with PARAMETER and uses these values to initialize two integer variables. Thus,
variables Pay and Received are initialized to have values 4350 (=10*435) and 8 (3+5),
respectively.
INTEGER, PARAMETER :: Quantity = 10, Amount = 435, Period = 3
INTEGER :: Pay = Quantity*Amount, Received = Period+5
The following example contains a mistake. While the compiler is processing the
initialization value for variable Received, the value of Period is unknown, although it
will be defined on the next line.
INTEGER, PARAMETER :: Quantity = 10, Amount = 435
INTEGER :: Pay = Quantity*Amount, Received = Period+5
INTEGER, PARAMETER :: Period = 3
Reference variables

25

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Basic Syntax
Declaring a variable as a reference rather than a normal variable simply entails appending an
ampersand to the type name, such as this "reference to an int"
int& foo = ....;
Did you notice the "...."? (Probably, right? After all, it's 25% of the example.) When a
reference is created, you must tell it which variable it will become an alias for. After you
create the reference, whenever you use the variable, you can just treat it as though it were a
regular integer variable. But when you create it, you must initialize it with another variable,
whose address it will keep around behind the scenes to allow you to use it to modify that
variable.
In a way, this is similar to having a pointer that always points to the same thing. One key
difference is that references do not require dereferencing in the same way that pointers do;
you just treat them as normal variables. A second difference is that when you create a
reference to a variable, you need not do anything special to get the memory address. The
compiler figures this out for you:
int x;
int& foo = x;
// foo is now a reference to x so this sets x to 56
foo = 56;
std::cout<< x <<std::endl;

Functions taking References Parameters

Here's a simple example of setting up a function to take an argument "by reference",

implementing the swap function:
void swap (int& first, int& second)
{
int temp = first;
first = second;
second = temp;
}
Both arguments are passed "by reference"--the caller of the function need not even be aware
of it:
int a = 2;
int b = 3;
swap( a, b );

After the swap, a will be 3 and b will be 2. The fact that references require no extra work can
lead to confusion at times when variables magically change after being passed into a function.
BjarneStroustrup suggests that for arguments that the function is expected to change, using a
pointer instead of a reference helps make this clear--pointers require that the caller explicitly pass
in the memory address.

Efficiency Gains

26

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

You might wonder why you would ever want to use references other than to change the value--
well, the answer is that passing by reference means that the variable need not be copied, yet it
can still be passed into a function without doing anything special. This gives you the most bang
for your buck when working with classes. If you want to pass a class into a function, it almost
always makes sense for the function to take the class "by reference"—but generally, you want to
use a const reference.
This might look something like this:
intworkWithClass( constMyClass&a_class_object )
{
}
The great thing about using const references is that you can be sure that the variable isn't
modified, so you can immediately change all of your functions that take large objects—no need
to make a copy anymore. And even you were conscientious and used pointers to pass around
large objects, using references in the future can still make your code that much cleaner.

References and Safety

You're probably noticing a similarity to pointers here--and that's true, references are often
implemented by the compiler writers as pointers. A major difference is that references are
"safer". In general, references should always be valid because you must always initialize a
reference. This means that barring some bizarre circumstances (see below), you can be certain
that using a reference is just like using a plain old non-reference variable. You don'
need to check to make sure that a reference isn't pointing to NULL, and you won't get bitten
by an uninitialized reference that you forgot to allocate memory for.

References and Safety: the Exceptions

For the sake of full disclosure, it is possible to have an invalid references in one minor and one
major case.
First, if you explicitly assign a reference to a dereferenced NULL pointer, your reference will
be invalid:
int *x = 0;
int& y = *x;
Now when you try to use the reference, you'll get a segmentation fault since you're trying to
access invalid memory (well, on most systems anyhow).
By the way, this actually does work: since you're not actually accessing the value stored in *x
when you make the reference to it, this will compile just fine.
A more pressing issue is that it is possible to "invalidate" a reference in the sense that it is
possible that a reference to a block of memory can live on past the time when the memory is
valid. The most immediate example is that you shouldn't return a reference to local memory:
int&getLocalVariable()
{
int x;
return x;
}
Once the stack frame containing the memory for getLocalVariable is taken off the stack, then
the reference returned by this function will no longer be valid. Oops.
27

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

References and Dynamically Allocated Memory

Finally, beware of references to dynamically allocated memory. One problem is that when you
use references, it's not clear that the memory backing the reference needs to be deallocated--it
usually doesn't, after all. This can be fine when you're passing data into a function since the
function would generally not be responsible for deallocating the memory anyway.
On the other hand, if you return a reference to dynamically allocated memory, then you're asking
for trouble since it won't be clear that there is something that needs to be cleaned up by the
function caller.

Scope and Accessing Class Members

 A class’s data members and member functions belong to that class’s scope.
 Nonmember functions are defined at global namespace scope.
 Within a class’s scope, class members are immediately accessible by all of that class’s
member functions and can be referenced by name.
 Outside a class’s scope, class members are referenced through one of the handles on an
object: an object name, a reference to an object, or a pointer to an object.
 Member functions of a class can be overloaded only by other member functions of that
class.
 To overload a member function, provide in the class definition a prototype for each
version
 of the overloaded function, and provide a separate definition for each version of the
function.
 Variables declared in a member function have local scope and are known only to that
function.
 The dot member selection operator (.) is preceded by an object’s name or by a reference
to an object to access the object’s public members.
 Constructors with Default Arguments
 Like other functions, constructors can specify default arguments.

Default Memberwise Assignment

 The assignment operator (=) can be used to assign an object to another of the same type.
 Objectsmay be passed by value to or returned by value from functions. C++ creates a
new object and uses a copy constructor to copy the original object’s values into the new
object.
 For each class, the compiler provides a default copy constructor that copies each member
Of the original object into the corresponding member of the new object.

What is the output of the following program?

//time.h
class Time
{
public:
Time (int h=12, int m=10, int s=11); //constructor with default arguments
~Time();
28

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

voidsetTime (int h, int m, int s);

void display();
private:
int hour; int min; int sec;
};
----------------------------------------------------------------------------------------------------------
//t.cpp
#include "t.h"
#include <iostream>
using namespace std;
Time::Time (int h, int m, int s) { hour=h; min=m; sec=s; }
Time::~Time () { };
void Time::setTime (int h, int m, int s) { hour=h; min=m; sec=s; }
void Time::display () { cout<<hour<<":"<<min<<":"<<sec<<" "; }
----------------------------------------------------------------------------------------------------------
//mainTime.cpp
#include "t.h"
#include <iostream>
using namespace std;
void main ()
{
Time t1;
t1.display();
t1.setTime (10, 25, 30);
Time t2;
t2 = t1; //memberwise assignment
t2.display();
}

Structures

The format for defining a structure is

struct Tag {
Members
};
Where Tag is the name of the entire type of structure and Members are the variables within
the struct. To actually create a single structure the syntax is
struct Tag name_of_single_structure;
To access a variable of the structure it goes
name_of_single_structure.name_of_variable;
For example:
struct example {
int x;
};
struct example an_example; //Treating it like a normal variable type
29

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

an_example.x = 33; //How to access its members

Here is an example program:
struct database {
intid_number;
int age;
float salary;
};
int main()
{
database employee; //There is now an employee variable that has modifiable
// variables inside it.
employee.age = 22;
employee.id_number = 1;
employee.salary = 12000.21;
}

The struct database declares that database has three variables in it, age, id_number, and salary.
You can use database like a variable type like int. You can create an employee with the database
type as I did above. Then, to modify it you call everything with the 'employee.' in front of it. You
can also return structures from functions by defining their return type as a structure type. For
instance: databasefn(); I will talk only a little bit about unions as well. Unions are like structures
except that all the variables share the same memory. When a union is declared the compiler
allocates enough memory for the largest data-type in the union. It's like a giant storage chest
where you can store one large item, or a small item, but never the both at the same time. The '.'
operator is used to access different variables inside a union also. As a final note, if you wish to
have a pointer to a structure, to actually access the information stored inside the structure that is
pointed to, you use the -> operator in place of the . operator. All points about pointers still apply.

A quick example:
#include <iostream>
using namespace std;
structxampl {
int x;
};
int main()
{
xampl structure;
xampl *ptr;
structure.x = 12;
ptr = &structure; // Yes, you need the & when dealing with structures
// and using pointers to them
cout<<ptr->x; // The -> acts somewhat like the * when used with pointers
// It says, get whatever is at that memory address
// Not "get what that memory address is"
cin.get();
}
30

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

UNIT II

INHERITANCE AND POLYMORPHISM

2.1 Base Classes and Derived Classes

2.2 Protected Members
2.3 Casting Class pointers and Member Functions
2.4 Overriding
2.5 Public
2.6 Protected and Private Inheritance
2.7 Constructors and Destructors in derived Classes
2.8 Implicit Derived
2.9 Class Object To Base
2.10 Class Object Conversion
2.11 Composition Vs. Inheritance
2.12 Virtual functions
2.13 This Pointer
2.14 Abstract Base Classes and Concrete Classes
2.15 Virtual Destructors
2.16 Dynamic Binding.

Inheritance is a form of software reuse where a new class is created to

– absorb an existing class’s data and behaviors, and
– enhance them with new capabilities
The new class, the derived class, inherits the members of the existing class, known as the
base class
A direct base class is the base class from which a derived class explicitly inherits.
An indirect base class is inherited from two or more levels up in the class hierarchy.
In single inheritance, a class is derived from one base class. With multiple inheritance, a derived
class inherits from multiple base classes. public:: every object of a derived class is also an object
of its base class
• Note, base-class objects are NOT objects of their derived classes.
private:: is essentially an alternative to composition
• I.e., derived class members not accessible from outside
protected:: is rarely used
class Employee {
string givenName, familyName;
date hiringDate;
short department;
...
};
class Manager: public Employee {
set <Employee *> group;
31

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

short level;
...
}

Member functions of derived class cannot directly access private members of base class

• Example:–

Manager member functions in previous example cannot read manager’s own name!
Because data members of a class are by default private
A base class’s protected members can be accessed by
members and friends of the base class, and
members and friends of any class derived from the base class.
Derived-class member functions can refer to public and protected members of the base class.
By simply using their names
is-a relationship:: inheritance
– e.g., derived class object, car, is an object of the base class vehicle
– e.g., derived class object, Manager, is an object of the base class Employee
– has-a relationship:: composition
– e.g., a TreeNode object has (i.e., contains) a member object of type string
Base classes typically represent larger sets of objects than derived classes
Example
– Base class: vehicle
• Includes cars, trucks, boats, bicycles, etc.
– Derived class: car
a smaller, more-specific subset of vehiclesI.e., base classes have more objects
• But fewer data and function members
• Derived classes have only subsets of the objects
• Hence the term subclass
• But a derived class has more data and function members

Dynamic Binding
Explanation
In OOPs Dynamic Binding refers to linking a procedure call to the code that will be executed
only at run time. The code associated with the procedure in not known until the program is
executed, which is also known as late binding.
Example:
#include <iostream.h>
int Square(int x)
{ return x*x; }
int Cube(int x)
{ return x*x*x; }
int main()
{
int x =10;
int choice;
32

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

do
{
cout<< "Enter 0 for square value, 1 for cube value: ";
cin>> choice;
} while (choice < 0 || choice > 1);
int (*ptr) (int);
switch (choice)
{
case 0: ptr = Square; break;
case 1: ptr = Cube; break;
}
cout<< "The result is: " <<ptr(x) <<endl;
return 0;
}

Result:
Enter 0 for square value, 1 for cube value:0
The result is:100
In the above OOPs example the functions "Square" and "Cube" are called only at runtime based
on the value given for "choice". Then a pointer "ptr" is used to call the appropriate function to
get the result.

• protected (C++)
• protected:
• [member-list]
• protected base-class
The protected keyword specifies access to class members in the member-list up to the next
access specifier (public or private) or the end of the class definition. Class members declared as
protected can be used only by the following:
Member functions of the class that originally declared these members.
Friends of the class that originally declared these members.
Classes derived with public or protected access from the class that originally declared these
members.
Direct privately derived classes that also have private access to protected members.

When preceding the name of a base class, the protected keyword specifies that the public and
protected members of the base class are protected members of its derived classes. Protected
members are not as private as private members, which are accessible only to members of the
class in which they are declared, but they are not as public as public members, which are
accessible in any function. Protected members that are also declared as static are accessible to
any friend or member function of a derived class. Protected members that are not declared as
static are accessible to friends and member functions in a derived class only through a pointer to,
reference to, or object of the derived class.

Public inheritance

33

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Public inheritance is by far the most commonly used type of inheritance. In fact, very rarely will
you use the other types of inheritance, so your primary focus should be on understanding this
section. Fortunately, public inheritance is also the easiest to understand. When you inherit a base
class publicly, all members keep their original access specifications. Private members stay
private, protected members stay protected, and public members stay public.

class Base
{
public:
intm_nPublic;
private:
intm_nPrivate;
protected:
intm_nProtected;
};
class Pub: public Base
{
// Public inheritance means:
// m_nPublic stays public
// m_nPrivate stays private
// m_nProtected stays protected
Pub()
{
// The derived class always uses the immediate parent's class access specifications
// Thus, Pub uses Base's access specifiers
m_nPublic = 1; // okay: anybody can access public members
m_nPrivate = 2; // not okay: derived classes can't access private members in the base
class!
m_nProtected = 3; // okay: derived classes can access protected members
}
};
int main()
{

// Outside access uses the access specifiers of the class being accessed.
// In this case, the access specifiers of cPub. Because Pub has inherited publicly from
Base,
// no access specifiers have been changed.
Pub cPub;
cPub.m_nPublic = 1; // okay: anybody can access public members
cPub.m_nPrivate = 2; // not okay: can not access private members from outside class
cPub.m_nProtected = 3; // not okay: can not access protected members from outside
class
}
This is fairly straightforward. The things worth noting are:
1. Derived classes can not directly access private members of the base class.
34

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

2. The protected access specifier allows derived classes to directly access members of the base
class while not exposing those members to the public.
3. The derived class uses access specifiers from the base class.
4. The outside uses access specifiers from the derived class.
To summarize in table form:

Private inheritance

With private inheritance, all members from the base class are inherited as private. This means
private members stay private, and protected and public members become private. Note that this
does not affect that way that the derived class accesses members inherited from its parent! It only
affects the code trying to access those members through the derived class.

class Base
{
public:
intm_nPublic;
private:
intm_nPrivate;
protected:
intm_nProtected;
};
class Pri: private Base
{
// Private inheritance means:
// m_nPublic becomes private
// m_nPrivate stays private
// m_nProtected becomes private
Pri()
{
// The derived class always uses the immediate parent's class access specifications
// Thus, Pub uses Base's access specifiers

35

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

m_nPublic = 1; // okay: anybody can access public members

m_nPrivate = 2; // not okay: derived classes can't access private members in the base
class!
m_nProtected = 3; // okay: derived classes can access protected members
}
};
int main()
{
// Outside access uses the access specifiers of the class being accessed.
// Note that because Pri has inherited privately from Base,
// all members of Base have become private when access through Pri.
PricPri;
cPri.m_nPublic = 1; // not okay: m_nPublic is now a private member when accessed
through Pri
cPri.m_nPrivate = 2; // not okay: can not access private members from outside class
cPri.m_nProtected = 3; // not okay: m_nProtected is now a private member when
accessed through Pri
// However, we can still access Base members as normal through Base:
Base cBase;
cBase.m_nPublic = 1; // okay, m_nPublic is public
cBase.m_nPrivate = 2; // not okay, m_nPrivate is private
cBase.m_nProtected = 3; // not okay, m_nProtected is protected
}

To summarize in table form:

Protected inheritance
Protected inheritance is the last method of inheritance. It is almost never used, except in very
particular cases. With protected inheritance, the public and protected members become protected,
and private members stay private.

To summarize in table form:

36

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Protected inheritance is similar to private inheritance. However, classes derived from the derived
class still have access to the public and protected members directly. The public (stuff outside the
class) does not.

THIS POINTER

Every object in C++ has access to its own address through an important pointer called this
pointer. The thispointer is an implicit parameter to all member functions. Therefore, inside a
member function, this may be used torefer to the invoking object. Friend functions do not have a
thispointer, because friends are not members of a class. Only member functionshave a this
pointer.

Let us try the following example to understand the concept of this pointer:
#include <iostream>
using namespace std;
classBox
{
public:
// Constructor definition
Box(double l=2.0, double b=2.0, double h=2.0)
{
cout<<"Constructor called." <<endl;
length= l;
breadth= b;
height= h;
}
doubleVolume()
{
returnlength * breadth * height;
}
intcompare(Box box)
{
return this->Volume() >box.Volume();
}
private:
doublelength; // Length of a box
37

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

doublebreadth; // Breadth of a box

doubleheight; // Height of a box
};
intmain(void)
{
Box Box1(3.3, 1.2, 1.5); // Declare box1
Box Box2(8.5, 6.0, 2.0); // Declare box2
if(Box1.compare(Box2))
{
cout<<"Box2 is smaller than Box1" <<endl;
}
else
{
cout<<"Box2 is equal to or larger than Box1" <<endl;
}
return0;
}

When the above code is compiled and executed, it produces the following result:
Constructor called.
Constructor called.
Box2 is equal to or larger than Box1
An interface describes the behavior or capabilities of a C++ class without committing to a
particularimplementation of that class.
The C++ interfaces are implemented using abstract classes and these abstract classes should
not beconfused with data abstraction which is a concept of keeping implementation details
separate from associateddata.
A class is made abstract by declaring at least one of its functions as pure virtual function. A
pure virtual functionis specified by placing "= 0" in its declaration as follows:
classBox
{
public:
// pure virtaul function
virtual double getVolume() = 0;
private:
doublelength; // Length of a box
doublebreadth; // Breadth of a box
doubleheight; // Height of a box
};

The purpose of an abstrac t c lass(often referred to as an ABC) is to provide an appropriate

base class fromwhich other classes can inherit. Abstract classes cannot be used to instantiate
objects and serves only as aninterface. Attempting to instantiate an object of an abstract class
causes a compilation error.
Thus, if a subclass of an ABC needs to be instantiated, it has to implement each of the
virtual functions, whichmeans that it supports the interface declared by the ABC. Failure to
38

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

override a pure virtual function in a derivedclass, then attempting to instantiate objects of that
class, is a compilation error.
Classes that can be used to instantiate objects are called concrete c lasses.

Abstract Class Example:

Consider the following example where parent class provides an interface to the base class to
implement a function called g etArea():

#include <iostream>
using namespace std;
// Base class
classShape
{ public:
// pure virtual function providing interface framework.
virtualintgetArea() = 0;
voidsetWidth(intw)
{
width= w;
}
voidsetHeight(inth)
{
height= h;
}
protected:
intwidth;
intheight;
};
// Derived classes
classRectangle: public Shape
{ public:
intgetArea()
{
return(width * height);
}
};
classTriangle: public Shape
{ public:
intgetArea()
{
return(width * height)/2;
}
};
intmain(void)
{
Rectangle Rect;
39

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Triangle Tri;
Rect.setWidth(5);
Rect.setHeight(7);
// Print the area of the object.
cout<<"Total Rectangle area: " <<Rect.getArea() <<endl;
Tri.setWidth(5);
Tri.setHeight(7);
// Print the area of the object.
cout<<"Total Triangle area: " <<Tri.getArea() <<endl;
return0;
}

When the above code is compiled and executed, it produces the following result:
Total Rectangle area: 35

Total Triangle area: 17

Using Constructors and Destructors inDerived Classes

Base class initializer

Uses member-initializer syntax

Can be provided in the derived class constructor to call the base-class constructor explicitly
– Otherwise base class’ default constructor called implicitly
Base-class constructors and base-class assignment operators are not inherited by derived classes
– However, derived-class constructors and assignment operators can call still them Derived-class
constructor Calls the constructor for its base class first to initialize its base-class members
If the derived-class constructor is omitted, its default constructor calls the base-class’ default
constructor
Destructors are called in the reverse order of constructor calls.
Derived-class destructor is called before its base-class Destructor

Implicit Derived-Class Object to Base-Class Object Conversion

baseClassObject = derivedClassObject;
This will work
– Remember, the derived class object has more membersthan the base class object
Extra data is not given to the base class

derivedClassObject = baseClassObject;
May not work properly
– Unless an assignment operator is overloaded in the derived class, data members exclusive to
the derived class will be unassigned Base class has less data members than the derived class
– Some data members missing in the derived class object
Four ways to mix base and derived class pointers andobjects
Referring to a base-class object with a base-class pointer
– Allowed
40

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Referring to a derived-class object with a derived-class pointer

– Allowed
Referring to a derived-class object with a base-class pointer.
– Possible syntax error
– Code can only refer to base-class members, or syntax error
Referring to a base-class object with a derived-class pointer
– Syntax error
– The derived-class pointer must first be cast to a base-class Pointer

Composition vs. Inheritance

"is a" relationship
Inheritance
"has a" relationship
Composition - class has an object from another class as adata member
Employee “is a” BirthDate; //Wrong!

Employee “has a” Birthdate;//Composition

“Uses A” And “Knows A” Relationships
“uses a” relationship
One object issues a function call to a member
function of another object
“knows a” relationship
One object is aware of another
– Contains a pointer or handle to another object
Also called an association

Pointers to Member Functions and Pointers to Data Members

A class can have two general categories of members: functions and data
members. Similarly, there are two categories of pointers to members: pointers to member
functions, and pointers to data members. The latter are less common because you rarely have
direct access to data members. However, when using legacy C code with structs or classes have
public data members, pointers to data members might be useful.

Declaring Pointers to Data Members

The syntax of pointers to members might look confusing at first, but it's consistent. The syntax
resembles the form of ordinary pointers to functions, with the addition of the class name
followed by the operator ::. For example, if an ordinary pointer to int looks like this:

int * pi;
you define a pointer to an int member of class A like this:
class A{/**/};
int A::*pmi; // pmi is a pointer to an int member of A
You can initialize pmi like this:
class A
{
public:
41

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

intnum;
int x;
};
int A::*pmi = &A::num; // 1

Manipulating a data member through an object

The statement numbered 1 defines a pointer to an int member of class A and initializes it with
the address of num. Now you can use the pointer pmi to examine and modify num's value in
any object of class A:
A a1;
A a2;

int n = a1.*pmi; // copy the value of a1.num to n

a1.*pmi = 5; // assign the value to a1.num
a2.*pmi = 6; // assign the value 6 to a2.num

Manipulating a data member through an object's pointer

Similarly, you can access a data member through a pointer to A like this:
A * pa = new A;
int n = pa->*pmi; // assign to n the value of pa->num
pa->*pmi = 5; // assign the value 5 to pa->num
Or using a pointer to an object derived from A:
class D : public A {};
A* pd = new D;
pd->*pmi = 5; // assign the value 5 to pd->num

Declaring Pointers to Member Functions

Thus far, I've focused on pointers to data members, which are used less often than
pointers to member functions. A pointer to a member function consists of the member function's
return type, the class name followed by ::, the pointer's name, and the function's parameter list.
For example, a pointer to a member function of class A that returns int and takes no arguments
looks like this (note that both pairs of parentheses are mandatory):
class A
{
public:
intfunc ();
};
int (A::*pmf) (); /* pmf is a pointer to some member
function of class A that returns int and takes no
arguments*/

In fact, a pointer to a member function looks just like an ordinary pointer to function, except that
it also contains the class's name immediately followed by the :: operator. You can invoke the
member function to which pmf points like this:

42

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

pmf = &A::func; //assign pmf

A a;
A *pa = &a;
(a.*pmf)(); // invoke a.func()
// call through a pointer to an object
(pa->*pmf)(); // calls pa->func()

Pointers to member functions respect polymorphism; if you call a virtual member function
through a pointer to member, the call will be resolved dynamically as the following code
shows:

class Base
{
public:
virtualint f (int n);
};
class Derived : public Base {
public:
int f (int h); //override
};
Base *pb = new Derived;
int (Base::*pmf)(int) = &Base::f;
(pb->*pmf)(5); // call resolved as D::f(5);
Note that you cannot take the address of constructors and destructors.

The Underlying Representation of Pointers to Members

Although pointers to members behave like ordinary pointers, behind the scenes their
representation is quite different. In fact, a pointer to member usually consists of a structure
containing up to four fields in certain cases. This is because pointers to members have to support
not only ordinary member functions, but also virtual member functions, member functions of
objects that have multiple base classes, and member functions of virtual base classes. Thus, the
simplest member function can be represented as a set of two pointers: one holding the physical
memory address of the member function, and a second pointer that holds the this pointer.
However, in cases like a virtual member function, multiple inheritance and virtual inheritance,
the pointer to member must store additional information. Therefore, you can't cast pointers to
members to ordinary pointers nor can you safely cast between pointers to members of different
types.
To get a notion of how your compiler represents pointers to members, use the size of
operator. In the following example, the sizes of a pointer to data member and a pointer to a
member function are taken. As you can see, they have different sizes, hence, different
representations:

struct A
{
int x;
void f();
43

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

};
int A::*pmi = &A::x;
void (A::*pmf)() = &A::f;
int n = sizeof (pmi); // 8 byte with my compiler
int m = sizeof (pmf); // 12 bytes with my compiler
Note that each of these pointers may have a different representation, depending on the class
in question and whether the member function is virtual.

Function Overriding
If base class and derived class have member functions with same name and
arguments. If you create an object of derived class and write code to access that member function
then, the member function in derived class is only invoked, i.e., the member function of derived
class overrides the member function of base class. This feature in C++ programming is known as
function overriding.

Accessing

44

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Accessing the Overridden Function in Base Class From Derived Class

To access the overridden function of base class from derived class, scope resolution operator
::. For example: If you want to access get_data() function of base class from derived class in
above example then, the following statement is used in derived class.
A::get_data; // Calling get_data() of class A.
It is because, if the name of class is not specified, the compiler thinks get_data() function is
calling itself.

45

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

What is virtual function? Explain with an example.

A virtual function is a member function that is declared within a base class and
redefined by a derived class. To create virtual function, precede the function’s declaration in the
base class with the keyword virtual. When a class containing virtual function is inherited, the
derived class redefines the virtual function to suit its own needs.
Base class pointer can point to derived class object. In this case, using base class pointer if
we call some function which is in both classes, then base class function is invoked. But if we
want to invoke derived class function using base class pointer, it can be achieved by defining the
function as virtual in base class, this is how virtual functions support runtime polymorphism.
Consider following program code:

Class A
{
int a;
public:
A()
{
a = 1;
}
virtual void show()
46

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

{
cout<<a;
}
};
Class B: public A
{
int b;
public:
B()
{
b = 2;
}
virtual void show()
{
cout<<b;
}
};
int main()
{
A *pA;
B oB;
pA = &oB;
pA->show();
return 0;
}

Output is 2 since pA points to object of B and show() is virtual in base class A.

What is a virtual destructor? Explain the use of it.

If the destructor in the base class is not made virtual, then an object that might have been
declared of type base class and instance of child class would simply call the base class destructor
without calling the derived class destructor.
Hence, by making the destructor in the base class virtual, we ensure that the derived class
destructor gets called before the base class destructor.

class a
{
public:
a(){printf("\nBase Constructor\n");}
~a(){printf("\nBase Destructor\n");}
};
class b : public a
{
public:
b(){printf("\nDerived Constructor\n");}
~b(){printf("\nDerived Destructor\n");}
47

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

};
int main()
{
a* obj=new b;
delete obj;
return 0;
}
Output:
Base Constructor
Derived Constructor
Base Destructor
By Changing
~a(){printf("\nBase Destructor\n");}
to
virtual ~a(){printf("\nBase Destructor\n");}
Output:
Base Constructor
Derived Constructor
Derived Destructor
Base Destructor

UNIT III

3.1 Abstract Data Types (ADTs)

3.2 List ADT
3.2.1. Possible Operations on a List
3.2.2. List ADT Implementation 1
3.3 Array-based implementation
3.4 linked list implementation
3.5 singly linked lists
3.6 Polynomial Manipulation
3.7 Stack ADT
3.7.1. The stack ADT and its applications
3.7.2. Applications of stacks
3.7.3. Implementations of the stack ADT
3.7.3.1. Using static arrays
3.7.3.2. Using dynamic linked lists
3.8 Queue ADT
3.8.1. The queue ADT and its applications
3.8.2. Applications of queues
3.8.3. Implementations of the queue ADT
48

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

3.8.3.1. Using static arrays

3.9 Evaluating arithmetic expressions

3.1. Abstract data type

An abstract data type (ADT) is an object with a generic description independent of
implementation details.
This description includes a specification of the components from which the object is made and
also the behavioral details of the object. Thus in order to define an ADT we need to specify:
• The components of an object of the ADT.
• A set of procedures that provide the behavioral description of objects belonging to the ADT.

3.2. The List ADT

A list is a linear structure
• Each item except the first (front, head) has a unique predecessor
• Each item except the last (end, tail) has a unique successor
• First item has no predecessor, and last item has no successor
• An item within a list is specified by its position in the list

3.2.1. Possible Operations on a List

• List - Create an empty list
• isEmpty - Determine whether the list is empty
• isFull - Determine whether the list is full
• getLength - Return number of items in the list
• insert - Add an item to the list
• remove- Remove a specified item from list
retrieve - Get the list item at a specified pos’n

List ADT
• Often, we could just use an array
• May wish to separate what a list does from its implementation (abstraction)
• Allows for a variety of implementations:
• Fixed versus arbitrary capacity
• Array-based versus linked lists (later in course)
• More natural to work with than an array: first position is location 1 in a list, but at index 0 in
an array
3.2.2. List ADT Implementation 1
• We’ll store either simple types (int, char, etc) or pointers to simple types or to more complex
objects - to avoid copying complex objects
• Underlying structure is an array with a fixed maximum size remove and retrieve will return the
item at a specified position; precondition: the position must be one that currently exists in the list
• replace will change the item stored at a specified position, and return the displaced item;
precondition: the position must be one that currently exists in the list
• swap will change positions of 2 items stored at 2 specified positions, precondition: the positions
must currently exist in the list Adding an item to a list will change, at most, the predecessor of
one item and the successor of one item

49

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

• Removing an item will change, at most, the predecessor of one item and the successor of one
item
Add value 5 at loc 3 of the list 7,0,23,16,8,4 to get 7,0,5,23,16,8,4
Delete 1st item from 9,3,6,0,7 to get 3,6,0,7;
delete 3rd item from this list to get 3,6,7
code:
constint DEFAULT_LIST = 200;
template<class Item>
class List {
public:
List(unsigned capacity = DEFAULT_LIST);
~List( ); // destructor
boolisEmpty( ) const;
boolisFull( ) const;
unsignedgetLength( ) const;
void insert (unsigned pos, Item item);
Item remove (unsigned pos);
Item replace(unsigned pos, Item item );
Item retrieve (unsigned pos) const;
void swap (unsigned i, unsigned j);

replace() in the List ADT

• Replacing a value in a given list position can be accomplished by removing the current value,
and then inserting the new value at the same position
• This process can be inefficient, depending on the underlying list implementation. In our array-
based list, using remove and insert to replace a list item can be slow.
To replace first item:
removes shifts all following items one place left, and insert moves them back to original
positions :
1.replace() accomplishes the same task without all the shifting
2.swap(i,j) allows to switch positions of 2 Items without unnecessary shifting that would take
place if we used code (e.g. for List<Card> a)

Card tmp=a.remove(i); // assuming 1 <= j <i

a.insert(i-1,a.remove(j));
a.insert(j,tmp);
that achieves the same result very inefficiently

3.3. Array Based Implementation:

First, if we want to store letters, we can use type char. Next, since a stack usually holds a bunch
of items with the same type (e.g., char), we can use an array to hold the contents of the stack.
Now, consider how we'll use this array of characters, call it contents, to hold the contents of the
stack. At some point we'll have to decide how big this array is; keep in mind that a normal array
has a fixed size.
Let's choose the array to be of size 4 for now. So, an array getting A, then B, will look like:
50

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

-----------------
|A|B|||
-----------------
0123
contents
So, a sequence of pops produce the following effects:

1. letter = Pop(stack)
2. stack (made up of 'contents' and 'top')
3. ----------------- ----- -----
4. | A | B | | | | 1 | | C |
5. ----------------- ----- -----
6. 0 1 2 3 top letter
7. contents
8. letter = Pop(stack)
9. stack (made up of 'contents' and 'top')
10. ----------------- ----- -----
11. | A | | | | | 0 | | B |
12. ----------------- ----- -----
13. 0 1 2 3 top letter
14. contents
15. letter = Pop(stack)
16. stack (made up of 'contents' and 'top')
17. ----------------- ----- -----
18. | | | | | | -1| | A |
19. ----------------- ----- -----
20. 0 1 2 3 top letter
What happens if we apply the following set of operations?
1. Push(stack, 'D')
2. Push(stack, 'E')
3. Push(stack, 'F')
4. Push(stack, 'G')

3.4. linked lists Implementation:

Linked lists can be used for implementing queues. We plan to maintain a dummy node at
the beginning and two pointers, the first pointing to this dummy node and the second pointing to
the last element. Both insertion and deletion are easy at the beginning. Insertion is easy at the
end, but deletion is difficult at the end, since we have to move the pointer at the end one step
back and there is no way other than traversing the entire list in order to trace the new end. So the
natural choice is to take the beginning of the linked list as the front of the queue and the end of
the list as the back of the queue.
The corresponding implementation is detailed below:
typedefstruct _node {
char element;
51

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

struct _node *next;

} node;
typedefstruct {
node *front;
node *back;
} queue;
queueinit ()
{
queue Q;
/* Create the dummy node */
Q.front = (node *)malloc(sizeof(node));
Q.front -> element = ' ';
Q.front -> next = NULL;
Q.back = Q.front;
return Q;
}
intisEmpty ( queue Q )
{
return (Q.front == Q.back);
}
intisFull ( queue Q )
{
return 0;
}
char front ( queue Q )
{
if (isEmpty(Q)) {
fprintf(stderr,"front: Queue is empty\n");
return '\0';
}
returnQ.front -> element;
}
queueenqueue ( queue Q , char ch )
{
node *C;
if (isFull(Q)) {
fprintf(stderr,"enqueue: Queue is full\n");
return Q;
}

/* Create new node */

C = (node *)malloc(sizeof(node));
C -> element = ch;
C -> next = NULL;
52

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

/* Adjust the back of queue */

Q.back -> next = C;
Q.back = C;
return Q;
}
queuedequeue ( queue Q )
{
if (isEmpty(Q)) {
fprintf(stderr,"dequeue: Queue is empty\n");
return Q;
}
/* Make the front of the queue the new dummy node */
Q.front = Q.front -> next;
Q.front -> element = '\0';
return Q;
}
void print ( queue Q )
{
node *G;
G = Q.front -> next;
while (G != NULL) {
printf("%c", G -> element);
G = G -> next;
}
}
And here is the program with a main() identical to that for the array implementation.

3.5. A singly linked list class

The class definition for a node
#include <iostream>
#include <string>
using namespace std;
typedef string listType;
class node
{
public:
node (listType);
voidsetData (listType);
voidsetNext (node*);
listTypegetData () const;
node* getNext () const;
private:
listType data;
node* next;
};

53

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

The functions for the node class

#include "node.h"
node::node (listType it)
{
//pre-condition: it is the datum to be stored in the node
//post-condition: it gets stored in the node
data = it;
next = NULL;
}
void node::setData (listType it)
{
data = it;
}
void node::setNext (node* aNode)
{
next = aNode;
}
listType node::getData () const

{
return data;
}
node* node::getNext () const
{
return next;
}

The class definition for the linked list

#include "node.h"
class linked
{
public:
linked ();
linked (linked&);
linked (listType [], int);
~linked ();
intgetSize ();
voidaddOnEnd (listType);
voidinsertBefore (int, listType);
voiddeleteLink (int);
voidsetDataInLink (int, listType);
listTypegetNthData (int);
private:
node* head;
54

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

node* tail;
int size;
voiddeleteAll ();
node* getNthAddress (int);
voiddeleteWithOneNode ();
voiddeleteAtBeginning ();
voiddeleteLast ();
voiddeleteInMiddle (int);
};

3.6. Polynomial Multiplication Using Linked List

A polynomial expression can be represent as linked list. 4X^4 + 3x^2 + 7X is a polynomial
expression and its linked list representation is as follows.
+------------+ +-----------+ +---------------+
| 4 | 4 | -|--->| 3 | 2 | -|--->| 7 | 1 | NULL|
+------------+ +-----------+ +----------------+
Here, each node composed of co-efficient, exponent and a pointer to the next node.
Multiplication of polynomial expressions:
3X^3 + 4x^2 + 5X
X^4

Output is 3x^7 + 4X^6 + 5X^4

3.7. Stacks and queues

Stacks and queues are special kinds of ordered lists in which insertion and deletion are restricted
only to some specific positions. They are very important tools for solving many useful
computational problems. Since we have already implemented ordered lists in the most general
form, we can use these to implement stacks and queues. However, because of the special
insertion and deletion patterns for stacks and queues, the ADT functions can be written to be
much more efficient than the general functions. Given the importance of these new ADTs, it is
worthwhile to devote time to these special implementations.

3.7.1. The stack ADT and its applications

A stack is an ordered list of elements in which elements are always inserted and deleted at one
end, say the beginning. In the terminology of stacks, this end is called the top of the stack,
whereas the other end is called the bottom of the stack. Also the insertion operation is called
push and the deletion operation is called pop. The element at the top of a stack is frequently
referred, so we highlight this special form ofgetElement. A stack ADT can be specified by the
following basic operations. Once again we assume that we are maintaining a stack of characters.
In practice, the data type for each element of a stack can be of any data type. Characters are
chosen as place-holders for simplicity.
S = init();
Initialize S to an empty stack.
isEmpty(S);
Returns "true" if and only if the stack S is empty, i.e., contains no elements.
55

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

isFull(S);
//Returns "true" if and only if the stack S has a bounded size and holds the maximum
number
of elements it can.
top(S);
Return the element at the top of the stack S, or error if the stack is empty.
S = push(S,ch);
Push the character ch at the top of the stack S.
S = pop(S);
Pop an element from the top of the stack S.
print(S);

Print the elements of the stack S from top to bottom.

An element popped out of the stack is always the last element to have been pushed in.
Therefore, a stack is often called a Last-In-First-Out or a LIFO list.

3.7.2. Applications of stacks

Stacks are used in a variety of applications. While some of these applications are "natural", most
other are essentially "pedantic". Here is a list anyway.
• For processing nes ted structures, like checking for balanced parentheses, evaluation of postfix
expressions.
• For handling function calls and, in particular, recursion.
• For searching in special data structures (depth -first search in graphs and trees), for example,
for implementing backtracking.

3.7.3. Implementations of the stack ADT

A stack is specified by the ordered collection representing the content of the stack together with
the choice of the end of the collection to be treated as the top. The top should be so chosen that
pushing and popping can be made as far efficient as possible.

3.7.3.1. Using static arrays

Static arrays can realize stacks of a maximum possible size. If we assume that the stack elements
are stored in the array starting from the index 0, it is convenient to take the top as the maximum
index of an element in the array. Of course, the other choice, i.e., the other boundary 0, can in
principle be treated as the top, but insertions and deletions at the location 0 call for too many
relocations of array elements. So our original choice is definitely better.

3.7.3.2. Using dynamic linked lists

As we have seen earlier, it is no big deal to create and maintain a dynamic list of elements. The
only consideration now is to decide whether the beginning or the end of the list is to be treated as
the top of the stack. Deletion becomes costly, if we choose the end of the list as the top.
Choosing the beginning as the top makes the implementations of both push and pop easy. So we
stick to this convention. As usual, we maintain a dummy node at the top (beginning) for
simplifying certain operations.
56

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

3.8. The Queue ADT

A queue is like a "natural" queue of elements. It is an ordered list in which all insertions
occur at one end called the back or rear of the queue, whereas all deletions occur at the other
end called the front orhead of the queue.

3.8.1. The queue ADT and its applications

In the popular terminology, insertion and deletion in a queue are respectively called the
enqueue and the dequeue operations. The element dequeued from a queue is always the first to
have been enqueued among the elements currently present in the queue. In view of this, a queue
is often called a First-In-First-Out or a FIFO list.
The following functions specify the operations on the queue ADT. We are going to
maintain a queue of characters. In practice, each element of a queue can be of any well-defined
data type.
Q = init();
Initialize the queue Q to the empty queue.
isEmpty(Q);
Returns "true" if and only if the queue Q is empty.
isFull(Q);
Returns "true" if and only if the queue Q is full, provided that we impose a limit on the
maximum size of the queue.
front(Q);
Returns the element at the front of the queue Q or error if the queue is empty.
Q = enqueue(Q,ch);
Inserts the element ch at the back of the queue Q. Insertion request in a full queue should
lead
to failure together with some appropriate error messages.
Q = dequeue(Q);
Delete one element from the front of the queue Q. A dequeue attempt from an empty
queue
should lead to failure and appropriate error messages.
print(Q);
Print the elements of the queue Q from front to back

3.8.2. Applications of queues

• For implementing any "natural" FIFO service, like telephone enquiries, reservation requests,
traffic flow, etc.
• For implementing any "computational" FIFO service, for instance, to access some resources.

Examples: printer queues, disk queues, etc.

• F or searching in special data structures (breadth-first search in graphs and trees).
• For handling scheduling of processes in a multitasking operating system.

3.8.3. Implementations of the queue ADT

57

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Continuing with our standard practice followed so far, we are going to provide two
implementations of the queue ADT, the first using static memory, the second using dynamic
memory. The implementations aim at optimizing both the insertion and deletion operations.

3.8.3.1. Using static arrays

Recall that in our implementation of the "ordered list" ADT we always let the list start
from the array index 0. This calls for relocation of elements of the list in the supporting array
after certain operations (usually deletion). Now we plan to exploit the specific insertion and
deletion patterns in queues to avoid these costly relocations. We maintain two indices to
represent the front and the back of the queue. During an enqueue operation, the back index is
incremented and the new element is written in this location. For a dequeue operation, on the
other hand, the front is simply advanced by one position. It then follows that the entire queue
now moves down the array and the back index may hit the right end of the array, even when the
size of the queue is smaller than the capacity of the array. In order to avoid waste of space, we
allow our queue to wrap at the end. This means that after the back pointer reaches the end of the
array and needs to proceed further down the line, it comes back to the zeroth index, provided that
there is space at the beginning of the array to accommodate new elements. Thus, the array is now
treated as a circular one with index MAXLEN treated as 0,MAXLEN + 1 as 1, and so on. That
is, index calculation is done modulo MAXLEN. We still don't have to maintain the total queue
size. As soon as the back index attempts to collide with the front index modulo MAXLEN, the
array is considered to befull.
There is just one more problem to solve. A little thought reveals that under this wrap-
around technology, there is no difference between a full queue and an empty queue with respect
to arithmetic modulo MAXLEN. This problem can be tackled if we allow the queue to grow to a
maximum size of MAXLEN - 1. This means we are going to lose one available space, but that
loss is inconsequential. Now the condition for full array is that the front index is two locations
ahead of the back modulo MAXLEN, whereas the empty array is characterized by that the front
index is just one position ahead of the back again modulo MAXLEN. An implementation of the
queue ADT under these design principles is now given.
#define MAXLEN 100
typedefstruct {
char element[MAXLEN];
int front;
int back;
} queue;
queueinit ()
{
queue Q;
Q.front = 0;
Q.back = MAXLEN - 1;
return Q;
}
intisEmpty ( queue Q )
{
return (Q.front == (Q.back + 1) % MAXLEN);
58

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

}
intisFull ( queue Q )
{
return (Q.front == (Q.back + 2) % MAXLEN);
}
char front ( queue Q )
{
if (isEmpty(Q)) {
fprintf(stderr,"front: Queue is empty\n");
return '\0';
}
returnQ.element[Q.front];
}
queueenqueue ( queue Q , char ch )
{
if (isFull(Q)) {
fprintf(stderr,"enqueue: Queue is full\n");
return Q;
}
++Q.back;
if (Q.back == MAXLEN) Q.back = 0;
Q.element[Q.back] = ch;
return Q;
}
queuedequeue ( queue Q )
{
if (isEmpty(Q)) {
fprintf(stderr,"dequeue: Queue is empty\n");
return Q;
}
++Q.front;
if (Q.front == MAXLEN) Q.front = 0;
return Q;
}
void print ( queue Q )
{
inti;
if (isEmpty(Q)) return;
i = Q.front;
while (1) {
printf("%c", Q.element[i]);
if (i == Q.back) break;
if (++i == MAXLEN) i = 0;
}
}
Here is a sample main() for these functions.
59

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

int main ()
{
queue Q;
Q = init(); printf("Current queue : "); print(Q); printf("\n");
Q = enqueue(Q,'h'); printf("Current queue : "); print(Q); printf("\n");
Q = enqueue(Q,'w'); printf("Current queue : "); print(Q); printf("\n");
Q = enqueue(Q,'r'); printf("Current queue : "); print(Q); printf("\n");
Q = dequeue(Q); printf("Current queue : "); print(Q); printf("\n");
Q = dequeue(Q); printf("Current queue : "); print(Q); printf("\n");
Q = enqueue(Q,'c'); printf("Current queue : "); print(Q); printf("\n");
Q = dequeue(Q); printf("Current queue : "); print(Q); printf("\n");
Q = dequeue(Q); printf("Current queue : "); print(Q); printf("\n");
Q = dequeue(Q); printf("Current queue : "); print(Q); printf("\n");
}
Finally, this is the output of the complete program.
Current queue :
Current queue : h
Current queue :hw
Current queue :hwr
Current queue :wr
Current queue : r
Current queue :rc
Current queue : c
Current queue :
dequeue: Queue is empty
Current queue :

3.9. Evaluating arithmetic expressions

An example that demonstrated how to evaluate simple arithmetic expression such as
34 * 12. Now we are going to extend this problem to that of evaluating more complex arithmetic
expressions. Initially, we are going to see how to handle expressions like
20 - 3 * 6 + 2
Eventually we will extend the basic algorithm to also handle parentheses, making it possible to
evaluate expressions like
4 * ( 6 - 2 * (4 - 2))

Tokens
Because we are going to have to deal with inputs made up of many parts that have to be
processed in an algorithm, the first step is to transform our input into a collection of objects that
we can manipulate. If our input comes to us in the form of a String and the elements of the input
are properly separated by spaces, we can start by using the String class's split() method to split
the input String into an array of Strings.
This solves the problem of separating the input into individual elements we can
manipulate. We are also going to go one step further, turning each of these elements into an
object called a Token.

60

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Tokens come in three basic types: numbers, operators, and parentheses. Tokens of type
number have an associated numeric value, while operators will have an associated precedence
value.

The TokenStack class

The basic algorithm for handling arithmetic expressions without parentheses makes use
of a data structure called a stack. A stack is a container for a collection of data items. The data
items are organized as a stack, with the first item to enter the container at the bottom and the last
item at the top. When new items are added to the stack they are pushed onto the top of the stack.
Items can only be removed from the stack by popping them off the top of the stack. For this
algorithm the objects we are working with are Token objects, so we will need to construct a stack
that can hold Tokens.

The basic algorithm

We are now ready to see the basic algorithm for computing arithmetic statements without
parentheses. The algorithm makes use of two Token Stacks, a value stack and an operator stack.
The basic algorithm processes the tokens from the input in a simple left to right order. Any
number tokens that we encounter get pushed onto the value stack. When we encounter an
operator token, we will push it onto the operator stack. At various points in the algorithm we will
process an operator. We do this by popping the operator off of the operator stack and popping
two numbers off the value stack. We then apply the operator to the two numbers to produce a
result, package the result into a number token, and then push the number token back onto the top
of the value stack. After the processing is complete, we discard the operator token. The most
important logic in the evaluation algorithm tells us when to process the operators sitting on the
operator stack. This logic is driven in part by the precedence of the operators involved: the
operators + and - have a precedence of 1, while the operators * and / have a precedence of 2.
Here are the key elements of the evaluation algorithm.
• If we encounter an operator token in the input and the operator stack is empty, we push the
operator token onto the operator stack.
• If we encounter an operator token in the input with a precedence that is greater than the
precedence of the operator token at the top of the operator stack, we push the new operator token
onto the operator stack.
• If we encounter an operator token in the input with a precedence that is less than or equal to
the precedence of the operator token at the top of the operator stack, we process and remove the
operator at the top of the stack and then push the new operator token onto the operator stack.
• When we reach the end of the input, any operators that remain on the operator stack are
processed and removed until the operator stack is empty. At that point, there should be only one
number token left on the value stack: that number is the result of the evaluation.

An example
Here is an illustration of this algorithm in action. The expression we want to compute is
2+3*4-6
At the start of the algorithm both stacks are empty and the tokens are lined up in the input.

61

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

After handling the first three tokens we arrive at this configuration.

The next operator in the input has a higher precedence than the operator at the top of the
operator stack, so we push the next operator. The next number token also gets pushed on the
value stack.

62

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

The next operator in the input sequence has a precedence lower than that of the operator at
the top of the operator stack. This causes us to process and remove the operator at the top of
the operator stack.
Once

Once again, the operator in the input has a precendence equal to that of the operator at the top
of the operator stack, so we process and remove the operator from the operator stack.

63

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

At this point the operator stack is empty, so the operator token at the front of the input gets
pushed on the operator stack. The number token at the end of the input gets pushed on the
value stack.

Once the input has emptied out, we process any operators that remain on the operator stack.
Once all of those operators have been processed, the sole remaining number on the value
stack is the result of the computation.

64

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Handling parentheses
The algorithm outlined above can easily be extended to also handle parentheses correctly. All
that is required is a couple of additional rules.
• When we encounter a left parentheses token in the input, we push that token on the
operator stack.
• When we encounter a right parenthesis token in the input, we process operator s and
remove them from the top of the operator stack until a left parenthesis appears at the
top of the operator stack. We then pop off the left parenthesis token and discard both
of the parenthesis tokens.

65

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

UNIT IV

NON-LINEAR DATA STRUCTURES

4.1. Trees
4.2. Binary Trees
4.3. Binary tree representation and traversals
4.4. Application of trees
4.4.1. Set representation and Union
4.5. Find operations
4.6. Graph and its representations
4.7. Graph Traversals
4.8. Representation of Graphs
4.9. Breadth-first search
4.10. Depth-first search
4.11. Connected components.

4.1. TREE
a tree is a widely used abstract data type (ADT) or data structure implementing this ADT
that simulates a hierarchical tree structure, with a root value and subtrees of children, represented
as a set of linked nodes. A tree data structure can be defined recursively (locally) as a collection
of nodes (starting at a root node), where each node is a data structure consisting of a value,
together with a list of references to nodes (the "children"), with the constraints that no reference
is duplicated, and none points to the root. Alternatively, a tree can be defined abstractly as a
whole (globally) as an ordered tree, with a value assigned to each node. Both these perspectives
are useful: while a tree can be analyzed mathematically as a whole, when actually represented as
a data structure it is usually represented and worked with separately by node (rather than as a list
of nodes and an adjacency list of edges between nodes, as one may represent a digraph, for
instance). For example, looking at a tree as a whole, one can talk about "the parent node" of a
given node, but in general as a data structure a given node only contains the list of its children,
but does not contain a reference to its parent (if any). A simple unordered tree; in this diagram,
the node labeled 7 has two children, labeled 2 and 6, and one parent, labeled 2. The root node, at
the top, has no parent.

Definition
A tree is a non-linear data structure that consists of a root node and potentially many
levels of additional nodes that form a hierarchy. A tree can be empty with no nodes called the
null or empty tree or a tree is a structure consisting of one node called the root and one or more
subtrees.

Terminologies used in Trees

• Root - the top most node in a tree.
• Parent - the converse notion of child.
• Siblings - nodes with the same parent.
66

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

• Descendant - a node reachable by repeated proceeding from parent to child.

• Leaf - a node with no children.
• Internal node - a node with at least one child.
• Degree - number of sub trees of a node.
• Edge - connection between one node to another.
• Path - a sequence of nodes and edges connecting a node with a descendant.
• Level - The level of a node is defined by 1 + the number of connections between the
node and the root.
• Height - The height of a node is the length of the longest downward path between the
node and a leaf.
• Forest - A forest is a set of n ≥ 0 disjoint trees.

Binary tree

A simple binary tree of size 9 and height 3, with a root node whose value is 2. The above tree
is unbalanced and not sorted. In computer science, a binary tree is a treedata structure in which
each node has at most two children (referred to as the left child and the right child). In a binary
tree, the degree of each node can be at most two. Binary trees are used to implement binary
search trees and binary heaps, and are used for efficient searching and sorting. A binary tree is a
special case of a Kary tree, where k is 2.

Types of binary trees

67

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Tree rotations are very common internal operations on self-balancing binary trees.
A rooted binary tree is a tree with a root node in which every node has at most two children.
• A full binary tree (sometimes 2-tree or strictly binary tree) is a tree in which every node
other than the leaves has two children. A full tree is sometimes ambiguously defined as a perfect
tree. Physicists define a binary tree to mean a full binary tree.[1]
• A proper binary tree is an ordered tree in which each internal node has exactly two children.
• A perfect binary tree is a full binary tree in which all leaves have the same depth or same
level, and in which every parent has two children.[2] (This is ambiguously also called a complete
binary tree (see next).) An example of a perfect binary tree is the ancestry chart of a person to a
given depth, as each person has exactly two biological parents (one mother and one father); note
that this reverses the usual parent/child tree convention, and these trees go in the opposite
direction from usual (root at bottom).
• A complete binary tree is a binary tree in which every level, except possibly the last, is
completely filled, and all nodes are as far left as possible.[3] A tree is called an almost complete
binary tree or nearly complete binary tree if the exception holds, i.e. the last level is not
completely filled. This type of tree is used as a specialized data structure called a heap.
• An infinite complete binary tree is a tree with a countably infinite number of levels, in which
every node has two children, so that there are 2d nodes at level d. The set of all nodes is
countably infinite, but the set of all infinite paths from the root is uncountable, having the
cardinality of the continuum. These paths correspond by an order-preserving bijection to the
points of the Cantor set, or (using the example of a Stern–Brocot tree) to the set of positive
irrational numbers.
• A balanced binary tree is commonly defined as a binary tree in which the depth of the left
and right subtrees of every node differ by 1 or less,[4] although in general it is a binary tree
where no leaf is much farther away from the root than any other leaf. (Different balancing
schemes allow different definitions of "much farther".[5]) Binary trees that are balanced
according to this definition have a predictable depth (how many nodes are traversed from the
root to a leaf, counting the root as node 0 and subsequent nodes as 1, 2, ...,n). This depth (also
called the height) is equal to the integer part of log2(n), where n is the number of nodes on the
balanced tree. For example, for a balanced tree with only 1 node, log2(1) = 0, so the depth of the
tree is 0. For a balanced tree with 100 nodes, log2(100) = 6.64, so it has a depth of 6.
• A degenerate (or pathological) tree is a tree where each parent node has only one associated
child node. This means that performance-wise, the tree will behave like a linked list data
structure.
Note that this terminology often varies in the literature, especially with respect to the meaning of
"complete" and "full".

Properties of binary trees

• The number of nodes n in a perfect binary tree can be found using this formula: n = 2h+1-1
where h is the depth of the tree.
• The number of nodes n in a binary tree of height h is at least n = h + 1 and at most n = 2h+1-1
where h is the depth of the tree.
• The number of leaf nodes l in a perfect binary tree can be found using this formula: l = 2h
where h is the depth of the tree.

68

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

• The number of nodes n in a perfect binary tree can also be found using this formula: n = 2l-1
where l is the number of leaf nodes in the tree.
• The number of null links (i.e., absent children of nodes) in a complete binary tree of n nodes
is (n+1).
• The number of internal nodes (i.e., non -leaf nodes or n-l) in a complete binary tree of n
nodes is n/2 .
• For any non -empty binary tree with n0 leaf nodes and n2 nodes of degree 2, n0 = n2 + 1.[6]
Common operations
There are a variety of different operations that can be performed on binary trees. Some
are mutator operations, while others simply return useful information about the tree.
Insertion
Nodes can be inserted into binary trees in between two other nodes or added after a leaf node. In
binary trees, a node that is inserted is specified as to which child it is.
External nodes
Say that the external node being added onto is node A. To add a new node after node A, A
assigns the new node as one of its children and the new node assigns node A as its parent.

Internal nodes
The process of inserting a node into a binary tree Insertion on internal nodes is slightly more
complex than on external nodes. Say that the internal node is node A and that node B is the child
of A. (If the insertion is to insert a right child, then B is the right child of A, and similarly with a
left child insertion.) A assigns its child to the new node and the new node assigns its parent to A.
Then the new node assigns its child to B and B assigns its parent as the new node.
Deletion
Deletion is the process whereby a node is removed from the tree. Only certain nodes in a binary
tree can be removed unambiguously.[7]

Node with zero or one children

69

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

The process of deleting an internal node in a binary tree Say that the node to delete is node A. If
a node has no children (external node), deletion is accomplished by setting the child of A's parent
to null. If it has one child, set the parent of A's child to A's parent and set the child of A's parent
to A's child.
Node with two children
In a binary tree, a node with two children cannot be deleted unambiguously.[7] However, in
certain binary trees (including binary search trees) these nodes can be deleted, though with a
rearrangement of the tree structure.

Traversal
Pre-order, in-order, and post-order traversal visit each node in a tree by recursively visiting each
node in the left and right subtrees of the root.
Depth-first order
In depth-first order, we always attempt to visit the node farthest from the root node that we can,
but with the caveat that it must be a child of a node we have already visited. Unlike a depth-first
search on graphs, there is no need to remember all the nodes we have visited, because a tree
cannot contain cycles. Pre-order is a special case of this. See depth-first search for more
information.
Breadth-first order
Contrasting with depth-first order is breadth-first order, which always attempts to visit the node
closest to the root that it has not already visited. See breadth-first search for more information.
Also called a level-order traversal. In a complete binary tree, a node's breadth-index (i - (2d - 1))
can be used as traversal instructions from the root. Reading bitwise from left to right, starting at
bit d - 1, where d is the node's distance from the root (d = floor(log2(i+1))) and the node in
question is not the root itself (d > 0). When the breadth-index is masked at bit d - 1, the bit values
0 and 1 mean to step either left or right, respectively. The process continues by successively
checking the next bit to the right until there are no more. The rightmost bit indicates the final
traversal from the desired node's parent to the node itself. There is a time-space trade-off
between iterating a complete binary tree this way versus each node having pointer/s to its
sibling/s.

Encoding general trees as binary trees

There is a one-to-one mapping between general ordered trees and binary trees, which in
particular is used by Lisp to represent general ordered trees as binary trees. To convert a general
ordered tree to binary tree, we only need to represent the general tree in left child right sibling
way. The result of this representation will be automatically binary tree, if viewed from a different
perspective. Each node N in the ordered tree corresponds to a node N' in the binary tree; the left
child of N' is the node corresponding to the first child of N, and the right child of N' is the node
corresponding to N 's next sibling --- that is, the next node in order among the children of the
parent of N. This binary tree representation of a general order tree is sometimes also referred to
as a left child-right sibling binary tree (LCRS tree), or a doubly chained tree, or a Filial-Heir
chain. One way of thinking about this is that each node's children are in a linked list, chained
together with their right fields, and the node only has a pointer to the beginning or head of his
list, through its left field. For example, in the tree on the left, A has the 6 children
{B,C,D,E,F,G}. It can be converted into the binary tree on the right.
70

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

The binary tree can be thought of as the original tree tilted sideways, with the black left edges
representing first child and the blue right edges representing next sibling. The leaves of the tree
on the left would be written in Lisp as:
(((N O) I J) C D ((P) (Q)) F (M))
which would be implemented in memory as the binary tree on the right, without any letters on
those nodes that have a left child.

Binary Trees
 A binary tree is composed of zero or more nodes

empty (contain no nodes)

unique path

ain a value

71

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

ree has depth 4

and a right subtree

tree:
root, left, right

Preorder traversal
first
‟s a preorder traversal to print out all the elements in the binary tree:
public void preorderPrint(BinaryTreebt) {
if (bt == null) return;
System.out.println(bt.value);
preorderPrint(bt.leftChild);
preorderPrint(bt.rightChild);
72

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

}
Inorder traversal
in the middle
‟s an inorder traversal to print out all the elements in the binary tree:
public void inorderPrint(BinaryTreebt) {
if (bt == null) return;
inorderPrint(bt.leftChild);
System.out.println(bt.value);
inorderPrint(bt.rightChild);
}
Postorder traversal
ted last
‟s a postorder traversal to print out all the elements in the binary tree:
public void postorderPrint(BinaryTreebt) {
if (bt == null) return;
postorderPrint(bt.leftChild);
postorderPrint(bt.rightChild);
System.out.println(bt.value);
}

Graph and its representations

Graph is a data structure that consists of following two components:
1. A finite set of vertices also called as nodes.
2. A finite set of ordered pair of the form (u, v) called as edge. The pair is ordered because (u, v)
is not same as (v, u) in case of directed graph(di-graph). The pair of form (u, v) indicates that
there is an edge from vertex u to vertex v. The edges may contain weight/value/cost. Graphs are
used to represent many real life applications: Graphs are used to represent networks. The
networks may include paths in a city or telephone network or circuit network. Graphs are also
used in social networks like linkedIn, facebook. For example, in facebook, each person is
represented with a vertex(or node). Each node is a structure and contains information like person
id, name, gender and locale. Following is an example undirected graph with 5 vertices.

Following two are the most commonly used representations of graph.

1. Adjacency Matrix
2. Adjacency List
73

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

There are other representations also like, Incidence Matrix and Incidence List. The choice of the
graph representation is situation specific. It totally depends on the type of operations to be
performed and ease of use.
Adjacency Matrix:
Adjacency Matrix is a 2D array of size V x V where V is the number of vertices in a graph. Let
the 2D array be adj[][], a slot adj[i][j] = 1 indicates that there is an edge from vertex i to vertex j.
Adjacency matrix for undirected graph is always symmetric. Adjacency Matrix is also used to
represent weighted graphs. If adj[i][j] = w, then there is an edge from vertex i to vertex j with
weight w. The adjacency matrix for the above example graph is:

Adjacency Matrix Representation of the above graph

Pros: Representation is easier to implement and follow. Removing an edge takes O(1)
time. Queries like whether there is an edge from vertex „u‟ to vertex „v‟ are efficient and can be
done O(1).
Cons: Consumes more space O(V^2). Even if the graph is sparse(contains less number of
edges), it consumes the same space. Adding a vertex is O(V^2) time.

Adjacency List:
An array of linked lists is used. Size of the array is equal to number of vertices. Let the array
be array[]. An entry array[i] represents the linked list of vertices adjacent to the ith vertex.
This representation can also be used to represent a weighted graph. The weights of edges can
be stored in nodes of linked lists. Following is adjacency list representation of the above
graph.

Below is C code for adjacency list representation of an undirected graph:

// A C Program to demonstrate adjacency list representation of graphs
#include <stdio.h>

74

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

#include <stdlib.h>
// A structure to represent an adjacency list node
structAdjListNode
{
intdest;
structAdjListNode* next;
};
// A structure to represent an adjacency liat
structAdjList
{
structAdjListNode *head; // pointer to head node of list
};
// A structure to represent a graph. A graph is an array of adjacency lists.
// Size of array will be V (number of vertices in graph)
structGraph
{
intV;

structAdjList* array;
};
// A utility function to create a new adjacency list node
structAdjListNode* newAdjListNode(intdest)
{
structAdjListNode* newNode =
(structAdjListNode*) malloc(sizeof(structAdjListNode));
newNode->dest = dest;
newNode->next = NULL;
returnnewNode;
}
// A utility function that creates a graph of V vertices
structGraph* createGraph(intV)
{
structGraph* graph = (structGraph*) malloc(sizeof(structGraph));
graph->V = V;
// Create an array of adjacency lists. Size of array will be V
graph->array = (structAdjList*) malloc(V * sizeof(structAdjList));
// Initialize each adjacency list as empty by making head as NULL
inti;
for(i = 0; i< V; ++i)
graph->array[i].head = NULL;
returngraph;
}
// Adds an edge to an undirected graph
voidaddEdge(structGraph* graph, intsrc, intdest)

{
75

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

// Add an edge from src to dest. A new node is added to the adjacency
// list of src. The node is added at the begining
structAdjListNode* newNode = newAdjListNode(dest);
newNode->next = graph->array[src].head;
graph->array[src].head = newNode;
// Since graph is undirected, add an edge from dest to src also
newNode = newAdjListNode(src);
newNode->next = graph->array[dest].head;
graph->array[dest].head = newNode;
}
// A utility function to print the adjacenncy list representation of graph
voidprintGraph(structGraph* graph)
{
intv;
for(v = 0; v < graph->V; ++v)
{
structAdjListNode* pCrawl = graph->array[v].head;
printf("\n Adjacency list of vertex %d\n head ", v);
while(pCrawl)
{
printf("-> %d", pCrawl->dest);
pCrawl = pCrawl->next;
}
printf("\n");
}

}
// Driver program to test above functions
intmain()
{
// create the graph given in above fugure
intV = 5;
structGraph* graph = createGraph(V);
addEdge(graph, 0, 1);
addEdge(graph, 0, 4);
addEdge(graph, 1, 2);
addEdge(graph, 1, 3);
addEdge(graph, 1, 4);
addEdge(graph, 2, 3);
addEdge(graph, 3, 4);
// print the adjacency list representation of the above graph
printGraph(graph);
return0;
}
Output:
Adjacency list of vertex 0
76

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

head -> 4-> 1

Adjacency list of vertex 1
head -> 4-> 3-> 2-> 0
Adjacency list of vertex 2
head -> 3-> 1
Adjacency list of vertex 3
head -> 4-> 2-> 1
Adjacency list of vertex 4
head -> 3-> 1-> 0

Pros: Saves space O(|V|+|E|) . In the worst case, there can be C(V, 2) number of edges in
a graph thus consuming O(V^2) space. Adding a vertex is easier.
Cons: Queries like whether there is an edge from vertex u to vertex v are not efficient and
can be done O(V).

Graph Representations and Traversals

A directed graph G is an ordered pair (V, E ) consisting of a set of vertices or nodes V =
{v1,...,vn} and a set of edges or arcs E ⊆ V 2. Generally we denote the number of vertices by |V |
or nand the number of edges by |E | or m. Directed graphs are commonly represented as an
adjacency list, which comprises an array or list of vertices, where each vertex vi stores a list of
all the vertices vj for which there is an edge (vi, vj) ∈ E.
Another common representation is an adjacency matrix, which is a two-dimensional
array, where Ai j is non-zero when there is an edge (vi, vj) ∈ E. In practice, many graphs are
sparse in the sense that most of the possible edges between pairs of vertices do not exist, i.e. m
<< n2. In such cases the adjacency list is generally preferable to the adjacency matrix
representation. Edges can sometimes additionally have an integer weight, which can be used to
represent distances or costs.

Here is a simple directed graph with four vertices V = {1, 2, 3, 4} and four edges E = {(1, 2), (2,
3), (3, 1), (3, 4)}. Consider the following abstract data type for a directed graph with weighted
edges. Note that while this specification does not explicitly require any particular
implementation, the required running times of some of these functions constrain the
implementation in various ways. For instance, a naive adjacency matrix implementation would
take Θ(n2) time to consider every array entry in producing a list of all the edges. However the
edges function is required to do this in O(n + m) time.

77

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

(* A signature for directed graphs.*)

type graph (* A directed graph consisting of a set of vertices
* V and directed edges E with integer weights. *)
type vertex (* A vertex, or node, of the graph *)
type edge (* A edge of the graph *)
(* Creates an empty graph. *)
val create : unit -> graph
(* Returns the id of the specified vertex. *)
valvertex_id : vertex ->int
(* Compares two vertices, returning 0 if their ids are equal, -1 if
* the first has a smaller id, and +1 if first has a larger id.
* Suitable for comparators in sets and maps. *)
val compare : vertex -> vertex ->int
(* For an edge return (src, dst, w) where src is the source vertex of
* the edge, dst is the destination vertex, and w is the edge
* weight. *)
valedge_info : edge -> vertex * vertex * int
(* True if the given graph is empty (has no vertices).
* Run time O(1). *)
valis_empty : graph -> bool
(* A list of all vertices in the graph, without duplicates, in the order
* they were added.Run time: O(|V|). *)
val vertices : graph -> vertex list
(* A list of all vertices in the graph, without duplicates, in the order
* they were added.Run time: O(1). *)
valnum_vertices : graph ->int
(* A list of all edges in the graph, without duplicates.
* Run time: O(|V|+|E|). *)
val edges : graph -> edge list
(* A list of the edges leaving the vertex v.
* Run time: linear in the length of the result. *)

val outgoing : vertex -> edge list

(* A list of the edges coming in to the vertex v.
* Run time: linear in the length of the result. *)
val incoming : vertex -> edge list
(* The number of incoming edges for the specified vertex.
* Run time: O(1). *)
valin_degree : vertex ->int
(* The number of outgoing edges for the specified vertex.
* Run time: O(1). *)
valout_degree : vertex ->int
(* Adds a new isolated vertex (a vertex with no incident
* edges) to the specified graph, and returns that vertex.
* Run time: O(1). *)
78

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

valadd_vertex : graph -> vertex

(* Removes the specified vertex from the specified graph,
* along with all incident edges; that is, all edges that
* have the vertex as a source or destination.
* Run time: O(|E|).
* Note that the total time for removing all |V| vertices in the
* graph is also O(|E|) and not O(|V||E|). *)
valremove_vertex : graph -> vertex -> unit
(* add_edge (src, dst, w) adds an edge from src vertex to dst
* vertex with weight w.
* Run time: O(1). *)
valadd_edge : vertex * vertex * int -> unit

(* remove_edge (src, dst) removes the edge from src vertex to

* dst vertex, and has no effect if the edge does not exist.
* Run time: O(|E|). *)
valremove_edge : vertex * vertex -> unit
(* Creates and returns a copy of the graph.
* Run time: O(|V|+|E|). *)
val copy : graph -> graph
Note that the create function creates and returns an empty graph.
The add_vertex function takes a graph as argument, adds a new singleton vertex to that graph (a
vertex with no edges starting or ending at that vertex), and returns the new vertex. The function
add_edge takes two vertices and a weight and joins the vertices together by an edge. These are
all O(1) time operations. The abstraction also provides operations for getting the list of vertices
and edges of a graph, as well as the list of outgoing edges from a given vertex. There is also a
functionincoming_ref which returns a list of reversed edges, by taking all the incoming edges
for a given vertex and turning them into edges that go in the opposite direction. This function is
useful for exploring the back-edges in a graph (i.e., exploring the reversed graph where all the
edge directions are swapped). The Graph module in graph.ml implements this signature using
adjacency lists of vertices, where both the outgoing edge list and the incoming edge for each
vertex are explicitly represented. That is, each edge is stored twice, once at its source vertex and
once at its destination vertex. This makes it easy to traverse the edges of the graph in reverse,
which is useful for things like computing connected components (described below). In that
implementation, a graph is represented as a pair consisting of the number of vertices and a list of
vertices. A vertex is represented as a triple of a unique integer id, an outgoing list, and an
incoming list. The outgoing list is a list of pairs of destination vertex and weight. The incoming
vertex list is a list of pairs of source vertex and weight. Note that as each edge is stored twice, in
the incoming list of its destination and the outgoing list of its source, the weight must be
consistent in the two lists. In that implementation, an edge is a triple of a source vertex,
destination vertex and weight, and is constructed on the fly as needed from the vertex out lists
rather than being explicitly stored in the data structure.

Graph Traversals
One of the most basic graph operations is to traverse a graph, finding the nodes accessible
by following edges from some starting node. You have already seen this operation in CS2110.
79

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

We mark the vertices as visited when we have visited them to keep track of the parts of the graph
that we have already explored. We start with a single vertex and mark it as visited. We then
consider each outgoing edge. If an edge connects to an unvisited node, we put that node in a set
of nodes to explore. Then we repeatedly remove a node from the set, mark it as visited, and
repeat the process with that node. If we ever take a node out of the set and it is already marked as
visited, then we ignore it. The order in which we explore the vertices depends on how we
maintain the set of vertices to explore. If we use a queue, so the unvisited vertices are explored in
a first-infirst- out (FIFO) fashion, then the above traversal process it is known as breadth-first
search (BFS). If we use a stack, so the unvisited vertices are explored in a last-in-first-out (LIFO)
fashion, this is known asdepth-first search (DFS). Of course, such a traversal will only visit
nodes reachable from the start node by a directed path. Here is an implementation of traversal in
a directed graph using the above abstraction. This implementation makes use of a set of vertices
of type VSet to keep track of the visited vertices. It performs a BFS or DFS depending on
whether the Queue or Stack package is opened. It also can traverse either the edges of the graph
or of the ''reverse'' graph (in which all the edges have been reversed), based on the parameter

dir.moduleVSet = Set.Make (structtype t = Graph.vertex

let compare = Graph.compareend)
open Queue (* use Queue for BFS, Stack for DFS *)
let traverse v0 dir =
let disc = create()
and visited = ref VSet.emptyin
(* Expand the visited set to contain everything v goes to,
* and add newly seen vertices to the stack/queue. *)
let expand(v) =
lethandle_edge(e) =
let (v, v', _) = Graph.edge_info(e) in
if not (VSet.mem v' !visited)
then (visited := (VSet.add v' !visited);
push v' disc)
else ()
in
List.maphandle_edge (ifdir<0 then (Graph.incoming_rev v)
else (Graph.outgoing v))
in
(visited := VSet.add v0 !visited;
push v0 disc;
while (not (is_empty disc))
do ignore(expand(pop disc)) done;
!visited)

Connected Components
In an undirected graph, a connected component is the set of nodes that are reachable by
traversal from some node. The connected components of an undirected graph have the property
that all nodes in the component are reachable from all other nodes in the component. In a
directed graph, however, reachable usually means by a path in which all edges go in the positive
80

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

direction, i.e. from source to destination. In directed graphs, a vertex v may be reachable from u
but not vice-versa. For instance, for the graph above, the set of nodes reachable from any of the
nodes 1, 2, or 3 is the set {1, 2, 3, 4}, whereas the set of nodes reachable from node 4 is just the
singleton {4}. The strongly connected components in a directed graph are defined in terms of the
set of nodes that are mutually accessible from one another. In other words, the strongly
connected component of a node u is the set of all nodes v such that v is reachable from u by a
directed path and u is reachable from v by a directed path. Equivalently, u and v lie on a directed
cycle. One can show that this is an equivalence relation on nodes, and the strongly connected
components are the equivalence classes. For instance, the graph above has two strongly
connected components, namely {1, 2, 3} and {4}. It is possible to show that the strongly
connected component from a node vi can be found by searching for nodes that are accessible
from vi both in G and in Grev, where Grev has the same set of vertices as G, and has the reverse
of each edge in G. Thus the following simple algorithm finds the strongly connected
components.

letstrong_component v0 =
VSet.inter (traverse v0 1) (traverse v0 (-1))
letstrong_components g =
letvs = ref VSet.empty
andcs = ref [] in
(List.iter (function (v) ->vs :=VSet.add v !vs) (Graph.vertices g);
while (not (VSet.is_empty !vs)) do
let c = strong_component (VSet.choose !vs) in
(vs := VSet.diff !vs c;
cs := c::!cs)
done;
!cs)

Topological Ordering
In a directed acyclic graph (DAG), the nodes can be ordered such that each node in the
ordering comes before all the other nodes to which it has outbound edges. This is called a
topological sort of the graph. In general, there is not a unique topological order for a given DAG.
If there are cycles in the graph, there is no topological ordering. Topological orderings have
many uses for problems ranging from job scheduling to determining the order in which to
compute quantities that depend on one another (e.g., spreadsheets, order of compilation of
modules in OCaml). The following figure shows a DAG and a topological ordering for the

81

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

graph.

Here is a simple recursive function for computing a topological ordering, which operates by
choosing a vertex with no incoming edges as the first node in the ordering, and then appending
that to the result of recursively computing the ordering of the graph with that node removed. If in
this process there ever is a graph where all the nodes have incoming edges, then the graph is
cyclic and an error is raised. The running time of this method is O(n2), whereas the
asymptotically fastest methods are O(n + m).
lettopological_rec g =
letrectopological_destr gr =
letvl = Graph.vertices gr in
ifvl = [] then []
else
letsl = List.filter (function v ->Graph.in_degree v = 0) vlin
ifsl = [] (* No vertices without incoming edges *)
thenfailwith "Graph is cyclic"
else
let v = List.hdslin
(Graph.remove_vertex gr v;
v :: topological_destr gr) in
topological_destr (Graph.copy g)

Here is an iterative version of topological sort which has O(n + m) running time. Note that while
remove_vertex is O(m) time for a single vertex, it is also O(m) time when all n vertices of the
graph are removed, because each edge is considered a constant number of times overall in the
process of removing all the vertices.

lettopological_iter g =
let gr = Graph.copy g in
letsl = ref (List.filter
(function v ->Graph.in_degree v = 0)
(Graph.vertices gr))
andrevorder = ref [] in
82

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

while !sl<> [] do
let v = List.hd !slin
(sl := List.tl !sl;
List.iter
(function e ->
matchGraph.edge_info e with (_, dst, _) ->
ifGraph.in_degreedst = 1
thensl := dst :: !slelse ())
(Graph.outgoing v);
Graph.remove_vertex gr v;
revorder := v :: !revorder)
done;
ifGraph.num_vertices gr = 0
thenList.rev !revorder
(* Remaining vertices all with incoming edges *)
elsefailwith "Graph is cyclic"

83

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

UNIT V
SORTING and SEARCHING
5.1. Sorting algorithms
5.2. Insertion sort
5.2.1. Pseudo code for Insertion Sort
5.3. Quick sort
5.3.1. Pseudo code for Quick Sort
5.4. Merge sort
5.4.1. Pseudo code for Merge Sort
5.5. Searching
5.6. Linear search
5.6.1. Implementation
5.7. Binary Search
5.7.1. Characteristics

5.1. SORTING
Sorting is the process of placing elements from a collection in some kind of order. For
example, a list of words could be sorted alphabetically or by length. A list of cities could be
sorted by population, by area, or by zip code. We have already seen a number of algorithms that
were able to benefit from having a sorted list (recall the final anagram example and the binary
search). Sorting a large number of items can take a substantial amount of computing resources.
Like searching, the efficiency of a sorting algorithm is related to the number of items being
processed. For small collections, a complex sorting method may be more trouble than it is worth.
The overhead may be too high. On the other hand, for larger collections, we want to take
advantage of as many improvements as possible. In this section we will discuss several sorting
techniques and compare them with respect to their running time. Before getting into specific
algorithms, we should think about the operations that can be used to analyze a sorting process.
First, it will be necessary to compare two values to see which is smaller (or larger). In order to
sort a collection, it will be necessary to have some systematic way to compare values to see if
they are out of order. The total number of comparisons will be the most common way to measure
a sort procedure. Second, when values are not in the correct position with respect to one another,
it may be necessary to exchange them. This exchange is a costly operation and the total number
of exchanges will also be important for evaluating the overall efficiency of the algorithm.

5.2. The Insertion Sort

The insertion sort, although still (O(n^{2})\), works in a slightly different way. It always
maintains a sorted sublist in the lower positions of the list. Each new item is then “inserted” back
into the previous sublist such that the sorted sublist is one item larger. The figure below shows
the insertion sorting process. The shaded items represent the ordered sublists as the algorithm
makes each pass. We begin by assuming that a list with one item (position \(0\)) is already
84

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

sorted. On each pass, one for each item 1 through \(n-1\), the current item is checked against
those in the already sorted sublist. As we look back into the already sorted sublist, we shift those
items that are greater to the right. When we reach a smaller item or the end of the sublist, the
current item can be inserted. The figure below shows the fifth pass in detail. At this point in the
algorithm, a sorted sublist of five items consisting of 17, 26, 54, 77, and 93 exists. We want to
insert 31 back into the already sorted items. The first comparison against 93 causes 93 to be
shifted to the right. 77 and 54 are also shifted. When the item 26 is encountered, the shifting
process stops and 31 is placed in the open position. Now we have a sorted sublist of six items.
The implementation of insertionSort (ActiveCode 4) shows that there are again \(n- 1\)
passes to sort nitems. The iteration starts at position 1 and moves through position \(n-1\), as
these are the items that need to be inserted back into the sorted sublists. Line 8 performs the shift
operation that moves a value up one position in the list, making room behind it for the insertion.
Remember that this is not a complete exchange as was performed in the previous algorithms.

85

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

The maximum number of comparisons for an insertion sort is the sum of the first (n- 1\) integers.
Again, this is \(O(n^{2})\). However, in the best case, only one comparison needs to be done on
each pass. This would be the case for an already sorted list. One note about shifting versus
exchanging is also important. In general, a shift operation requires approximately a third of the
processing work of an exchange since only one assignment is performed. In benchmark studies,
insertion sort will show very good performance.

5.2.1. PSEUDOCODE for INSERTION SORT:

def insertionSort(alist):
for index in range(1,len(alist)):
currentvalue = alist[index]
position = index
while position>0 and alist[position-1]>currentvalue:
alist[position]=alist[position-1]
position = position-1
alist[position]=currentvalue
alist = [54,26,93,17,77,31,44,55,20]
insertionSort(alist)
print(alist)

5.3. Quick Sort

The quick sort uses divide and conquer to gain the same advantages as the merge sort,
while not using additional storage. As a trade-off, however, it is possible that the list may not be
divided in half. When this happens, we will see that performance is diminished. A quick sort first
selects a value, which is called the pivot value. Although there are many different ways to
choose the pivot value, we will simply use the first item in the list. The role of the pivot value is
to assist with splitting the list. The actual position where the pivot value belongs in the final
sorted list, commonly called the split point, will be used to divide the list for subsequent calls to
86

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

the quick sort. Figure shows that 54 will serve as our first pivot value. Since we have looked at
this example a few times already, we know that 54 will eventually end up in the position
currently holding 31.

87

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

The partitionprocess will happen next. It will find the split point and at the same time move
other items to the appropriate side of the list, either less than or greater than the pivot value.
Partitioning begins by locating two position markers—let’s call them leftmark and rightmark—at
the beginning and end of the remaining items in the list (positions 1 and 8 in Figure below. The
goal of the partition process is to move items that are on the wrong side with respect to the pivot
value while also converging on the split point. Figure above shows this process as we locate the
position of 54.

We begin by incrementing leftmark until we locate a value that is greater than the pivot value.
We then decrement rightmark until we find a value that is less than the pivot value. At this point
we have discovered two items that are out of place with respect to the eventual split point. For
our example, this occurs at 93 and 20. Now we can exchange these two items and then repeat the
process again. At the point where rightmark becomes less than leftmark, we stop. The position of
rightmark is now the split point. The pivot value can be exchanged with the contents of the split
point and the pivot value is now in place. In addition, all the items to the left of the split point are
less than the pivot value, and all the items to the right of the split point are greater than the pivot
value. The list can now be divided at the split point and the quick sort can be invoked recursively
on the two halves.

The quickSort function shown in CodeLens 7 invokes a recursive function,

quickSortHelper.quickSortHelper begins with the same base case as the merge sort. If the length
of the list is less than or equal to one, it is already sorted. If it is greater, then it can be partitioned
and recursively sorted. Thepartition function implements the process described earlier.

5.3.1. QUICK SORT for PSEUDOCODE:

def quickSort(alist):
quickSortHelper(alist,0,len(alist)-1)
def quickSortHelper(alist,first,last):
if first<last:
splitpoint = partition(alist,first,last)
quickSortHelper(alist,first,splitpoint-1)
quickSortHelper(alist,splitpoint+1,last)
def partition(alist,first,last):
pivotvalue = alist[first]
leftmark = first+1
88

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

rightmark = last
done = False
while not done:
while leftmark <= rightmark and \
alist[leftmark] <= pivotvalue:
leftmark = leftmark + 1
while alist[rightmark] >= pivotvalue and \
rightmark >= leftmark:
rightmark = rightmark -1
if rightmark < leftmark:
done = True
else:
temp = alist[leftmark]
alist[leftmark] = alist[rightmark]
alist[rightmark] = temp
temp = alist[first]
alist[first] = alist[rightmark]
alist[rightmark] = temp
return rightmark
alist = [54,26,93,17,77,31,44,55,20]
quickSort(alist)
print(alist)

5.4. Merge Sort

We now turn our attention to using a divide and conquer strategy as a way to improve the
performance of sorting algorithms. The first algorithm we will study is the merge sort. Merge
sort is a recursive algorithm that continually splits a list in half. If the list is empty or has one
item, it is sorted by definition (the base case). If the list has more than one item, we split the list
and recursively invoke a merge sort on both halves. Once the two halves are sorted, the
fundamental operation, called a merge, is performed. Merging is the process of taking two
smaller sorted lists and combining them together into a single, sorted, new list. Figure below
shows our familiar example list as it is being split by mergeSort. figure 4shows the simple lists,
now sorted, as they are merged back together. The mergeSort function shown in ActiveCode 6
begins by asking the base case question. If the length of the list is less than or equal to one, then
we already have a sorted list and no more processing is necessary. If, on the other hand, the
length is greater than one, then we use the Python slice operation to extract the left and right
halves. It is important to note that the list may not have an even number of items. That does not
matter, as the lengths will differ by at most one.

89

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

5.4.1. MERGE SORT for PSEUDOCODE:

def mergeSort(alist):
print("Splitting ",alist)
if len(alist)>1:
90

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

mid = len(alist)//2
lefthalf = alist[:mid]
righthalf = alist[mid:]
mergeSort(lefthalf)
mergeSort(righthalf)
i=0
j=0
k=0
while i<len(lefthalf) and j<len(righthalf):
if lefthalf[i]<righthalf[j]:
alist[k]=righthalf[j]
j=j+1
k=k+1
while i<len(lefthalf):
alist[k]=lefthalf[i]
i=i+1
k=k+1
while j<len(righthalf):
alist[k]=righthalf[j]
j=j+1
k=k+1
print("Merging ",alist)
alist = [54,26,93,17,77,31,44,55,20]
mergeSort(alist)
print(alist)

5.5. Searching
Computer systems are often used to store large amounts of data from which individual
records must be retrieved according to some search criterion. Thus the efficient storage of data to
facilitate fast searching is an important issue. In this section, we shall investigate the
performance of some searching algorithms and the data structures which they use.

5.6. Linear search

A linear search is the most basic of search algorithm you can have. A linear search
sequentially moves through your collection (or data structure) looking for a matching value.

5.6.1. Implementation

#include<iostream>
using namespace std;

int main() {
cout<<"Enter The Size Of Array: ";
int size;
cin>>size;

91

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

int array[size], key,i;

// Taking Input In Array

for(int j=0;j<size;j++){
cout<<"Enter "<<j<<" Element: ";
cin>>array[j];
}

//Your Entered Array Is

for(int a=0;a<size;a++){
cout<<"array[ "<<a<<" ] = ";
cout<<array[a]<<endl;
}

cout<<"Enter Key To Search in Array";

cin>>key;

for(i=0;i<size;i++){
if(key==array[i]){
cout<<"Key Found At Index Number : "<<i<<endl;
break;
}
}

if(i != size){
cout<<"KEY FOUND at index : "<<i;
}
else{
cout<<"KEY NOT FOUND in Array ";
}
return 0;
}

Image View Of Code:

92

Visit : www.EasyEngineeering.net
Visit : www.EasyEngineeering.net

93

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Sample Output:

What is Linear Search In C++ Code Example Sample Output

Code Logic Explanation:

94

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

 To Make Logic First We Think That We Have To Traverse Whole Array Form Start
To End So we Decide To Use a Loop
 First for Loop Taking Input in Array Element By Element Second Displaying Entered
Elements
 Third for Loop Which is Main For Loop Having an if Condition Which Checks Every
Array Element with Key
 If an Element Matches With Key if Condition Becomes True and Loop Terminates
With Break Statement
 Then If Condition Outside Loop Which Will Become True Because Loop Variable 'i'
not Equal to Size Of Array
 If Element Not Found In Array Than Loop Will Run Complete And If Condition Will
Not True Because in This Case Loop Will Run Complete And After Termination
Variable 'i' Will be Equal to Size Variable

Running The Code With Sample Input

Let size=5;

Array Elements are

1
2
3
4
5

Key is equal to 4
3rd for loop comparisons

i=0
if(1==4) false

i=1
if(2==4) false

i=2
if(3==4) false

i=3
if(4==4) True
break for loop

Output:
Key Found At Index Number : 3

95

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

5.7. Binary Search

If we place our items in an array and sort them in either ascending or descending order on
the key first, then we can obtain much better performance with an algorithm called binary
search. In binary search, we first compare the key with the item in the middle position of the
array. If there's a match, we can return immediately. If the key is less than the middle key, then
the item sought must lie in the lower half of the array; if it's greater then the item sought must lie
in the upper half of the array. So we repeat the procedure on the lower (or upper) half of the
array.
Our FindInCollection function can now be implemented:
static void *bin_search( collection c, int low, int high, void *key ) {
int mid;
/* Termination check */
if (low > high) return NULL;
mid = (high+low)/2;
switch (memcmp(ItemKey(c->items[mid]),key,c->size)) {
/* Match, return item found */
case 0: return c->items[mid];
/* key is less than mid, search lower half */
case -1: return bin_search( c, low, mid-1, key);
/* key is greater than mid, search upper half */
case 1: return bin_search( c, mid+1, high, key );
default : return NULL;
}
}
void *FindInCollection( collection c, void *key ) {
/* Find an item in a collection
Pre-condition:
c is a collection created by ConsCollection
c is sorted in ascending order of the key
key != NULL
Post-condition: returns an item identified by key if
one exists, otherwise returns NULL
*/
int low, high;
low = 0; high = c->item_cnt-1;
return bin_search( c, low, high, key );
}
Points to note:
a. bin_search is recursive: it determines whether the search key lies in the lower or upper half of
the array, then calls itself on the appropriate half.
b. There is a termination condition (two of them in fact!) i. If low > high then the partition to be
searched has no elements in it and
ii. If there is a match with the element in the middle of the current partition, then we can return
immediately.

96

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

c. AddToCollection will need to be modified to ensure that each item added is placed in its
correct place in the array.
The procedure is simple:
i. Search the array until the correct spot to insert the new item is found,
ii. Move all the following items up one position and
iii. Insert the new item into the empty position thus created.
bin_search is declared static. It is a local function and is not used outside this class: if it were not
declared static, it would be exported and be available to all parts of the program. The static
declaration also allows other classes to use the same name internally.
A technique for searching an ordered list in which we first check the middle item and – based on
that comparison - "discard" half the data. The same procedure is then applied to the remaining
half until a match is found or there are no more items left.

5.7.1. Characteristics
The worst case performance scenario for a linear search is that it needs to loop through the entire
collection; either because the item is the last one, or because the item isn't found. In other words,
if you have N items in your collection, the worst case scenario to find an item is N iterations.
This is known as O(N) using the Big O Notation. The speed of search grows linearly with the
number of items within your collection. Linear searches don't require the collection to be sorted.
In some cases, you'll know ahead of time that some items will be disproportionally searched for.
In such situations, frequently requested items can be kept at the start of the collection. This can
result in exceptional performance, regardless of size, for these frequently requested items.
Linear Search 1
Problem:
Given a list of N values, determine whether a given value X occurs in the list.
1 2 3 4 5 6 7 8 17 31 9 73 55 12 19 7
For example, consider the problem of determining whether the value 55 occurs in:
There is an obvious, correct algorithm:
start at one end of the list, if the current element doesn't equal the search target,
move to the next element, stopping when a match is found or the opposite end of the list is
reached.
Basic principle: divide the list into the current element and everything before (or after) it;
if current isn't a match, search the other case algorithm Linear Search takes number X, list
number L, number Sz
# Determines whether the value X occurs within the list L.
# Pre: L must be initialized to hold exactly Sz values
## Walk from the upper end of the list toward the lower end,
# looking for a match:
while
Sz > 0 AND L[Sz] != X
Sz := Sz - 1
endwhile
if Sz > 0
# See if we walked off the front of the list display true
# if so, no match else display false
# if not, got a match
97

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

Halt

Glossary

abstract class: A class primarily intended to define an instance, but can not be instantiated without
additional methods.

abstract data type: An abstraction that describes a set of items in terms of a hidden data structure and
operations on that structure.

abstraction: A mental facility that permits one to view problems with varying degrees of detail
depending on the current context of the problem.

accessor: A public member subprogram that provides query access to a private data member.

actor: An object that initiates behavior in other objects, but cannot be acted upon itself.

agent: An object that can both initiate behavior in other objects, as well as be operated upon by other
objects.

ADT: Abstract data type.

AKO: A Kind Of. The inheritance relationship between classes and their superclasses.

allocatable array: A named array having the ability to dynamically obtain memory. Only when space
has been allocated for it does it have a shape and may it be referenced or defined.

argument: A value, variable, or expression that provides input to a subprogram.

array: An ordered collection that is indexed.

array constructor: A means of creating a part of an array by a single statement.

array overflow: An attempt to access an array element with a subscript outside the array size bounds.

array pointer: A pointer whose target is an array, or an array section.

array section: A subobject that is an array and is not a defined type component.

assertion: A programming means to cope with errors and exceptions.

assignment operator: The equal symbol, “=”, which may be overloaded by a user.

assignment statement: A statement of the form “variable = expression”.

98

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

association: Host association, name association, pointer association, or storage association.

attribute: A property of a variable that may be specified in a type declaration statement.

automatic array: An explicit-shape array in a procedure, which is not a dummy argument, some or all
of whose bounds are provided when the procedure is invoked.

base class: A previously defined class whose public members can be inherited by another class. (Also
called a super class.)

behavior sharing: A form of polymorphism, when multiple entities have the same generic interface.
This is achieved by inheritance or operator overloading.

binary operator: An operator that takes two operands.

bintree: A tree structure where each node has two child nodes.

browser: A tool to find all occurrences of a variable, object, or component in a source code.

call-by-reference: A language mechanism that supplies an argument to a procedure by passing the

address of the argument rather than its value. If it is modified, the new value will also take effect
outside of the procedure.

call-by-value: A language mechanism that supplies an argument to a procedure by passing a copy of

its data value. If it is modified, the new value will not take effect outside of the procedure that modifies it.

class: An abstraction of an object that specifies the static and behavioral characteristics of it, including
their public and private nature. A class is an ADT with a constructor template from which object
instances are created.

class attribute: An attribute whose value is common to a class of objects rather than a value peculiar to
each instance of the class.

class descriptor: An object representing a class, containing a list of its attributes and methods as well
as the values of any class attributes.

class diagram: A diagram depicting classes, their internal structure and operations, and the fixed
relationships between them.

class inheritance: Defining a new derived class in terms of one or more base classes.

client: A software component that users services from another supplier class.

concrete class: A class having no abstract operations and can be instantiated.

compiler: Software that translates a high-level language into machine language.

component: A data member of a defined type within a class declaration

constructor: An operation, by a class member function, that initializes a newly created instance of a
99

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

class. (See default and intrinsic constructor.)

constructor operations: Methods which create and initialize the state of an object.

container class: A class whose instances are container objects. Examples include sets, arrays, and
stacks.

container object: An object that stores a collection of other objects and provides operations to access or
iterate over them.

control variable: The variable which controls the number of loop executions.

data abstraction: The ability to create new data types, together with associated operators, and to hide
the internal structure and operations from the user, thus allowing the new data type to be used in a
fashion analogous to intrinsic data types.

data hiding: The concept that some variables and/or operations in a module may not be accessible to a
user of that module; a key element of data abstraction.

data member: A public data attribute, or instance variable, in a class declaration.

data type: A named category of data that is characterized by a set of values. together with a way to
denote these values and a collection of operations that interpret and manipulate the values. For an
intrinsic type, the set of data values depends on the values of the type parameters.

deallocation statement: A statement which releases dynamic memory that has been previously allocated
to an allocatable array or a pointer.

debugger software: A program that allows one to execute a program in segments up to selected
breakpoints, and to observe the program variables.

debugging: The process of detecting, locating, and correcting errors in software.

declaration statement: A statement which specifies the type and, optionally, attributes of one or more
variables or constants.

default constructor: A class member function with no arguments that assigns default initial values to
all data members in a newly created instance of a class.

defined operator: An operator that is not an intrinsic operator and is defined by a subprogram that is
associated with a generic identifier.

deque: A container that supports inserts or removals from either end of a queue.

dereferencing: The interpretation of a pointer as the target to which it is pointing.

derived attribute: An attribute that is determined from other attributes.

derived class: A class whose declaration indicates that it is to inherit the publicmembers of a previously
defined base class.
100

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

derived type: A user defined data type with components, each of which is either of intrinsic type or of
another derived type.

destructor: An operation that cleans up an existing instance of a class that is no longer needed.

destructor operations: Methods which destroy objects and reclaim their dynamic memory.

domain: The set over which a function or relation is defined.

dummy argument: An argument in a procedure definition which will be associated with the actual
(reference or value) argument when the procedure is invoked.

dummy array: A dummy argument that is an array.

dummy pointer: A dummy argument that is a pointer.

dummy procedure: A dummy argument that is specified or referenced as a procedure.

dynamic binding: The allocation of storage at run time rather than compile time, or the run time
association of an object and one of its generic operations..

edit descriptor: An item in an input/output format which specifies the conversion between internal and
external forms.

encapsulation: A modeling and implementation technique (information hiding) that separates the
external aspects of an object from the internal, implementation details of the object.

exception: An unexpected error condition causing an interruption to the normal flow of program control.

explicit interface: For a procedure referenced in a scoping unit, the property of being an internal
procedure, a module procedure, an external procedure that has an interface (prototype) block, a recursive
procedure reference in its own scoping unit, or a dummy procedure that has an interface block.

explicit shape array: A named array that is declared with explicit bounds.

external file: A sequence of records that exists in a medium external to the program.

external procedure: A procedure that is defined by an external subprogram.

FIFO: First in, first out storage; a queue.

friend: A method, in C++, which is allowed privileged access to the private implementation of another
object.

function body: A block of statements that manipulate parameters to accomplish the subprogram’s
purpose.

function definition: Program unit that associates with a subprogram name a return type, a list of
arguments, and a sequence of statements thatmanipulate the arguments to accomplish the subprogram’s
101

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

purpose

function header: A line of code at the beginning of a function definition; includes the argument list, and
the function return variable name.

generic function: A function which can be called with different types of arguments.

generic identifier: A lexical token that appears in an INTERFACE statement and is associated with all
the procedures in the interface block.

generic interface block: A form of interface block which is used to define a generic name for a set of
procedures.

generic name: A name used to identify two or more procedures, the required one being determined by
the types of the non-optional arguments in the procedure invocation.

generic operator: An operator which can be invoked with different types of operands.

Has-A: A relationship in which the derived class has a property of the base class.

hashing technique: A technique used to create a hash table, in which the array element where an item
is to be stored is determined by converting some item feature into an integer in the range of the size of the
table.

heap: A region of memory used for data structures dynamically allocated and de-allocated by a program.

host: The program unit containing a lower (hosted) internal procedure.

host association: Data, and variables automatically available to an internal procedure from its host.

information hiding: The principle that the state and implementation of an object should be private to
that object and only accessible via its public interface.

inheritance: The relationship between classes whereby one class inherits part or all of the public
description of another base class, and instances inherit all the properties and methods of the classes
which they contain.

instance: A individual example of a class invoked via a class constructor.

instance diagram: A drawing showing the instance connection between two objects along with the
number or range of mapping that may occur.

instantiation: The process of creating (giving a value to) instances from classes.

intent: An attribute of a dummy argument that which indicates whether it may be used to transfer data
into the procedure, out of the procedure, or both.

interaction diagram: A diagram that shows the flow of requests, or messages between objects.
interface: The set of all signatures (public methods) defined for an object.

102

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

internal file: A character string that is used to transfer and/or convert data from one internal storage
mode to a different internal storage mode.

internal procedure: A procedure contained within another program unit, or class, and which can only
be invoked from within that program unit, or class.

internal subprogram: A subprogram contained in a main program or another subprogram.

intrinsic constructor: A class member function with the same name as the class which receives initial
values of all the data members as arguments.

Is-A: A relationship in which the derived class is a variation of the base class.

iterator: A method that permits all parts of a data structure to be visited.

keyword: A programming language word already defined and reserved for a single special purpose.

LIFO: Last in, first out storage; a stack.

link: The process of combining compiled program units to form an executable program.

linked list: A data structure in which each element identifies its predecessor and/or successor by some
form of pointer.

linker: Software that combines object files to create an executable machine language program.

list: An ordered collection that is not indexed.

map: An indexed collection that may be ordered.

matrix: A rank-two array.

member data: Variables declared as components of a defined type and encapsulated in a class.

member function: Subprograms encapsulated as members of a class.

method: A class member function encapsulated with its class data members.

method resolution: The process of matching a generic operation on an object to the unique method
appropriate to the object’s class.

message: A request, from another object, for an object to carry out one of its operations.

message passing: The philosophy that objects only interact by sending messages to each other that
request some operations to be performed.

module: A program unit which allows other program units to access variables, derived type definitions,
classes and procedures declared within it by USE association.

module procedure: A procedure which is contained within a module, and usually used to define generic
103

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

interfaces, and/or to overload or define operators.

nested: Placement of a control structure inside another control structure.

object: A concept, or thing with crisp boundaries and meanings for the problem at hand; an instance of a
class.

object diagram: A graphical representation of an object model showing relationships, attributes, and
operations.

object-oriented (OO): A software development strategy that organizes software as a collection of objects
that contain both data structure and behavior. (Abbreviated OO.)

object-oriented programming (OOP): Object-oriented programs are object-based, class-based, support

inheritance between classes and base classes and allow objects to send and receive messages.

object-oriented programming language: A language that supports objects (encapsulating identity,

data, and operations), method resolution, and inheritance.

octree: A tree structure where each node has eight child nodes.

OO (acronym): Object-oriented.

operand: An expression or variable that precedes or succeeds an operator.

operation: Manipulation of an object’s data by its member function when it receives a request.

operator overloading: A special case of polymorphism; attaching more than one meaning to the same
operator symbol. ‘Overloading’ is also sometimes used to indicate using the same name for different
objects.

overflow: An error condition arising from an attempt to store a number which is too large for the storage
location specified; typically caused by an attempt to divide by zero.

overloading: Using the same name for multiple functions or operators in a single scope.

overriding: The ability to change the definition of an inherited method or attribute in a subclass.

parameterized classes: A template for creating real classes that may differ in well-defined ways as
specified by parameters at the time of creation. The parameters are often data types or classes, but
may include other attributes, such as the size of a collection. (Also called generic classes.)

pass-by-reference: Method of passing an argument that permits the function to refer to the memory
holding the original copy of the argument

pass-by-value: Method of passing an argument that evaluates the argument and stores this value in the
corresponding formal argument, so the function has its own copy of the argument value

pointer: A single data object which stands for another (a “target”), which may be a compound object
such as an array, or defined type.
104

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

pointer array: An array which is declared with the pointer attribute. Its shape and size may not be
determined until they are created for the array by means of a memory allocation statement.

pointer assignment statement: A statement of the form “pointer-name) target”.

polymorphism: The ability of an function/operator, with one name, to refer to arguments, or return
types, of different classes at run time.

post-condition: Specifies what must be true after the execution of an operation.

pre-condition: Specifies the condition(s) that must be true before an operation can be executed.

private: That part of an class, methods or attributes, which may not be accessed by other classes, only
by instances of that class.

protected: (Referring to an attribute or operation of a class in C++) accessible by methods of any

descendent of the current class.

prototype: A statement declaring a function’s return type, name, and list of argument types.

pseudocode: A language of structured English statements used in designing a step-by-step approach to

solving a problem.

public: That part of an object, methods or attributes, which may be accessed by other objects, and thus
constitutes its interface.

quadtree: A tree structure where each tree node has four child nodes.

query operation: An operation that returns a value without modifying any objects.

rank: Number of subscripted variables an array has. A scalar has rank zero, a vector has rank one, a
matrix has rank two.

scope: That part of an executable program within which a lexical token (name) has a single interpretation.

section: Part of an array.

sequential: A kind of file in which each record is written (read) after the previously written (read) record.

server: An object that can only be operated upon by other objects.

service: A class member function encapsulated with its class data members.

shape: The rank of an array and the extent of each of its subscripts. Often stored in a rank-one array.

side effect: A change in a variable’s value as a result of using it as an operand, or argument.

signature: The combination of a subprogram’s (operator’s) name and its argument (operand) types.
Does not include function result types.
105

Visit : www.EasyEngineeering.net
 Visit : www.EasyEngineeering.net

size: The total number of elements in an array.

stack: Region of memory used for allocation of function data areas; allocation of variables on the stack
occurs automatically when a block is entered, and deallocation occurs when the block is exited

stride: The increment used in a subscript triplet.

strong typing: The property of a programming language such that the type of each variable must be
declared.

structure component: The part of a data object of derived type corresponding to a component of its
type.

sub-object: A portion of a data object that may be referenced or defined independently of other portions.
It may be an array element, an array section, a structure component, or a substring.

subprogram: A function or subroutine subprogram.

subprogram header: A block of code at the beginning of a subprogram definition; includes the name,
and the argument list, if any.

subscript triplet: A method of specifying an array section by means of the initial and final subscript
integer values and an optional stride (or increment).

super class: A class from which another class inherits. (See base class.)

supplier: Software component that implements a new class with services to be used by a client software
component.

target: The data object pointed to by a pointer, or reference variable.

template: An abstract recipe with parameters for producing concrete code for class definitions or
subprogram definitions.

thread: The basic entity to which the operating system allocates CPU time.

tree: A form of linked list in which each node points to at least two other nodes, thus defining a dynamic
data structure.

unary operator: An operator which has only one operand.

undefined: A data object which does not have a defined value.

underflow: An error condition where a number is too close to zero to be distinguished from zero in the
floating-point representation being used.

utility function: A private subprogram that can only be used within its defining class.

vector: A rank-one array. An array with one subscript.

106

Visit : www.EasyEngineeering.net