AD3251 DATA STRUCTURES DESIGN

UNIT I ABSTRACT DATA TYPES

Abstract Data Types (ADTs) – ADTs and classes – introduction to OOP – classes in Python –
inheritance – namespaces – shallow and deep copying Introduction to analysis of algorithms –
asymptotic notations – recursion – analyzing recursive algorithms

Abstract Data Types (ADTs)

An ADT is a mathematical model of a data structure that specifies the type of data
stored, the operations supported on them, and the types of parameters of the operations. An ADT
specifies what each operation does, but not how it does it.
Python supports abstract data types using a mechanism known as an abstract base class
(ABC).
Some examples of ADT are Stack, Queue, List etc. Let us see
some operations of those mentioned ADT −

 Stack − A stack is an abstract data type that stores elements in a lastin-first- out (LIFO)
order. Elements are added and removed to/from the top only.
 Queue − A queue is an abstract data type that stores elements in a first-in- first-out
order. Elements are added at one end and removed from the other.
 List − A list is an abstract data type that implements an ordered collection of values,
where the same value may occur more than once
ADTs and classes Class
Definitions
A class serves as the primary means for abstraction in object-oriented programming.A
class provides a set of behaviors in the form of member functions (also known as methods), with
implementations that are common to all instances of that class.
A class also serves as a blueprint for its instances, effectively determining the way that
state information for each instance is represented in the form of attributes

Example: CreditCard Class

class CreditCard:
def init (self, customer, bank, acnt, limit): self.
customer = customer
self. bank = bank
 self. account = acnt
self. limit = limit self.
balance = 0
def get customer(self):
return self. customer
def get bank(self):
return self. bank
def get account(self):
return self. account
def get limit(self): return
self. limit
def get balance(self):
return self. Balance def
charge(self, price):
if price + self. balance > self. limit: return
False
else:
self. balance += price return
True
def make payment(self, amount): self.
balance −= amount

The self Identifier

self represents the instance of the class. By using the “self” keyword we can access
the attributes and methods of the class in python

The Constructor
A user can create an instance of the CreditCard class using a syntax as: cc =
CreditCard( John Doe, 1st Bank , 5391 0375 9387 5309 , 1000)
Internally, this results in a call to the specially named init method that serves as the
constructor of the class.

Introduction to OOP

Object Oriented programming (OOP) is a programming paradigm that relies on the

concept of classes and objects. It is used to structure a software program into simple, reusable
pieces of code blueprints (usually called classes), which are used to create individual instances of
objects. There are many object-oriented programming languages including JavaScript, C++,
Java, and Python.

Object-Oriented Design Goals

Software implementations should achieve robustness, adaptability, and
reusability.
  Robustness - Capable of handling unexpected inputs that are not explicitly defined for its
application. For example, if a program is expecting a positive integer (perhaps
representing the price of an item) and instead is given a negative integer, then the
program should be able to recover gracefully from this error.

 Adaptability - adaptability (also called evolvability). Related to this concept is portability,

which is the ability of software to run with minimal change on different hardware and
operating system platforms. An advantage of writing software in Python is the portability
provided by the language itself.

 Reusability - The same code should be usable as a component of different systems in

various applications

Object-Oriented Design Principle

 Modularity - Modularity refers to an organizing principle in which different components

of a software system are divided into separate functional units. In Python, we have
already seen that a module is a collection of closely related functions and classes that are
defined together in a single file of source code. Python‟s standard libraries include, for
example, the math module, which provides definitions for key mathematical constants
and functions, and the os module, which provides support for interacting with the
operating system.

 Abstraction - An ADT is a mathematical model of a data structure that specifies the type
of data stored, the operations supported on them, and the types of parameters of the
operations. An ADT specifies what each operation does, but not how it does it

 Encapsulation - Containing information in an object, exposing only selected

information. Encapsulation means containing all important information inside an object,
and only exposing selected information to the outside world.

Encapsulation requires defining some fields as private and some as public.

 Private/ Internal interface: methods and properties, accessible from other methods of
the same class.
 Public / External Interface: methods and properties, accessible also from outside the
class.
  Inheritance - Child classes inherit data and behaviors from parent class. Inheritance
supports reusability.

 Polymorphism: many methods can do the same task. Polymorphism means designing
objects to share behaviors. Polymorphism allows the same method to execute different
behaviors in two ways: method overriding and method overloading.

Classes in Python

• Class- Classes are defined by the user. The class provides the basic structure for an object.
It consists of data members and method members that are used by the instances(object) of the
class.

• Object- A unique instance of a data structure that is defined by its class. An object
comprises both data members and methods. Class itself does nothing but real functionality is
achieved through their objects.

• Data Member: A variable defined in either a class or an object; it holds the data associated
with the class or object.

• Instance variable: A variable that is defined in a method, its scope is only within the object
that defines it.

• Class variable: A variable that is defined in the class and can be used by all the instance of
that class.

• Instance: An object is an instance of a class.

• Method: They are functions that are defined in the definition of class and are used by
various instances of the class.

• Function Overloading: A function defined more than one time with different behavior.
(different arguments)

• Encapsulation: It is the process of binding together the methods and data variables as a
single entity i.e. class. It hides the data within the class and makes it available only through the
methods.

• Inheritance: The transfer of characteristics of a class to other classes that are derived from
it.
• Polymorphism: It allows one interface to be used for a set of actions. It means same
function name(but different signatures) being used for different types.

• Data abstraction: It is the process of hiding the implementation details and showing
only functionality to the user.

Classes-
• Python is OOP language. Almost everything in python is an object with its properties
and methods.

• Object is simply a collection of data(variables) and methods(functions) that acts on those

data.

Creating Classes:
A class is a block of statement that combine data and operations, which are performed on the
data, into a group as a single unit and acts as a blueprint for the creation of objects.

Syntax:
class ClassName:
„ Optional class documentation string #list
of python class variables
# Python class constructor #Python
class method definitions

• In a class we can define variables, functions etc. While writing function in class we have to
pass atleast one argument that is called self parameter.

• The self parameter is a reference to the class itself and is used to access variables that belongs
to the class.
Example: Creating class in .py file class
student:
def display(self): # defining method in class
print("Hello Python")

• In python programming self is a default variable that contains the memory address of
the instance of the current class.

• So we can use self to refer to all the instance variable and instance methods.

Objects and Creating Objects-

• An object is an instance of a class that has some attributes and behavior.
• Objects can be used to access the attributes of the class.

Example:
class student:
def display(self): # defining method in class print("Hello
Python")
s1=student() #creating object of class s1.display()
#calling method of class using object Output:
Hello Python

Example: Class with get and put method class

car:
def get(self,color,style):
self.color=color self.style=style
def put(self):
print(self.color)
print(self.style)
c=car()
c.get('Brio','Red')
c.put()
Output:
Brio
Red

Instance variable and Class variable:

• Instance variable is defined in a method and its scope is only within the object
that defines it.

• Every object of the class has its own copy of that variable. Any changes made to the variable
don‟t reflect in other objects of that class.

• Class variable is defined in the class and can be used by all the instances of that class.

• Instance variables are unique for each instance, while class variables are shared by
all instances.

Example: For instance and class variables class

sample:
x=2 # x is class variable
def get(self,y): # y is instance variable self.y=y
s1=sample()
s1.get(3) # Access attributes
print(s1.x," ",s1.y) s2=sample()
s2.y=4 print(s2.x,"
",s2.y) Output:
23
24

Inheritance:

The mechanism of designing and constructing classes from other classes is called inheritance.
Inheritance is the capability of one class to derive or inherit the properties from some another
class.
The new class is called derived class or child class and the class from which this derived class
has been inherited is the base class or parent class. The benefits of inheritance are:
1. It represents real-world relationships well.
2. It provides reusability of a code. We don‟t have to write the same code again and again.
Also, it allows us to add more features to a class without modifying it.

3. It is transitive in nature, which means that if class B inherits from another class A, then all the
subclasses of B would automatically inherit from class
Syntax:
Class A:
# Properties of class A
Class B(A):
# Class B inheriting property of class A #
more properties of class B

Example 1: Example of Inheritance without using constructor

class vehicle: #parent class

name="Maruti"
def display(self):
print("Name= ",self.name)
class category(vehicle): # drived class
price=400000
def disp_price(self):
print("price= ",self.price)
car1=category()
car1.display()
car1.disp_price() Output:
Name= Maruti price=
400000

Example 2: Example of Inheritance using constructor

class vehicle: #parent class def

init (self,name,price):
self.name=name
self.price=price def
display(self):
print("Name= ",self.name)
class category(vehicle): # drived class def
init (self,name,price):
vehicle. init (self,name,price) #pass data to base constructor def
disp_price(self):
print("price= ",self.price)
car1=category("Maruti",400000) car1.display()
car1.disp_price() car2=category("Honda",600000)
car2.display()
car2.disp_price()
Output:
Name= Maruti
price= 400000
Name= Honda
price= 600000

Multilevel Inheritance:

In multilevel inheritance, features of the base class and the derived class are further inherited into
the new derived class. This is similar to a relationship representing a child and grandfather.

Syntax:
Class A:
# Properties of class A
Class B(A):
# Class B inheriting property of class A #
more properties of class B
Class C(B):
# Class C inheriting property of class B
# thus, Class C also inherits properties of class A # more
properties of class C
Example 1: Python program to demonstrate multilevel inheritance
#Mutilevel Inheritance
class c1:
def display1(self):
print("class c1") class
c2(c1):
def display2(self):
print("class c2") class
c3(c2):
def display3(self):
print("class c3") s1=c3()
s1.display3()
s1.display2()
s1.display1()
Output:
class c3
class c2
class c1
Example 2: Python program to demonstrate multilevel inheritance
# Base class
class Grandfather:
grandfathername =""
def grandfather(self):
print(self.grandfathername) #
Intermediate class
class Father(Grandfather):
fathername = ""
def father(self):
print(self.fathername) #
Derived class
class Son(Father):
def parent(self):
print("GrandFather :", self.grandfathername)
print("Father :", self.fathername)
# Driver's code s1
= Son()
s1.grandfathername = "Srinivas"
s1.fathername = "Ankush" s1.parent()
Output:
GrandFather : Srinivas
Father : Ankush

Multiple Inheritance:
When a class can be derived from more than one base classes this type of inheritance is called
multiple inheritance. In multiple inheritance, all the features of the base classes are inherited into
the derived class.

Syntax:
Class A:
# variable of class A #
functions of class A
Class B:
# variable of class B #
functions of class B
Class C(A,B):
# Class C inheriting property of both class A and B # more
properties of class C
Example: Python program to demonstrate multiple inheritance
# Base class1 class
Father:
def display1(self):
print("Father")
# Base class2 class
Mother:
def display2(self):
print("Mother") #
Derived class
class Son(Father,Mother):
def display3(self):
print("Son") s1
= Son()
s1.display3()
s1.display2()
s1.display1()
Output:
Son
Mother
Father
Hierarchical Inheritance:
When more than one derived classes are created from a single base this type of inheritence is
called hierarchical inheritance. In this program, we have a parent (base) class and two child
(derived) classes.

Example : Python program to demonstrate Hierarchical inheritance

# Base class class
Parent:
def func1(self):
print("This function is in parent class.") #
Derived class1
class Child1(Parent):
def func2(self):
print("This function is in child 1.") #
Derived class2
class Child2(Parent):
def func3(self):
print("This function is in child 2.")
object1 = Child1()
object2 = Child2()
object1.func1()
object1.func2()
object2.func1()
object2.func3()
Output:
This function is in parent class. This
function is in child 1.
This function is in parent class. This
function is in child 2.

Namespaces
A namespace is an abstraction that manages all of the identifiers that are defined in a
particular scope, mapping each name to its associated value.

A name in Python is a way to access a variable like in any other languages. Python is more
flexible when it comes to the variable declaration. We can declare a variable by assigning a name
to it. We can use names to reference values.

Example:
num = 5
str = 'Z'
seq = [0, 1, 1, 2, 3, 5]
#We can even assign a name to a function. def
function():
print('It is a function.') foo
= function
foo()

A namespace is a simple system to control the names in a program. A namespace is a

dictionary of variable names (keys) and their corresponding objects (values). Namespaces play a
key role in the execution of function calls and the normal control flow of a program. Python
implements namespaces in the form of dictionaries. It maintains a name-to-object mapping
where names act as keys and the objects as values. Multiple namespaces may have the same
name but pointing to a different variable.

Instance and Class Namespaces

instance namespace, which manages attributes specific to an individual object. For example,
each instance of our CreditCard class maintains a distinct balance, a
distinct account number, a distinct credit limit, and so on. Each credit card will have a
dedicated instance namespace to manage such values.
There is a separate class namespace for each class that has been defined. This namespace
is used to manage members that are to be shared by all instances of a class,

Name Resolution and Dynamic Dispatch

The process that is used when retrieving a name in Python‟s object-oriented framework.
When the dot operator syntax is used to access an existing member, such as obj.foo, the
Python interpreter begins a name resolution process, described as follows:
1. The instance namespace is searched; if the desired name is found, its associated value is
used.
2. Otherwise the class namespace, for the class to which the instance belongs, is searched; if
the name is found, its associated value is used.
3. If the name was not found in the immediate class namespace, the search continues
upward through the inheritance hierarchy, checking the class namespace for each ancestor
(commonly by checking the superclass class, then its superclass class, and so on). The first time
the name is found, its associate value is used.
4. If the name has still not been found, an AttributeError is raised.

Types of Namespaces
1. Local Namespace
Creation of local functions creates the local namespace. This namespace covers the local names
inside a function. Python creates this namespace for every function called in a program. It
remains active until the function returns.
2. Global Namespace
When a user creates a module, a global namespace gets created. This namespace covers the
names from various imported modules used in a project. Python creates this namespace for every
module included in your program. It‟ll last until the program ends.
3. Built-in Namespace
This namespace covers the built-in functions and built-in exception names. Python creates it as
the interpreter starts and keeps it until you exit. The built-in namespace encompasses global
namespace and
global namespace encompasses local namespace. Some functions like print(), id() are examples
of built in namespaces.

Lifetime of a namespace:
A lifetime of a namespace depends upon the scope of objects, if the scope of an object ends, the
lifetime of that namespace comes to an end. It is not possible to access inner namespace‟s
objects from an outer namespace.
Scopes
A scope refers to a region of a program where a namespace can be directly accessed, i.e. without
using a namespace prefix. The scope of a name is the area of a program where this name can be
unambiguously used, for example, inside of a function. A name's namespace is identical to its
scope. Scopes are defined statically, but they are used dynamically.
During program execution there are the following nested scopes available: the
innermost scope is searched first and it contains the local names
the scopes of any enclosing functions, which are searched starting with the nearest enclosing
scope
the next-to-last scope contains the current module's global names
the outermost scope, which is searched last, is the namespace containing the built-in
names.

shallow and deep copying

A shallow copy is one which makes a new object stores the reference of another object. While, in
deep copy, a new object stores the copy of all references of another object making it another list
separate from the original one.

Thus, when you make a change to the deep copy of a list, the old list doesn‟t get affected and
vice-versa. But shallow copying causes changes in both the new as well as in the old list.

This copy method is applicable in compound objects such as a list containing another list.

Syntax for Shallow Copy

import copy
copy.copy(object_name) Syntax

for Deep copy import copy

copy.deepcopy(object_name)

Example:

import copy
a = [ [1, 2, 3], [4, 5, 6] ]
b = copy.copy(a)
c = [ [7, 8, 9], [10, 11, 12] ]
d = copy.deepcopy(c)
print(a)
print(b) a[1]
[2] = 23
b[0][0] = 98
print(a)
print(b)
print("\n")
print(c)
print(d) c[1]
[2] = 23
d[0][0] = 98
print(c)
print(d)
Output:
Shallow Copy [1,2,3]
[4,5,6]
[1,2,3][4,5,6]
[98,2,3][4,5,23]
[98,2,3][4,5,23]
Deep Copy
[7, 8, 9], [10, 11, 12]
[7, 8, 9], [10, 11, 12]
[7, 8, 9], [10, 11, 23]
[98, 8, 9], [10, 11, 12]
Introduction to analysis of algorithms
Efficiency of Algorithms:
The performances of algorithms can be measured on the scales of time and space. The
performance of a program is the amount of computer memory and time needed to run a program.
We use two approaches to determine the performance of a program. One is analytical and the
other is experimental.
In performance analysis we use analytical methods, while in performance measurement we
conduct experiments.
Time Complexity: The time complexity of an algorithm or a program is a function of the
running time of the algorithm or a program. In other words, it is the amount of computer time it
needs to run to completion.
Space Complexity: The space complexity of an algorithm or program is a function of the space
needed by the algorithm or program to run to completion. The time
complexity of an algorithm can be computed either by an empirical or theoretical
approach.
The empirical or posteriori testing approach calls for implementing the complete algorithms
and executing them on a computer for various instances of the problem. The time taken by the
execution of the programs for various instances of the problem are noted and compared. The
algorithm whose implementation yields the least time is considered as the best among the
candidate algorithmic solutions.
Analyzing Algorithms
Suppose M is an algorithm, and suppose n is the size of the input data. Clearly the complexity
f(n) of M increases as n increases. It is usually the rate of increase of f(n) with some standard
functions.
The most common computing times are O(1), O(log2 n), O(n), O(n log2 n), O(n2),
O(n3), O(2n)
Example:
The total frequency counts of the program segments A, B and C given by 1, (3n+1) and
(3n2+3n+1) respectively are expressed as O(1), O(n) and O(n2). These are referred to as the time
complexities of the program segments since they are indicative of the running times of the
program segments. In a similar manner space complexities of a program can also be
expressed in terms of mathematical
notations, which is nothing but the amount of memory they require for their execution.

Asymptotic Notations:
It is often used to describe how the size of the input data affects an algorithm‟s usage of
computational resources. Running time of an algorithm is described as a function of input size n
for large n.
Big oh(O): Definition: f(n) = O(g(n)) (read as f of n is big oh of g of n) if there exist a positive
integer n0 and a positive number c such that |f(n)| ≤ c|g(n)| for all n
≥ n0 . Here g(n) is the upper bound of the function f(n).

Theta(Θ): Definition: f(n) = Θ(g(n)) (read as f of n is theta of g of n), if there exists a positive
integer n0 and two positive constants c1 and c2 such that c1 |g(n)|
≤ |f(n)| ≤ c2 |g(n)| for all n ≥ n0. The function g(n) is both an upper bound and a lower bound for
the function f(n) for all values of n, n ≥ n0 .
Little oh(o): Definition: f(n) = O(g(n)) ( read as f of n is little oh of g of n), if f(n)
= O(g(n)) and f(n) ≠ Ω(g(n)).

Reasons for analyzing algorithms:

To predict the resources that the algorithm requires
1. Computational Time(CPU consumption).
2. Memory Space(RAM consumption).
3. Communication bandwidth consumption.
4. To predict the running time of an algorithm
5. Total number of primitive operations executed.

Recursion - analyzing recursive algorithms

A function is said to be recursive if it calls itself again and again within its body
Types of Recursion:
Recursion is of two types depending on whether a function calls itself from within itself or
whether two functions call one another mutually. The former is called direct recursion and the
later is called indirect recursion. Thus there are two types of recursion:
Direct Recursion
Indirect Recursion

Recursion may be further categorized as:

Linear Recursion
Binary Recursion
Multiple Recursion

Linear Recursion:
It is the most common type of Recursion in which function calls itself repeatedly until base
condition [termination case] is reached. Once the base case is reached the results are return to
the caller function.
If a recursive function is called only once then it is called a linear recursion.
Binary Recursion:
Functions with two recursive calls are referred to as binary recursive functions.
Example1: The Fibonacci function fib provides a classic example of binary recursion. The
Fibonacci numbers can be defined by the rule:
fib(n) = 0
if n is 0,
return 1 if
n is 1,
= fib(n-1) + fib(n-2) otherwise
For example, the first seven Fibonacci numbers are Fib(0)
=0
Fib(1) = 1
Fib(2) = Fib(1) + Fib(0) = 1
Fib(3) = Fib(2) + Fib(1) = 2
Fib(4) = Fib(3) + Fib(2) = 3
Fib(5) = Fib(4) + Fib(3) = 5
Fib(6) = Fib(5) + Fib(4) = 8
# Program to display the Fibonacci sequence up to n-th term where n is provided by the user
# change this value for a different result nterms =
10
# uncomment to take input from the user #nterms
= int(input("How many terms? ")) # first two
terms
n1 = 0
n2 = 1
count = 0
# check if the number of terms is valid if
nterms <= 0:
print("Please enter a positive integer") elif
nterms == 1:
print("Fibonacci sequence upto",nterms,":") print(n1)
else:
print("Fibonacci sequence upto",nterms,":") while count
< nterms:
print(n1,end=' , ') nth
= n1 + n2
# update values n1
= n2
n2 = nth count
+= 1
Tail Recursion:
Tail recursion is a form of linear recursion. In tail recursion, the recursive call is the last thing
the function does. Often, the value of the recursive call is returned. As such, tail recursive
functions can often be easily implemented in an iterative manner; by taking out the recursive call
and replacing it with a loop, the same effect can generally be achieved. In fact, a good
compiler can recognize tail
recursion and convert it to iteration in order to optimize the performance of the code.
A good example of a tail recursive function is a function to compute the GCD, or Greatest
Common Denominator, of two numbers:
def factorial(n):
if n == 0: return 1
else: return factorial(n-1) * n
def tail_factorial(n, accumulator=1):
if n == 0: return 1
else: return tail_factorial(n-1, accumulator * n)
Recursive algorithms for Factorial, GCD, Fibonacci Series and Towers of Hanoi:
Factorial(n) Input:
integer n ≥ 0 Output:
n!
1. If n = 0 then return (1)
2. else return prod(n, factorial(n − 1))
GCD(m, n)
Input: integers m > 0, n ≥ 0
Output: gcd (m, n)
12
1. If n = 0 then return (m)
2. else return gcd(n,m mod n)
Time-Complexity: O(ln n)
Fibonacci(n)
Input: integer n ≥ 0
Output: Fibonacci Series: 1 1 2 3 5 8 13………………………………..
1. if n=1 or n=2
2. then Fibonacci(n)=1
3. else Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)

Towers of Hanoi
Input: The aim of the tower of Hanoi problem is to move the initial n different sized disks from
needle
A to needle C using a temporary needle B. The rule is that no larger disk is to be placed above
the
smaller disk in any of the needle while moving or at any time, and only the top of the disk is to
be
moved at a time from any needle to any needle. Output:
1. If n=1, move the single disk from A to C and return,
2. If n>1, move the top n-1 disks from A to B using C as temporary.
3. Move the remaining disk from A to C.
4. Move the n-1 disk disks from B to C, using A as temporary. def
TowerOfHanoi(n , from_rod, to_rod, aux_rod):
if n == 1:
print "Move disk 1 from rod",from_rod,"to rod",to_rod return
TowerOfHanoi(n-1, from_rod, aux_rod, to_rod)
print "Move disk",n,"from rod",from_rod,"to rod",to_rod
TowerOfHanoi(n-1, aux_rod, to_rod, from_rod)
n=4
TowerOfHanoi(n, 'A', 'C', 'B')