Data Structures and Algorithms With Python 100 Coding Q A Code of Code by Cakal Yasin 1

D ATA S T R U C T U R E S
AND ALGORITHMS
WITH PYTHON
100+ Coding Q&A
Yasin Cakal
Code of Code
Copyright © 2023 Yasin Cakal
All rights reserved
The characters and events portrayed in this book are fictitious. Any similarity to real persons, living
or dead, is coincidental and not intended by the author.
No part of this book may be reproduced, or stored in a retrieval system, or transmitted in any form or
by any means, electronic, mechanical, photocopying, recording, or otherwise, without express written
permission of the publisher.
CONTENTS
Title Page
Copyright
Introduction
Introduction to Data Structures and Algorithms
Overview of Data Structures and Algorithms
Importance of Data Structures and Algorithms in Programming
How to choose the right Data Structure or Algorithm
Basic Python Concepts Review
Variables and Data Types
Control Flow Statements
File Handling
Data Structures
Arrays
Stacks and Queues
Linked Lists
Hash Tables
Trees
Types of Trees
Binary Search Trees (BST)
Cartesian Trees (Treap)
B-Trees
Red-Black Trees
Splay Trees
AVL Trees
K-Dimensional (K-D) Trees
Trie Tree
Suffix Tree
Min Heap
Max Heap
Sorting Algorithm
Quick Sort
Merge Sort
Tim Sort
Heap Sort
Bubble Sort
Insertion Sort
Selection Sort
Tree Sort
Shell Sort
Bucket Sort
Radix Sort
Counting Sort
Cube Sort
Searching Algorithms
Linear Search
Binary Search
Graph Algorithms
Dijkstra’s Algorithm
Breadth First Search (BFS)
Depth First Search (DFS)
Algorithm Design Techniques
Greedy Algorithms
Dynamic Programming
Divide and Conquer
Backtracking
Randomized Algorithms
Conclusion
Recap
Thank You
INTRODUCTION
Welcome to “Data Structures and Algorithms with Python”! This
comprehensive book is designed to teach you the fundamental concepts of
data structures and algorithms and how to implement them using Python.
Whether you’re a beginner or an experienced programmer, this book will
provide you with the knowledge and skills you need to become proficient in
data structures and algorithms.
This book covers a wide range of data structures, including arrays, stacks,
queues, linked lists, skip lists, hash tables, binary search trees, Cartesian
trees, B-trees, red-black trees, splay trees, AVL trees, and KD trees. It also
covers a wide range of algorithms, including Quicksort, Mergesort, Timsort,
Heapsort, bubble sort, insertion sort, selection sort, tree sort, shell sort,
bucket sort, radix sort, counting sort, and cubesort.
In addition to learning about the various data structures and algorithms,
you’ll also learn about algorithm design techniques such as greedy
algorithms, dynamic programming, divide and conquer, backtracking, and
randomized algorithms.
The book's content will include hands-on exercises and examples to help
you practice and apply the concepts you learn. Through the book, you’ll be
exposed to the Time and Space Complexity of the algorithm and Data
Structures, so that you can understand the trade-offs of choosing one over
the other.
By the end of this book, you’ll have a solid understanding of data structures
and algorithms and how to use them effectively in Python. This book is
perfect for anyone who wants to improve their skills as a developer or
prepare for a career in computer science or data science.
Let's start your journey towards mastering data structures and algorithms
with Python.
INTRODUCTION TO DATA
STRUCTURES AND
ALGORITHMS
OVERVIEW OF DATA
STRUCTURES AND
ALGORITHMS
Data structures and algorithms are the foundation of all computer
programming. Without a basic understanding of the basic underlying
concepts, it can be difficult to write efficient code that solves a given
problem. In this article, we will explore the basics of data structures and
algorithms in Python. We will discuss the different types of data structures,
their uses, and the key algorithms used to process them. We will also
discuss the Python language and its features that make it a great choice for
data structure and algorithm development.
What are Data Structures and Algorithms?

Data structures are the way in which data is organized and stored in a
computer. They provide the means to store and manipulate data in a way
that is efficient and effective. Data structures can be implemented in any
language, but the way in which they are used can vary depending on the
language.
Algorithms are the instructions used to process data in a given data

structure. Algorithms take a given set of data as input and produce a desired
output. Algorithms can be used to sort data, search for specific values, or
even to solve complex problems.
Python
Python is an incredibly popular programming language that is used for a
wide variety of applications. One of the main reasons for its popularity is its
simplicity. Python is easy to read and understand, making it great for
beginners. It is also a powerful language that can be used to create complex
programs.
Python is a great language for data structure and algorithm development. It

has a wide range of built-in data structures and algorithms that make it easy
to process data in an efficient manner. Python also has a number of libraries
and frameworks that make it easy to use data structures and algorithms in
different ways.
Types of Data Structures

The most common type of data structure is the array. Arrays are a collection
of elements stored in a single container. Elements can be of any type,
including numbers, strings, and objects. Arrays are useful for storing and
manipulating data in an efficient manner.
Other types of data structures include linked lists, stacks, queues, trees, and
graphs. Each of these structures has its own set of properties and use cases.
Linked lists are a good choice when dealing with large datasets, as they
allow for quick insertion and deletion of data. Stacks and queues are useful
for dealing with data in a first-in-first-out manner. Trees are useful for
organizing data in a hierarchical fashion, while graphs are useful for
representing relationships between data.
Algorithms
Algorithms are the instructions used to process data stored in a data
structure. The most commonly used algorithms for data structures include
sorting algorithms, search algorithms, and graph algorithms.
Sorting algorithms are used to sort data in an array, linked list, or other data
structure. Popular sorting algorithms include quicksort, merge sort, and
heapsort. These algorithms can be used to sort data in an efficient manner.
Search algorithms are used to search for a specific element in a data

structure. Popular search algorithms include linear search and binary search.
Linear search searches the entire data structure for a given element, while
binary search uses a divide-and-conquer approach to search for a specific
element in a sorted data structure.
Graph algorithms are used to traverse and examine the relationships
between data stored in a graph. Popular graph algorithms include depth-first
search and breadth-first search. These algorithms can be used to find
shortest paths between two nodes in a graph.
Conclusion
Data structures and algorithms are the foundation of all computer
programming. A basic understanding of the different types of data
structures and algorithms is essential for writing efficient code. Python is an
incredibly popular language for data structure and algorithm development.
It has a wide range of built-in data structures and algorithms, as well as a
number of libraries and frameworks that make it easy to use data structures
and algorithms in different ways.
Exercises
What is a data structure?
What is an algorithm?
What is a linked list?
What is the difference between a linear search and a binary search?
What are graph algorithms used for?
Solutions
What is a data structure?
A data structure is a way of organizing and storing data in a computer. It
provides the means to store and manipulate data in a way that is efficient
and effective.
What is an algorithm?
An algorithm is a set of instructions used to process data in a given data
structure. Algorithms take a given set of data as input and produce a desired
output.
What is a linked list?

A linked list is a type of data structure used to store data in a single
container. It is a good choice when dealing with large datasets, as it allows
for quick insertion and deletion of data.
What is the difference between a linear search and a binary search?
A linear search searches the entire data structure for a given element, while
a binary search uses a divide-and-conquer approach to search for a specific
element in a sorted data structure.
What are graph algorithms used for?

Graph algorithms are used to traverse and examine the relationships
between data stored in a graph. Popular graph algorithms include depth-first
search and breadth-first search. These algorithms can be used to find
shortest paths between two nodes in a graph.
IMPORTANCE OF DATA
STRUCTURES AND
ALGORITHMS IN
PROGRAMMING
Data Structures and Algorithms are two of the most important concepts in
computer programming. They are used to organize and process data in a
way that makes it easier to understand and use. They are also essential for
solving complex problems in the real world. In this article, we will discuss
the importance of data structures and algorithms in programming, and how
they can be used to facilitate the development of efficient and effective
software solutions.
Data structures and algorithms are two related but distinct ideas. Data
structures are a collection of data organized in a specific way that makes it
easier to access and manipulate. Examples of data structures include arrays,
linked lists, binary search trees, and hash tables. Algorithms, on the other
hand, are a set of instructions that allow a computer to solve a problem.
They are written in a way that is understandable by both humans and
computers, and can be used to efficiently solve complex problems.
Importance of Data Structures and Algorithms in

Programming
Data structures and algorithms are essential for programming because they
enable us to effectively solve complex problems. Without data structures
and algorithms, software developers would be unable to efficiently store
and manipulate data. Furthermore, algorithms provide us with a way to find
solutions to complex problems, such as route-finding, image processing,
and natural language processing.
Data structures and algorithms are also important for software development
because they help to improve the performance of software applications. By
using efficient data structures and algorithms, software developers can
reduce the amount of time and memory needed to execute a program. This
allows applications to run faster and with less resources, making them more
efficient and cost-effective.
Finally, data structures and algorithms are important for software

development because they help to reduce the amount of code needed to
solve a problem. By using data structures and algorithms, developers can
avoid writing code that is repetitive and inefficient. This helps to make
software development easier and more efficient.
Data Structures and Algorithms in Python

Python is a popular programming language that is used for a variety of
applications, including web development, machine learning, and data
science. It is a high-level language that is relatively easy to learn and use.
Python also has a wide range of data structures and algorithms that can be
used to solve complex problems.
For example, Python has an array data structure that can be used to store
and manipulate data in a way that is efficient and easy to understand. It also
has a number of sorting algorithms, such as insertion sort, bubble sort, and
quick sort, that can be used to sort data quickly and efficiently. Python also
has a number of graph algorithms, such as Dijkstra’s algorithm and Prim’s
algorithm, that can be used to find the shortest path between two points or
to find the minimum spanning tree of a graph.
Conclusion
Data structures and algorithms are essential tools for programming. They
enable us to organize and process data in a way that is efficient and
effective. They also help to improve the performance of software
applications and reduce the amount of code needed to solve a problem.
Python is a popular programming language that has a wide range of data
structures and algorithms that can be used to solve complex problems.
Exercises
What is the purpose of using data structures and algorithms in
programming?
What are some examples of data structures?
What is the purpose of algorithms?
Name two sorting algorithms that are available in Python.
What is the purpose of using a graph algorithm?
Solutions
What is the purpose of using data structures and algorithms in
programming?
The purpose of using data structures and algorithms in programming is to
organize and process data in a way that is efficient and effective, and to
improve the performance of software applications and reduce the amount of
code needed to solve a problem.
What are some examples of data structures?

Examples of data structures include arrays, linked lists, binary search trees,
and hash tables.
What is the purpose of algorithms?

The purpose of algorithms is to provide a set of instructions that allow a
computer to solve a problem. They are written in a way that is
understandable by both humans and computers, and can be used to
efficiently solve complex problems.
Name two sorting algorithms that are available in Python.

Two sorting algorithms available in Python are insertion sort and bubble
sort.
What is the purpose of using a graph algorithm?

The purpose of using a graph algorithm is to find the shortest path between
two points or to find the minimum spanning tree of a graph.
HOW TO CHOOSE THE
RIGHT DATA STRUCTURE
OR ALGORITHM
Data structures and algorithms are essential components of programming.
They are used to store and manipulate data, as well as to solve complex
tasks. Knowing how to choose the right data structure or algorithm to solve
a given problem is a crucial skill to have as a programmer. This article will
provide an overview of how to choose the right data structure or algorithm
for a given problem.
What is a Data Structure and an Algorithm?

A data structure is a way of organizing data so that it can be used
efficiently. It can be used to store and organize data in a way that makes
certain operations more efficient. Common data structures include arrays,
linked lists, trees, and hash tables.
An algorithm is a set of steps used to solve a problem or achieve a goal. It is

a sequence of instructions that tells a computer how to perform a task.
Algorithms are used to solve complex problems by taking input data and
performing a set of operations on it. Common algorithms include sorting,
searching, and graph traversal.
The Different Types of Data Structures and

Algorithms
There are many different types of data structures and algorithms. They can
be organized into categories based on their purpose. The following are some
of the most common types of data structures and algorithms:
Sorting algorithms: These algorithms are used to sort a collection
of data. Examples of sorting algorithms include bubble sort,
insertion sort, and merge sort.
Searching algorithms: These algorithms are used to search for a
particular item in a collection of data. Examples of searching
algorithms include linear search and binary search.
Graph algorithms: These algorithms are used to traverse a graph.
Examples of graph algorithms include depth-first search and
breadth-first search.
Dynamic programming algorithms: These algorithms are used to
solve problems with overlapping subproblems. Examples of
dynamic programming algorithms include knapsack problem and
longest common subsequence.
String algorithms: These algorithms are used to solve string-
related problems. Examples of string algorithms include string
matching and string editing algorithms.
How to Choose the Right Data Structure or

Algorithm
When choosing the right data structure or algorithm for a given problem,
there are several factors to consider. These factors include the type of data
being manipulated, the size of the data set, the operations being performed,
the complexity of the operations, and the time and space constraints.
1. Type of Data
The first factor to consider when choosing the right data structure or
algorithm for a given problem is the type of data being manipulated.
Different data structures and algorithms are better suited for different types
of data. For example, a linked list might be better suited for a list of
numbers, while a binary tree might be better suited for a list of strings.
2. Size of Data Set

The second factor to consider is the size of the data set. Different data
structures and algorithms have different performance characteristics when
operating on different size data sets. For example, a linear search might be
more efficient for a small data set, while a binary search might be more
efficient for a large data set.
3. Operations
The third factor to consider is the type of operations being performed on the
data. Different operations require different data structures and algorithms.
For example, a hash table might be more efficient for retrieving data, while
a binary tree might be more efficient for inserting data.
4. Complexity
The fourth factor to consider is the complexity of the operations being
performed. Different operations have different complexity levels. For
example, sorting a list of numbers might have a complexity of O(n log n),
while searching for a particular item might have a complexity of O(log n).
5. Time and Space Constraints

The fifth factor to consider is the time and space constraints. Different data
structures and algorithms have different time and space requirements. For
example, a binary search might have a time complexity of O(log n), while a
linear search might have a time complexity of O(n).
Conclusion
Choosing the right data structure or algorithm for a given problem is an
important skill for a programmer to have. There are several factors to
consider when choosing the right data structure or algorithm, including the
type of data being manipulated, the size of the data set, the operations being
performed, the complexity of the operations, and the time and space
constraints. Understanding these factors and how to choose the right data
structure or algorithm for a given problem will help programmers to write
more efficient and effective code.
Exercises
What is the difference between a data structure and an algorithm?
What are the different types of data structures and algorithms?
What are the five factors to consider when choosing the right data
structure or algorithm for a given problem?
What is the time complexity of a linear search?
What is the time complexity of a binary search?
Solutions
What is the difference between a data structure and an algorithm?
The difference between a data structure and an algorithm is that a data
structure is a way of organizing data so that it can be used efficiently, while
an algorithm is a set of steps used to solve a problem or achieve a goal.
What are the different types of data structures and algorithms?

The different types of data structures and algorithms are sorting algorithms,
searching algorithms, graph algorithms, dynamic programming algorithms,
and string algorithms.
What are the five factors to consider when choosing the right data
structure or algorithm for a given problem?
The five factors to consider when choosing the right data structure or
algorithm for a given problem are the type of data being manipulated, the
size of the data set, the operations being performed, the complexity of the
operations, and the time and space constraints.
What is the time complexity of a linear search?

The time complexity of a linear search is O(n).
What is the time complexity of a binary search?

The time complexity of a binary search is O(log n).
BASIC PYTHON
CONCEPTS REVIEW
VARIABLES AND DATA
TYPES
Data Structures and Algorithms (DS&A) with Python is an essential part of
computer programming. Through this course, you will learn how to create
and manipulate data structures and algorithms in Python. This article will
focus on one of the fundamental concepts in DS&A with Python: variables
and data types. We will discuss what variables and data types are, how they
work in Python, and how to use them in coding examples.
What are Variables and Data Types?

Variables and data types are two of the key concepts in programming. A
variable is a name given to a value stored in memory, while a data type is a
particular kind of value. In Python, variables are used to store information,
and data types are used to classify that information.
In order to understand variables and data types in Python, it is necessary to

first understand the concept of memory. When information is stored in
memory, it is stored in the form of bits and bytes. Bits are the smallest unit
of information, and bytes are a group of 8 bits. Bytes are used to represent
characters, such as letters and numbers.
In Python, variables are used to store information in memory. Variables are

like labels, and they provide a way to refer to the information stored in
memory. The data types in Python are used to classify the information
stored in memory. Data types are like categories, and they provide a way to
organize the information stored in memory.
How do Variables and Data Types Work in

Python?
Variables and data types are two of the fundamental concepts in
programming. In order to use variables and data types in Python, it is
necessary to understand how they work.
When a variable is declared in Python, it is given a name. This name is used

to refer to the value stored in memory. The data type of the variable
determines the type of value that is stored in memory.
In Python, there are several different types of data types. These include
numbers, strings, lists, and dictionaries. Each data type has its own set of
properties and methods.
When a variable is declared, the data type of the variable is specified. This
specifies the type of information that can be stored in the variable. Once the
variable is declared, the value stored in the variable can be accessed and
manipulated.
Using Variables and Data Types in Python

Now that we have discussed what variables and data types are and how they
work in Python, let’s look at how to use them in coding examples.
In the following example, we will declare a variable called “name” and

assign it the value “John”. We will also specify the data type of the variable
as a string.
name = "John" # Declare variable and assign value

print(type(name)) # Print data type of variable
The output of the code will be:
<class 'str'>
This code shows how to declare a variable and assign it a value. It also
shows how to print the data type of the variable.
In the following example, we will create a list and assign it the values
“John”, “Paul”, and “George”. We will also specify the data type of the list
as a list.
names = ["John", "Paul", "George"] # Create list and assign values
print(type(names)) # Print data type of list
<class 'list'>
This code shows how to create a list and assign values to it. It also shows
how to print the data type of the list.
In the following example, we will create a dictionary and assign it the keys
“name” and “age” and the values “John” and “20”. We will also specify the
data type of the dictionary as a dictionary.
info = {"name": "John", "age": 20} # Create dictionary and assign values
print(type(info)) # Print data type of dictionary
<class 'dict'>
This code shows how to create a dictionary and assign values to it. It also
shows how to print the data type of the dictionary.
Conclusion
In this article, we have discussed variables and data types in Python. We
have discussed what variables and data types are, how they work in Python,
and how to use them in coding examples. Variables and data types are two
of the fundamental concepts in programming, and understanding them is
essential to being able to create and manipulate data structures and
algorithms in Python.
Exercises
Declare a variable called “num” and assign it the value 10. Print the
data type of the variable.
Create a list called “fruits” and assign it the values “apple”, “banana”,
and “orange”. Print the data type of the list.
Create a dictionary called “person” and assign it the keys “name” and
“age” and the values “John” and “20”. Print the data type of the
dictionary.
Declare a variable called “num1” and assign it the value 10. Declare a
variable called “num2” and assign it the value 20. Print the sum of the
two variables.
Create a list called “numbers” and assign it the values 1, 2, 3, and 4.
Print the length of the list.
Solutions
Declare a variable called “num” and assign it the value 10. Print the
data type of the variable.
num = 10 # Declare variable and assign value
print(type(num)) # Print data type of variable
<class 'int'>
Create a list called “fruits” and assign it the values “apple”, “banana”,
and “orange”. Print the data type of the list.
fruits = ["apple", "banana", "orange"] # Create list and assign values
print(type(fruits)) # Print data type of list
<class 'list'>
Create a dictionary called “person” and assign it the keys “name” and
“age” and the values “John” and “20”. Print the data type of the
dictionary.
person = {"name": "John", "age": 20} # Create dictionary and assign values
print(type(person)) # Print data type of dictionary
<class 'dict'>
Declare a variable called “num1” and assign it the value 10. Declare a
variable called “num2” and assign it the value 20. Print the sum of the
two variables.
num1 = 10 # Declare variable and assign value
num2 = 20 # Declare variable and assign value
print(num1 + num2) # Print the sum of the two variables
30
Create a list called “numbers” and assign it the values 1, 2, 3, and 4.
Print the length of the list.
numbers = [1, 2, 3, 4] # Create list and assign values
print(len(numbers)) # Print the length of the list
4
CONTROL FLOW
STATEMENTS
Control flow statements are an essential part of any programming language.
They are the basic building blocks of any program and help you control the
direction of the program execution. In the context of Python, control flow
statements are the fundamental structures that allow you to write
meaningful and efficient code. They allow you to create programs that can
make decisions based on certain conditions, loop through data, and execute
code blocks based on user input.
In this article, we will explore the different types of control flow statements
available in Python and how to use them. We will also look at several
examples to help you better understand the concepts. By the end of this
article, you should have a good understanding of how to use control flow
statements in Python.
What are Control Flow Statements?

Control flow statements are programming constructs that allow you to
control the flow of execution of your program. In Python, there are several
different types of control flow statements. These include:
If statements: used to evaluate a condition and execute code

blocks based on the outcome.
For loops: used to iterate over a sequence of items.
While loops: used to execute a block of code while a condition is
true.
Break and continue statements: used to break out of a loop or
skip the current iteration.
Try and except blocks: used to handle errors in a program.
Let’s look at each of these in more detail.
If Statements
If statements are one of the most commonly used control flow statements in
Python. They allow you to check a condition and execute a block of code if
the condition is true. For example, consider the following code:
x=5
if x > 0:
print("x is positive")
In this example, the if statement checks if the value of x is greater than 0. If
it is, then the code block inside the if statement is executed. In this case, it
prints out the message “x is positive”.
If statements can also be used with logical operators such as and, or, and
not. For example, consider the following code:
x=5
y = 10
if x > 0 and y > 0:
print("x and y are both positive")
In this example, the if statement checks if both x and y are greater than 0. If
they are, then the code block inside the if statement is executed. In this case,
it prints out the message “x and y are both positive”.
For Loops
For loops are used to iterate over a sequence of items. For example,
consider the following code:
for number in range(10):

print(number)
In this example, the for loop iterates over the range of numbers from 0 to 9
and prints each number. For loops are often used when you need to perform
an operation on each item in a sequence.
While Loops
While loops are similar to for loops, but they execute a block of code while
a condition is true. For example, consider the following code:
x=5
while x > 0:
print(x)
x=x-1
In this example, the while loop checks if x is greater than 0. If it is, then the
code block inside the while loop is executed. In this case, it prints out the
value of x and then decrements x by 1. The while loop continues to execute
the code block until the condition is no longer true.
Break and Continue Statements

Break and continue statements are used to break out of a loop or skip the
current iteration. For example, consider the following code:

if number == 5:
break
print(number)
In this example, the break statement causes the loop to exit when it reaches
the number 5. This means that the number 5 will not be printed out.
The continue statement, on the other hand, can be used to skip the current
iteration. For example, consider the following code:

if number % 2 == 0:
continue
print(number)
In this example, the continue statement causes the loop to skip the current
iteration if the number is even. This means that only the odd numbers will
be printed out.
Try and Except Blocks
Try and except blocks are used to handle errors in a program. For example,
consider the following code:
try:
print(1/0)
except ZeroDivisionError:
print("You cannot divide by zero!")
In this example, the try block contains a statement that will cause an error if
it is executed. The except block catches any errors that occur in the try
block and executes the code inside it. In this case, it prints out the message
“You cannot divide by zero!”
Conclusion
In this article, we explored the different types of control flow statements
available in Python and how to use them. We looked at if statements, for
loops, while loops, break and continue statements, and try and except
blocks. We also looked at several examples to help you better understand
the concepts. By the end of this article, you should have a good
understanding of how to use control flow statements in Python.
Exercises
Write a program that prints out the numbers from 1 to 10 using a for
loop.
Write a program that prints out the numbers from 10 to 1 using a while
loop.
Write a program that prints out the numbers from 1 to 10, but skips
the number 5 using a for loop and a break statement.
Write a program that prints out the odd numbers from 1 to 10 using a
for loop and a continue statement.
Write a program that prints out the numbers from 1 to 10, but prints
out an error message if 0 is reached using a for loop and a try/except
block.
Solutions
Write a program that prints out the numbers from 1 to 10 using a for
loop.
for number in range(1, 11):
print(number)
Write a program that prints out the numbers from 10 to 1 using a while
loop.
x = 10
while x > 0:
print(x)
x -= 1
Write a program that prints out the numbers from 1 to 10, but skips
the number 5 using a for loop and a break statement.
if number == 5:
break
print(number)
Write a program that prints out the odd numbers from 1 to 10 using a
for loop and a continue statement.
if number % 2 == 0:
continue
print(number)
Write a program that prints out the numbers from 1 to 10, but prints
out an error message if 0 is reached using a for loop and a try/except
block.
try:
if number == 0:
raise ValueError
print(number)
except ValueError:
print("You cannot divide by zero!")
Welcome to the Data Structures and Algorithms with Python course! In this
course, we will learn about the basic concepts of data structures and
algorithms and how to implement them in Python. In this article, we will be
focusing on functions in Python.
Functions are an essential part of Python programming and provide a

powerful and flexible way of constructing programs. Functions allow us to
break down complex tasks into smaller, more manageable pieces which can
be easily reused, tested, and debugged. In this article, we will learn about
the fundamentals of functions and how to create them in Python. We will
also look at some of the built-in functions available in Python and how to
use them.
What is a Function?
A function is a reusable block of code that performs a specific task. It can
take any number of arguments, perform some processing, and return an
output. In Python, functions are defined using the “def” keyword followed
by the function name and parentheses containing the parameters.
For example, here is a simple function that takes two arguments and returns
the sum of them:
def sum(a, b):

return a + b
This function can now be called with two arguments and it will return the
sum of them.
sum(2, 3)
# Output: 5
The function can also be called with different arguments and it will return a
different result.
sum(4, 5)
# Output: 9
Advantages of Functions
Using functions has many advantages. First, it makes the code more
organized and readable. It also helps to reduce the amount of code needed
to achieve a task. For example, if we need to perform a certain task multiple
times, we can write a function to do it once and then call the function
multiple times. This eliminates the need to rewrite the same code over and
over again.
Another advantage of using functions is that they can be tested and

debugged individually. This makes it much easier to find and fix any bugs
that might be present in the code.
Finally, functions make it easy to reuse code. Once a function is written, it

can be used in any other program without having to rewrite it. This is
especially useful when creating large and complex programs.
Creating Functions
Now that we understand what a function is and why it is useful, let’s look at
how to create one in Python. As mentioned earlier, functions are defined
using the “def” keyword followed by the function name and parentheses
containing the parameters. The body of the function is indented and
contains the code that will be executed when the function is called.
For example, here is a function that takes two numbers as arguments and
returns their sum:
def sum(a, b):

return a + b
This function can now be called with two arguments and it will return the
sum of them.
sum(2, 3)
# Output: 5
The body of the function can also contain multiple lines of code. Here is a
more complex example:
def multiply(a, b):

result = a * b
return result
This function takes two numbers as arguments, multiplies them together,
and returns the result.
multiply(2, 3)
# Output: 6
Built-in Functions
Python also provides a number of built-in functions that can be used to
perform common tasks. These functions are already defined and can be
called directly without having to define them first.
For example, the “print()” function can be used to print a value to the
console.
print(2)
# Output: 2
The “len()” function can be used to get the length of a string or list.
len('Hello World!')
# Output: 12
The “min()” and “max()” functions can be used to get the minimum and
maximum values from a list.
min([1, 2, 3, 4])
# Output: 1
max([1, 2, 3, 4])
# Output: 4
There are many other built-in functions available in Python which can be
used to simplify common tasks.
Passing Arguments
In Python, arguments can be passed to a function in two ways: by position
or by keyword. When passing arguments by position, the order in which the
arguments are passed must match the order in which they were defined in
the function.
returns their sum:
def sum(a, b):

return a + b
This function can be called with two arguments and the result will be the
sum of the two numbers.
sum(2, 3)
# Output: 5
The arguments can also be passed in a different order and the result will still
be the same.
sum(3, 2)
# Output: 5
When passing arguments by keyword, the order in which the arguments are
passed does not matter. Instead, the argument names must match the
parameter names defined in the function.
returns their sum:
def sum(a, b):

return a + b
This function can be called with two arguments and the result will be the
same as before.
sum(a=2, b=3)
# Output: 5
The arguments can also be passed in a different order and the result will still
be the same.
sum(b=3, a=2)
# Output: 5
Default Arguments
Python allows functions to have default arguments. When a default
argument is specified, it will be used if no value is passed for that argument
when the function is called.
returns their sum. The second argument has a default value of 0.
def sum(a, b=0):

return a + b
This function can be called with one argument and the result will be the
same as before.
sum(2)
# Output: 2
The second argument can also be passed with a different value and the
result will be different.
sum(2, 3)
# Output: 5
This is a useful feature because it allows us to create functions with fewer
arguments and still get the same result.
Conclusion
In this article, we have learned about functions in Python and how to create
them. We have also seen some of the advantages of using functions and
some of the built-in functions available in Python. Finally, we have looked
at how to pass arguments to a function and how to use default arguments.
Coding
Exercises
Write a function that takes two numbers as arguments and returns the
difference of them.
Write a function that takes a list as an argument and returns the
maximum value in the list.
Write a function that takes a string as an argument and returns the
number of characters in the string.
average value of the list.
Write a function that takes two strings as arguments and returns the
concatenation of the two strings.
Solutions
Write a function that takes two numbers as arguments and returns the
difference of them.
def difference(a, b):
return a - b
maximum value in the list.
def max_value(lst):
return max(lst)
Write a function that takes a string as an argument and returns the
number of characters in the string.
def num_chars(str):
return len(str)
average value of the list.
def average(lst):
return sum(lst) / len(lst)
Write a function that takes two strings as arguments and returns the
concatenation of the two strings.
def concat(str1, str2):
return str1 + str2
FILE HANDLING
File handling is a crucial part of computer programming and is used in
every language. It is a way to store data, retrieve data, and manipulate data.
In this article, we will discuss how file handling works with Python and
how to use it to store, retrieve, and manipulate data. We’ll use examples so
that you can understand the concepts better and apply them to your own
programs.
What is Input and Output?

Input and Output, commonly referred to as I/O, is the process of providing
input to a program and receiving output from a program. Input is any type
of data that is provided to a program, such as text, numbers, or files. Output
is the result of a program’s computation, such as text, numbers, or files. I/O
is a fundamental concept in programming and data structures and
algorithms, as it allows programs to interact with the user and receive data
as input and provide results as output.
I/O in Python
Python provides several built-in functions for performing I/O. The most
commonly used functions are print, input, and open. These functions are
used to print output to the screen, receive input from the user, and open
files, respectively. Let’s take a look at each of these functions in more
detail.
print
The print function is used to print output to the screen. It takes a single
argument, which is the value to be printed. The argument can be any type of
data, such as a string, number, or list.
For example, the following code prints “Hello World!” to the screen:
print("Hello World!")
input
The input function is used to receive input from the user. It takes a single
argument, which is the prompt for the user’s input. The prompt is usually a
string, but it can also be a number or a list.
For example, the following code prompts the user to enter their name and
stores the input in the variable name:
name = input("Please enter your name: ")

What is File Handling?
File handling is the process of reading and writing data from and to files
stored on a computer or other storage device. The data can be anything
from text, to images, to programs, to binary files, and more. It’s important
to understand how to use file handling as it allows you to store important
data and make sure it persists even after your program ends.
File handling allows you to perform a variety of operations on files, such as

reading and writing data, copying files, deleting files, and more. It’s also
important to understand the different types of files and how they are used.
By understanding these concepts, you will be able to create more efficient
programs that can handle different types of data.
File Handling in Python

Python is a popular programming language that has a variety of built-in
functions and modules to help you work with files. In Python, there are two
main modules used for file handling: the os module and the shutil module.
The os module provides functions to interact with the operating system
while the shutil module provides functions to interact with files. With these
modules, you can create, open, read, write, and delete files.
Creating Files in Python

To create a file in Python, you can use the open() function. This function
takes two arguments: the name of the file and the mode of the file. The
mode of the file can be ‘r’ for read-only, ‘w’ for write-only, ‘a’ for append-
only, or ‘x’ for create-and-write.
For example, to create a file called ‘test.txt’ in write-only mode, you would
use the following code:
file = open('test.txt', 'w')

The open() function will return a file object. You can then use the write()
method to write data to the file.
Writing Files in Python

Once you have created a file, you can then write data to it. You can write
data either as a string or as a list. To write data as a string, you can use the
write() method. For example, to write ‘Hello World’ to a file called
‘test.txt’, you would use the following code:

file.write('Hello World')
file.close()
To write data as a list, you can use the writelines() method. For example, to
write a list of strings to a file called ‘test.txt’, you would use the following
code:

list_of_strings = ['Hello', 'World']
file.writelines(list_of_strings)
file.close()
Reading Files in Python
Once you have written data to a file, you can then read the data. To read
data from a file, you can use the read() or readlines() method. The read()
method will read the entire file and return a string, while the readlines()
method will read each line of the file and return a list of strings.
For example, to read the file ‘test.txt’ and store the data in a variable called
‘data’, you would use the following code:
file = open('test.txt', 'r')

data = file.read()
file.close()
Copying Files in Python
You can also use the shutil module to copy files in Python. The shutil
module provides a copy() function which takes two arguments: the source
file and the destination file. For example, to copy the file ‘test.txt’ to the file
‘test_copy.txt’, you would use the following code:
import shutil
shutil.copy('test.txt', 'test_copy.txt')
Deleting Files in Python
Finally, you can use the os module to delete files. The os module provides a
remove() function which takes one argument: the file to be deleted. For
example, to delete the file ‘test.txt’, you would use the following code:
import os
os.remove('test.txt')
Conclusion
In this article, we discussed how to use file handling in Python. We covered
how to create, open, read, write, and delete files, as well as how to copy
files. We also discussed the different types of files and what the different
modes of a file mean. With this knowledge, you should now be able to
create programs that can store and manipulate data effectively.
Exercises
Create a text file called ‘data.txt’, then write the following lines to the
file:
Line 1: Hello World
Line 2: This is a test
Line 3: File handling is cool!
Read the file ‘data.txt’ and print out each line to the console.
Copy the file ‘data.txt’ to ‘data_copy.txt’.
Append the text ‘This is an additional line’ to the file ‘data.txt’.
Delete the file ‘data_copy.txt’.
Solutions
Create a text file called ‘data.txt’, then write the following lines to the
file:
Line 1: Hello World
Line 2: This is a test
Line 3: File handling is cool!
file = open('data.txt', 'w')
list_of_strings = ['Hello World', 'This is a test', 'File handling is cool!']
file.writelines(list_of_strings)
file.close()
Read the file ‘data.txt’ and print out each line to the console.
file = open('data.txt', 'r')
data = file.readlines()
for line in data:
print(line)
file.close()
Copy the file ‘data.txt’ to ‘data_copy.txt’.
import shutil
shutil.copy('data.txt', 'data_copy.txt')
Append the text ‘This is an additional line’ to the file ‘data.txt’.
file = open('data.txt', 'a')
file.write('This is an additional line')
file.close()
Delete the file ‘data_copy.txt’.
import os
os.remove('data_copy.txt')
DATA STRUCTURES
ARRAYS
Arrays are one of the most important data structures used in computer
programming. They are a collection of elements that are stored in a linear
fashion and can be used to store and manipulate data efficiently. In this
article, we will be discussing arrays, their creation and initialization,
accessing and modifying elements, common array methods, and two-
dimensional arrays. With each topic, we will provide code examples to help
solidify concepts and help you understand how arrays work. By the end of
this article, you should have an understanding of how to use arrays in
Python to structure and manipulate data.
Creating and Initializing Arrays

In Python, there are many ways to create and initialize an array. The
simplest way to create an array is to use the array.array() function. The
array.array() function takes in one argument which is the data type of the
array elements. This function creates an empty array in which you can store
elements of the specified data type.
For example, if you wanted to create an array to store integers, you could
do the following:
import array
# Create an array to store integers
int_array = array.array('i')
print(int_array) # prints: array('i', [])
The above code creates an empty array of integers. You can see that the
array is empty by printing it out.
In addition to creating an empty array, you can also initialize an array with
data. You can do this by passing a list of elements to the array.array()
function as the second argument. For example, if you wanted to create an
array of integers with the values [1, 2, 3] you could do the following:
import array
# Create an array of integers
int_array = array.array('i', [1, 2, 3])
print(int_array) # prints: array('i', [1, 2, 3])
The above code creates an array of integers with the values [1, 2, 3].
Accessing Elements of Arrays

Once you have created an array, you will need to know how to access the
elements of the array. To access elements of an array, you can use the index
operator ([]). The index operator takes in a single argument which is the
index of the element you wish to access. The first element of the array has
an index of 0 and the last element of the array has an index of len(array)-1.
For example, if you wanted to access the first element of the array int_array,
you could do the following:
# Access the first element of int_array

first_element = int_array[0]
print(first_element) # prints: 1
The above code accesses the first element of the array int_array which is 1.
Modifying Elements of Arrays

In addition to accessing elements of arrays, you can also modify the
elements. To modify the elements of an array, you can use the index
operator ([]). The index operator takes in two arguments, the index of the
element you wish to modify and the new value you wish to assign to the
element.
For example, if you wanted to modify the third element of the array
int_array, you could do the following:
# Modify the third element of int_array

int_array[2] = 4
print(int_array) # prints: array('i', [1, 2, 4])
The above code modifies the third element of the array int_array which is
now 4.
Common Array Methods

In addition to accessing and modifying elements of an array, there are also
many useful methods that can be used with arrays. The most common
methods are append(), extend(), insert(), remove(), pop(), and clear().
The append() method takes in a single argument which is the element you
wish to add to the end of the array. For example, if you wanted to add the
integer 5 to the end of the array int_array, you could do the following:
# Add the integer 5 to the end of int_array

int_array.append(5)
print(int_array) # prints: array('i', [1, 2, 4, 5])
The above code adds the integer 5 to the end of the array int_array.
The extend() method takes in a single argument which is a list of elements

you wish to add to the end of the array. For example, if you wanted to add
the integers 6 and 7 to the end of the array int_array, you could do the
following:
# Add the integers 6 and 7 to the end of int_array

int_array.extend([6, 7])
print(int_array) # prints: array('i', [1, 2, 4, 5, 6, 7])
The above code adds the integers 6 and 7 to the end of the array int_array.
The insert() method takes in two arguments, the index of the element you
wish to insert and the element you wish to insert. For example, if you
wanted to insert the integer 8 at index 2 of the array int_array, you could do
the following:
# Insert the integer 8 at index 2 of int_array

int_array.insert(2, 8)
print(int_array) # prints: array('i', [1, 2, 8, 4, 5, 6, 7])
The above code inserts the integer 8 at index 2 of the array int_array.
The remove() method takes in a single argument which is the element you
wish to remove from the array. For example, if you wanted to remove the
integer 8 from the array int_array, you could do the following:
# Remove the integer 8 from int_array

int_array.remove(8)
print(int_array) # prints: array('i', [1, 2, 4, 5, 6, 7])
The above code removes the integer 8 from the array int_array.
The pop() method takes in a single argument which is the index of the
element you wish to remove from the array. For example, if you wanted to
remove the element at index 2 of the array int_array, you could do the
following:
# Remove the element at index 2 of int_array

int_array.pop(2)
print(int_array) # prints: array('i', [1, 2, 5, 6, 7])
The above code removes the element at index 2 of the array int_array.
The clear() method takes no arguments and removes all elements from the
array. For example, if you wanted to remove all elements from the array
int_array, you could do the following:
# Remove all elements from int_array

int_array.clear()
print(int_array) # prints: array('i', [])
The above code removes all elements from the array int_array.
2D Arrays
In addition to one-dimensional arrays, you can also create two-dimensional
arrays. Two-dimensional arrays are useful for storing and manipulating two-
dimensional data. In Python, two-dimensional arrays can be created using
the numpy library.
The numpy library is a powerful library for scientific computing in Python.

To use the numpy library, you must first import it.
import numpy as np
Once you have imported the numpy library, you can create two-dimensional
arrays using the numpy.array() function. The numpy.array() function takes
in one argument which is a list of lists. For example, if you wanted to create
a two-dimensional array with the values [[1, 2], [3, 4]], you could do the
following:
# Create a two-dimensional array

two_dimensional_array = np.array([[1, 2], [3, 4]])
print(two_dimensional_array) # prints: array([[1, 2],
[3, 4]])
The above code creates a two-dimensional array with the values [[1, 2], [3,
4]].
Conclusion
In this article, we discussed arrays, their creation and initialization,
accessing and modifying elements, common array methods, and two-
dimensional arrays. We also provided code examples to help solidify
concepts and help you understand how arrays work. By the end of this
article, you should have an understanding of how to use arrays in Python to
structure and manipulate data.
Exercises
Create an array of integers with the values [1, 2, 3, 4, 5].
Add the integer 6 to the end of the array int_array.
Insert the integer 7 at index 3 of the array int_array.
Remove the element at index 4 of the array int_array.
Create a two-dimensional array with the values [[1, 2], [3, 4], [5, 6]].
Solutions
Create an array of integers with the values [1, 2, 3, 4, 5].
import array
# Create an array of integers
int_array = array.array('i', [1, 2, 3, 4, 5])
Add the integer 6 to the end of the array int_array.
# Add the integer 6 to the end of int_array
int_array.append(6)
Insert the integer 7 at index 3 of the array int_array.
# Insert the integer 7 at index 3 of int_array
int_array.insert(3, 7)
Remove the element at index 4 of the array int_array.
# Remove the element at index 4 of int_array
int_array.pop(4)
Create a two-dimensional array with the values [[1, 2], [3, 4], [5, 6]].
import numpy as np
# Create a two-dimensional array
two_dimensional_array = np.array([[1, 2], [3, 4], [5, 6]])
STACKS AND QUEUES
Data Structures and Algorithms with Python is an introductory course that
covers the fundamentals of data structures and algorithms. In this course,
we will focus on two important data structures—stacks and queues—and
how to implement them using arrays, classes, and the queue module in
Python. We will also discuss the applications of stacks and queues.
What Are Stacks and Queues?

Stacks and queues are two of the most commonly used data structures. A
stack is a collection of objects that are organized in a Last-In-First-Out
(LIFO) structure. The last object that was added to the stack is the first one
that can be removed. Stacks are often used to store data in a temporary or
intermediate format, such as when reversing a string or evaluating an
expression.
A queue is a collection of objects that are organized in a First-In-First-Out

(FIFO) structure. The first object that was added to the queue is the first one
that can be removed. Queues are often used to store data in a waiting state,
such as when processing jobs or tasks in a system.
Implementing Stacks and Queues Using Arrays Stacks and queues can be
implemented using arrays. An array is a data structure that stores a
collection of items in a contiguous block of memory. Each item in the array
is referred to as an element, and it can be accessed using its index or
position in the array.
To implement a stack using an array, we will need to use the following

methods:
push(): This method adds an element to the top of the stack.

pop(): This method removes the element from the top of the
stack.
isEmpty(): This method checks if the stack is empty.
The following code snippet shows how to implement a stack using an array
in Python:
class Stack:
def __init__(self):
self.stack = []
def push(self, item):
self.stack.append(item)
def pop(self):
if self.isEmpty():
return None
else:
return self.stack.pop()
def isEmpty(self):
return len(self.stack) == 0
To implement a queue using an array, we will need to use the following
methods:
enqueue(): This method adds an element to the back of the

queue.
dequeue(): This method removes the element from the front of
the queue.
isEmpty(): This method checks if the queue is empty.
The following code snippet shows how to implement a queue using an array
in Python:
class Queue:
def __init__(self):
self.queue = []
def enqueue(self, item):
self.queue.append(item)
def dequeue(self):
if self.isEmpty():
return None
else:
return self.queue.pop(0)
def isEmpty(self):
return len(self.queue) == 0
Implementing Stacks and Queues Using Classes
Stacks and queues can also be implemented using classes. A class is a
blueprint for creating objects. Objects are instances of classes, and they can
have their own attributes and methods.
The following code snippet shows how to implement a stack using a class
in Python:
class Stack:
def __init__(self):
self.items = []
self.items.append(item)
def pop(self):
if self.isEmpty():
return None
else:
return self.items.pop()
def isEmpty(self):
return len(self.items) == 0
The following code snippet shows how to implement a queue using a class
in Python:
class Queue:
def __init__(self):
self.items = []
def dequeue(self):
if self.isEmpty():
return None
else:
return self.items.pop(0)
def isEmpty(self):
Using the Queue Module in Python
The queue module in Python provides a number of queue-related data
structures and algorithms. The most commonly used data structure is the
Queue class, which is a FIFO queue. The Queue class provides the
following methods:
put(): This method adds an element to the back of the queue.

get(): This method removes the element from the front of the
queue.
empty(): This method checks if the queue is empty.
The following code snippet shows how to use the Queue class in Python:
import queue
q = queue.Queue()
q.put(1)
q.put(2)
q.put(3)
while not q.empty():
print(q.get())
# Output:
#1
#2
#3
Applications of Stacks and Queues
Stacks and queues are used in a variety of applications, such as:
Operating system processes: Stacks are used to store the state of

a process before it is suspended, while queues are used to store
the list of processes that are waiting to be executed.
Compilers: Stacks are used to store intermediate results during
compilation, while queues are used to store symbols for lexical
analysis.
Graph algorithms: Stacks are used to store the nodes that have
been visited during a depth-first search (DFS), while queues are
used to store the nodes that need to be visited during a breadth-
first search (BFS).
Network routing algorithms: Stacks are used to store the shortest
path between two nodes, while queues are used to store the nodes
that need to be visited during a routing algorithm.
Conclusion
In this article, we have discussed the fundamentals of stacks and queues,
and how to implement them using arrays, classes, and the queue module in
Python. We have also discussed the applications of stacks and queues in
various domains. With this knowledge, you are now ready to explore and
use stacks and queues in your own projects.
Exercises
Write a Python program to create a Stack class and use it to push and
pop elements.
Write a Python program to create a Queue class and use it to enqueue
and dequeue elements.
Write a Python program to use a Queue class to create a queue of
strings and then print out the strings in reverse order.
Write a Python program to use a Stack class to create a stack of
numbers and then print out the numbers in reverse order.
numbers and then print out the numbers in order.
Solutions
Write a Python program to create a Stack class and use it to push and
pop elements.
class Stack:
def __init__(self):
self.items = []
def pop(self):
if self.isEmpty():
return None
else:
def isEmpty(self):
s = Stack()
s.push(1)
s.push(2)
s.push(3)
while not s.isEmpty():
print(s.pop())
Write a Python program to create a Queue class and use it to enqueue
and dequeue elements.
class Queue:
def __init__(self):
self.items = []
def dequeue(self):
if self.isEmpty():
return None
else:
return self.items.pop(0)
def isEmpty(self):
q = Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
while not q.isEmpty():
print(q.dequeue())
strings and then print out the strings in reverse order.
import queue
q = queue.Queue()
q.put("Hello")
q.put("World")
q.put("!")
print(q.get(), end="")
# Output: !dlroW olleH
Write a Python program to use a Stack class to create a stack of
numbers and then print out the numbers in reverse order.
class Stack:
def __init__(self):
self.items = []
def pop(self):
if self.isEmpty():
return None
else:
def isEmpty(self):
s = Stack()
s.push(1)
s.push(2)
s.push(3)
while not s.isEmpty():
print(s.pop(), end="")
# Output: 321
numbers and then print out the numbers in order.
import queue
q = queue.Queue()
q.put(1)
q.put(2)
q.put(3)
print(q.get(), end="")
# Output: 123
LINKED LISTS
Linked lists are a fundamental data structure commonly used in computer
science. They are an ordered collection of data elements, each containing a
link to its successor. Linked lists are used to efficiently store and manipulate
data in a variety of applications, such as web browsers, databases, operating
systems, and graphics applications.
In this article, we will discuss linked lists in the context of the course Data
Structures and Algorithms with Python. We’ll start by looking at the basics
of linked lists, and then move on to discuss how to implement linked lists
using classes. We’ll also cover singly linked lists, doubly linked lists,
traversing linked lists, inserting and deleting elements from linked lists, and
skip lists.
Overview of Linked Lists

Linked lists are a type of data structure that allows data elements to be
stored and manipulated in an ordered collection. Each element in a linked
list is known as a node, and each node contains two pieces of information: a
data element and a link to the successor node. The first element in a linked
list is known as the head, and the last element is known as the tail.
Linked lists are a dynamic data structure, meaning that their size can change
at runtime. They are also very efficient, as the time required to access,
insert, or delete an element is independent of the size of the list. This makes
linked lists well suited for applications where frequent insertions and
deletions are needed.
Implementing Linked Lists Using Classes

In Python, linked lists can be implemented using classes. The following
code shows an example of how a linked list can be implemented using a
class.
class Node:
def __init__(self, data):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = None
The Node class is responsible for storing the data element and the link to
the successor node. The LinkedList class is responsible for managing the
list of nodes. It stores a reference to the head node, which is the first
element in the linked list.
Singly Linked Lists

A singly linked list is a type of linked list where each node contains a link
to its successor, but not to its predecessor. This makes it a one-way data
structure, as elements can only be traversed in one direction.
A singly linked list can be implemented using the following code:
class Node:
self.data = data
self.next = None
class SinglyLinkedList:
def __init__(self):
self.head = None
The SinglyLinkedList class is similar to the LinkedList class, but it stores a
reference to the head node instead of the head node itself. This makes it
easier to add and remove elements from the list.
Doubly Linked Lists

A doubly linked list is a type of linked list where each node contains a link
to both its successor and its predecessor. This makes it a two-way data
structure, as elements can be traversed in both directions.
A doubly linked list can be implemented using the following code:
class Node:
self.data = data
self.next = None
self.prev = None
class DoublyLinkedList:
def __init__(self):
self.head = None
self.tail = None
The DoublyLinkedList class is similar to the SinglyLinkedList class, but it
stores a reference to the head and tail nodes instead of the head and tail
nodes themselves. This makes it easier to add and remove elements from
the list.
Traversing Linked Lists

Traversing a linked list involves iterating through all of its elements. This
can be done in either a forward or backward direction, depending on the
type of linked list being used.
In a singly linked list, elements can be traversed in a forward direction

using a while loop. The following code shows an example of how this can
be done:
# Traverse a singly linked list

current_node = linked_list.head
while current_node is not None:
# Do something with the current node
current_node = current_node.next
In a doubly linked list, elements can be traversed in either a forward or
backward direction using a while loop. The following code shows an
example of how this can be done:
# Traverse a doubly linked list forward

# Traverse a doubly linked list backward
current_node = linked_list.tail
current_node = current_node.prev
Inserting and Deleting Elements from Linked
Lists
Inserting and deleting elements from linked lists can be done in constant
time, regardless of the size of the list. This makes linked lists well suited for
applications where frequent insertions and deletions are needed.
In a singly linked list, elements can be inserted and deleted from the head or
tail of the list. The following code shows an example of how this can be
done:
# Insert a new element at the head

new_node = Node(data)
new_node.next = linked_list.head
linked_list.head = new_node
# Delete the element at the head
linked_list.head = linked_list.head.next
In a doubly linked list, elements can be inserted and deleted from any
position in the list. The following code shows an example of how this can
be done:
# Insert a new element at a given position
new_node = Node(data)
new_node.next = current_node
new_node.prev = current_node.prev
current_node.prev.next = new_node
current_node.prev = new_node
# Delete an element at a given position
current_node.prev.next = current_node.next
current_node.next.prev = current_node.prev
Skip Lists
A skip list is a type of linked list that allows for efficient searching and
traversal. It is a randomized data structure, meaning that its elements are
stored in a random order. This makes it well suited for applications where
frequent searches are needed.
In a skip list, each node contains multiple links to other nodes. This allows
for faster search times, as the search can be done in multiple directions at
the same time. The following code shows an example of how a skip list can
be implemented using a class:
class SkipListNode:
self.data = data
self.next = [None] * MAX_LEVEL
class SkipList:
def __init__(self):
self.head = None
Conclusion
In this article, we discussed linked lists in the context of the course Data
Structures and Algorithms with Python. We looked at the basics of linked
lists, and then discussed how to implement them using classes. We also
covered singly linked lists, doubly linked lists, traversing linked lists,
inserting and deleting elements from linked lists, and skip lists.
Linked lists are a powerful data structure that can be used to efficiently
store and manipulate data. They are a dynamic data structure, meaning that
their size can change at runtime, and they are also very efficient, as the time
required to access, insert, or delete an element is independent of the size of
the list.
Exercises
Write a function that takes a linked list and returns the length of the
list.
Write a function that takes a linked list and returns the middle element
of the list.
Write a function that takes a linked list and a value, and deletes all
nodes with the given value from the list.
Write a function that takes a linked list and a value, and inserts a new
node with the given value at the end of the list.
node with the given value at the beginning of the list.
Solutions
Write a function that takes a linked list and returns the length of the
list.
def get_length(linked_list):
length = 0
length += 1
return length
Write a function that takes a linked list and returns the middle element
of the list.
def get_middle(linked_list):
slow_node = linked_list.head
fast_node = linked_list.head
while fast_node is not None and fast_node.next is not None:
slow_node = slow_node.next
fast_node = fast_node.next.next
return slow_node
Write a function that takes a linked list and a value, and deletes all
nodes with the given value from the list.
def delete_value(linked_list, value):
prev_node = None
if current_node.data == value:
# Delete the node
if prev_node is not None:
prev_node.next = current_node.next
else:
linked_list.head = current_node.next
else:
prev_node = current_node
node with the given value at the end of the list.
def insert_at_end(linked_list, value):
new_node = Node(value)
if linked_list.head is None:
return
while current_node.next is not None:
current_node.next = new_node
node with the given value at the beginning of the list.
def insert_at_beginning(linked_list, value):
new_node.next = linked_list.head
HASH TABLES
Hash tables are one of the most important and widely used data structures in
computer science. They have numerous applications and have become
essential tools in many programming tasks. In this article, we will provide a
comprehensive overview of hash tables, discuss their implementations
using arrays, and explore their functions, collision handling, and
applications.
Overview of Hash Tables

A hash table is a data structure that maps keys to values. It uses a hash
function to compute an index into an array, in which the corresponding
value is stored. Hash tables are extremely efficient for lookups and are used
in many areas of computer science, including searching, sorting, caching,
and more.
Implementing Hash Tables using Arrays

Hash tables are usually implemented using arrays. An array is an indexed
data structure that stores a fixed number of elements of the same type. The
array index is used to map keys to values. To look up a value in an array,
you simply use the key to calculate the index, and then access the
corresponding element.
The following is an example of a simple array-based hash table in Python:
hash_table = [None] * 10
def insert(key, value):
index = hash(key)
hash_table[index] = value
def get(key):
index = hash(key)
return hash_table[index]
Hash Functions
A hash function is a function that maps keys to indexes in a hash table. In
order to look up a key in a hash table, the hash function must be used to
calculate the index of the corresponding value.
A hash function must have the following properties:
It must be deterministic: the same input must always produce the

same output.
It must be fast: the time it takes to calculate the hash should be
constant.
It must be distributed evenly: the output values should be
uniformly distributed across the range of possible outputs.
The most commonly used hash functions include:
Modulo hashing: this is a simple hash function that takes the

remainder of the key divided by the array size.
Folding: this is a technique that splits the key into several parts
and then adds them together to produce the hash.
Cryptographic hashing: this is a technique that uses
cryptographic algorithms to generate a unique hash for each key.
Collision Handling
A collision is when two keys hash to the same index. It is inevitable that
collisions will occur in hash tables, as there are usually more keys than
indexes. Therefore, it is important to have a strategy for dealing with
collisions.
The most common strategies for dealing with collisions are:
Separate chaining: this is a technique where each index in the

hash table is a linked list of keys that have hashed to that index.
When a collision occurs, the key is added to the linked list.
Open addressing: this is a technique where each index in the
hash table is a pointer to the next available index. When a
collision occurs, the key is added to the next available index.
Applications of Hash Tables

Hash tables are used in many areas of computer science. They are
commonly used for searching, sorting, and caching.
Searching: Hash tables are extremely efficient for searching. By using a

hash function to calculate the index, the time it takes to find a key is
constant. This makes hash tables ideal for applications such as databases
and search engines.
Sorting: Hash tables can be used to sort data in linear time. By hashing each
key to an index, the data can be sorted in linear time. This is useful for
applications that require fast sorting, such as databases.
Caching: Hash tables can be used to store frequently used data in memory.
By using a hash function to calculate the index, data can be stored and
retrieved quickly. This is useful for applications that require frequent access
to data, such as web browsers.
Conclusion
In this article, we have provided a comprehensive overview of hash tables,
discussed their implementations using arrays, explored their functions,
collision handling, and applications. We have also seen how hash tables can
be used for searching, sorting, and caching.
Hash tables are one of the most important and widely used data structures in
computer science. They have numerous applications and have become
essential tools in many programming tasks.
Exercises
Write a Python program to create a hash table of size 10 and print out
the values stored in each index.
Write a Python program to create a hash table and insert the following
key-value pairs: (1,2), (3,4), (5,6), (7,8).
Write a Python program to implement separate chaining for collision
handling in a hash table.
Write a Python program to implement open addressing for collision
Write a Python program to search for a given key in a hash table.
Solutions
Write a Python program to create a hash table of size 10 and print out
the values stored in each index.
for i in range(len(hash_table)):
hash_table[i] = i * i
print(hash_table[i])
Write a Python program to create a hash table and insert the following
key-value pairs: (1,2), (3,4), (5,6), (7,8).
def insert(key, value):
index = hash(key)
hash_table[index] = value
insert(1,2)
insert(3,4)
insert(5,6)
insert(7,8)
print(hash_table[i])
Write a Python program to implement separate chaining for collision
class Node:
def __init__(self, key, value):
self.key = key
self.value = value
self.next = None
class HashTable:
def __init__(self, size):
self.size = size
self.table = [None] * self.size
def hash(self, key):
return key % self.size
def insert(self, key, value):
index = self.hash(key)
node = Node(key, value)
if self.table[index] == None:
self.table[index] = node
else:
cur_node = self.table[index]
while cur_node.next != None:
cur_node = cur_node.next
cur_node.next = node
def get(self, key):
cur_node = self.table[index]
while cur_node != None:
if cur_node.key == key:
return cur_node.value
else:
return None
Write a Python program to implement open addressing for collision
class HashTable:
def __init__(self, size):
self.size = size
self.table = [None] * self.size
def hash(self, key):
return key % self.size
self.table[index] = (key, value)
else:
i = (index + 1) % self.size
while i != index and self.table[i] != None:
i = (i + 1) % self.size
if i == index:
return False
else:
self.table[i] = (key, value)
return True
def get(self, key):
return None
else:
i = index
while i != (index + 1) % self.size and self.table[i] != None and
self.table[i][0] != key:
i = (i + 1) % self.size
if i == (index + 1) % self.size:
return None
else:
return self.table[i][1]
Write a Python program to search for a given key in a hash table.
def search(hash_table, key):
index = hash(key)
cur_node = hash_table[index]
while cur_node != None:
if cur_node.key == key:
return cur_node.value
else:
return None
TREES
Trees are an important data structure in computer science, used to store and
organize data efficiently. Trees are composed of nodes, which contain data,
and edges, which connect nodes. Trees are hierarchical structures, with the
root node at the top and the leaves at the bottom. Trees are used in many
algorithms and applications, from database queries to sorting algorithms. In
this Data Structures and Algorithms with Python course, you will learn
about trees, how to implement them using classes, how to traverse trees,
how to insert and delete elements from a tree, and how to use trees in
applications.
Overview of Trees
Trees are data structures that are used to store and organize data in an
efficient manner. A tree consists of nodes and edges. Each node contains
data and each edge connects two nodes. The topmost node is called the root
node, while the bottommost nodes are called leaves. Trees are hierarchical
structures, with the root node at the top and the leaves at the bottom. Trees
can be used to store data in a variety of ways, such as storing files in a file
system, or storing information in a database.
Trees are used in many algorithms and applications, such as database

queries, sorting algorithms, and graph algorithms. Trees can also be used to
store information in a variety of ways, such as storing hierarchical data or
storing data in a database.
Implementing Trees Using Classes

In order to implement trees using classes, we need to create a class for
nodes and a class for edges. Each node will contain data, and each edge will
connect two nodes. We will also need to define methods for traversing a
tree, inserting and deleting elements from a tree, and using trees in
applications.
The Node Class
The Node class is used to store data in a tree. Each node has a value, which
is the data stored in the node, and a list of edges, which are the edges that
connect the node with other nodes. The following is an example of a Node
class in Python:
class Node:
def __init__(self, value):
self.value = value
self.edges = []
The Edge Class
The Edge class is used to connect two nodes. Each edge has a start node,
which is the node at the start of the edge, and an end node, which is the
node at the end of the edge. The following is an example of an Edge class in
Python:
class Edge:
def __init__(self, start, end):
self.start = start
self.end = end
Traversing a Tree
In order to traverse a tree, we must first define a traversal algorithm. The
most common traversal algorithms are depth-first search and breadth-first
search.
Depth-First Search
Depth-first search (DFS) is a traversal algorithm that starts at the root node
and explores as far as possible along each branch before backtracking. The
following is an example of a depth-first search algorithm in Python:
def dfs(root):
if root is None:
return
print(root.value)
for edge in root.edges:
dfs(edge.end)
Breadth-First Search
Breadth-first search (BFS) is a traversal algorithm that starts at the root
node and explores the neighbor nodes first, before moving on to the next
level neighbors. The following is an example of a breadth-first search
algorithm in Python:
def bfs(root):
if root is None:
return
queue = [root]
while queue:
node = queue.pop(0)
print(node.value)
for edge in node.edges:
queue.append(edge.end)
Inserting and Deleting Elements from a Tree
In order to insert and delete elements from a tree, we need to define
algorithms for inserting and deleting elements.
Inserting Elements
To insert an element into a tree, we need to define an algorithm that finds
the appropriate position in the tree and inserts the element. The following is
an example of an algorithm for inserting elements into a tree in Python:
def insert(root, value):

if root is None:
return Node(value)
if value < root.value:
root.left = insert(root.left, value)
else:
root.right = insert(root.right, value)
return root
Deleting Elements
To delete an element from a tree, we need to define an algorithm that finds
the element and removes it from the tree. The following is an example of an
algorithm for deleting elements from a tree in Python:
def delete(root, value):

if root is None:
return
root.left = delete(root.left, value)
elif value > root.value:
root.right = delete(root.right, value)
else:
if root.left is None:
temp = root.right
root = None
return temp
elif root.right is None:
temp = root.left
root = None
return temp
temp = minValueNode(root.right)
root.value = temp.value
root.right = delete(root.right, temp.value)
return root
Conclusion
In this Data Structures and Algorithms with Python course, you have
learned about trees, how to implement them using classes, how to traverse
trees, how to insert and delete elements from a tree, and how to use trees in
applications. Trees are an important data structure in computer science,
used in many algorithms and applications. With the knowledge of trees, you
will be able to create efficient algorithms and applications.
Exercises
Write a function that takes a tree as input and prints out the values of
the nodes in preorder traversal.
the nodes in inorder traversal.
the nodes in postorder traversal.
Write a function that takes a tree and a value as input and inserts the
value into the tree.
Write a function that takes a tree and a value as input and deletes the
value from the tree.
Solutions
the nodes in preorder traversal.
def preorder_traversal(root):
if root is None:
return
print(root.value)
preorder_traversal(root.left)
preorder_traversal(root.right)
the nodes in inorder traversal.
def inorder_traversal(root):
if root is None:
return
inorder_traversal(root.left)
print(root.value)
inorder_traversal(root.right)
the nodes in postorder traversal.
def postorder_traversal(root):
if root is None:
return
postorder_traversal(root.left)
postorder_traversal(root.right)
print(root.value)
Write a function that takes a tree and a value as input and inserts the
value into the tree.
def insert(root, value):
if root is None:
return Node(value)
root.left = insert(root.left, value)
else:
root.right = insert(root.right, value)
return root
Write a function that takes a tree and a value as input and deletes the
value from the tree.
def delete(root, value):
if root is None:
return
root.left = delete(root.left, value)
elif value > root.value:
root.right = delete(root.right, value)
else:
temp = root.right
root = None
return temp
temp = root.left
root = None
return temp
temp = minValueNode(root.right)
root.value = temp.value
root.right = delete(root.right, temp.value)
return root
TYPES OF TREES
BINARY SEARCH TREES
(BST)
Binary search trees (BST) are a fundamental data structure used in
computer science and are a key component in many algorithms. BSTs are
used in a variety of applications, from database systems to sorting
algorithms. BSTs provide efficient ways of searching, inserting, and
deleting elements. In this article, we will discuss the time and space
complexities associated with BSTs, as well as provide examples of how to
implement them in Python.
What is a Binary Search Tree?

A Binary Search Tree (BST) is a collection of nodes arranged in a
hierarchical structure. Each node contains two fields: a key and a value. The
key of a node is used to compare the relative order of two nodes. The key is
also used to search, insert, and delete elements from the tree. Each node in
the tree can have at most two children, referred to as the left and right child.
The left child must have a key that is less than or equal to the parent node’s
key. Similarly, the right child must have a key that is greater than or equal
to the parent node’s key.
How does Binary Search Trees Work?

A binary search tree (BST) is a type of data structure that is used in
computer science to store and organize data. It is a tree-like structure with
nodes that contain a key, left and right pointers, and a data value.
To begin, each node in the tree is initialized as the root node. The root node
will contain a key, left and right pointers, and a data value. The root node is
the starting point to traverse the BST.
Next, the BST is traversed in a top-down fashion. To look up a node, the
key of the root node is compared to the key being searched for. If the key
being searched for is less than the root node’s key, the left pointer is
followed. If the key being searched for is greater than the root node’s key,
the right pointer is followed. This process is repeated until the key being
searched for is found.
Once the desired node is located, the data stored in the node is retrieved and
returned. If the node is not found, an error is returned.
The BST is an efficient data structure for searching and inserting data, as
the time complexity for searching is O(log n). The time complexity for
inserting a node is also O(log n). This is because the BST is self-balancing,
meaning the height of the tree is kept to a minimum. This allows for faster
searches and insertions of data.
Binary search trees are often used in applications where fast search and
insertion operations are required, such as in databases, search engines, and
sorting algorithms.
Time Complexity
The time complexity of BSTs is determined by the number of operations
required to access, search, insert, and delete elements from the tree. To
evaluate the time complexity, we must consider the average case and the
worst case.
Access:
The time complexity of accessing a node in a BST is O(log n), where n is
the number of nodes in the tree. This is because, in the worst case, the
search must traverse the entire tree. However, since the tree is balanced, the
search will typically take log(n) time.
Search:
The time complexity of searching a BST is also O(log n). This is because,
in the worst case, the search must traverse the entire tree. However, since
the tree is balanced, the search will typically take log(n) time.
Insertion:
The time complexity of inserting a node into a BST is O(log n). This is
because, in the worst case, the insertion must traverse the entire tree.
However, since the tree is balanced, the insertion will typically take log(n)
time.
Deletion:
The time complexity of deleting a node from a BST is O(log n). This is
because, in the worst case, the deletion must traverse the entire tree.
However, since the tree is balanced, the deletion will typically take log(n)
time.
Space Complexity:
The space complexity of a BST is determined by the amount of memory
required to store the tree. The space complexity of a BST is O(n), where n
is the number of nodes in the tree. This is because the tree must store the
keys and values of each node.
Creating a Binary Search Tree in Python

Now that we have discussed the time and space complexities of BSTs, let’s
take a look at how to implement one in Python.
We will start by creating a Node class that will be the building blocks of our
BST. The Node class will contain two fields: a key and a value. It will also
contain a reference to the left and right children of the node.
class Node:
def __init__(self, key, value):
self.key = key
self.value = value
self.left = None
self.right = None
Next, we will create a BinarySearchTree class that will contain the logic for
inserting, searching, and deleting nodes from our BST. The
BinarySearchTree class will contain a reference to the root node of the tree.
class BinarySearchTree:
def __init__(self):
self.root = None
Now we can implement the insert(), search(), and delete() methods.
The insert() method will take a key and a value and insert them into the
BST. The method will start by creating a new Node object with the key and
value. It will then traverse the BST to find the correct position for the new
node.

# Create a new node
new_node = Node(key, value)
# Check if the tree is empty
if self.root is None:
self.root = new_node
return
# Traverse the tree to find the correct position
current_node = self.root
if key < current_node.key:
# Go left
if current_node.left is None:
current_node.left = new_node
return
else:
current_node = current_node.left
else:
# Go right
if current_node.right is None:
current_node.right = new_node
return
else:
current_node = current_node.right
The search() method will take a key and search for it in the BST. It will start
by checking if the tree is empty. If the tree is not empty, it will traverse the
tree to find the node with the given key.
def search(self, key):

# Check if the tree is empty
return None
# Traverse the tree to find the node with the given key
if key == current_node.key:
return current_node
elif key < current_node.key:
current_node = current_node.left
else:
current_node = current_node.right
# Node with given key was not found
return None
The delete() method will take a key and delete the node with the given key
from the tree. It will start by searching for the node with the given key. If
the node is found, the method will delete the node and update the pointers
of the parent and child nodes accordingly.
def delete(self, key):

# Search for the node with the given key
node_to_delete = self.search(key)
if node_to_delete is None:
# Node with given key was not found
return
# Check if node to be deleted has no children
if node_to_delete.left is None and node_to_delete.right is None:
# Check if node to be deleted is root
if node_to_delete == self.root:
self.root = None
return
# Find parent node
parent = self._find_parent(key)
# Update parent node's pointer
if parent.left == node_to_delete:
parent.left = None
else:
parent.right = None
return
# Node to be deleted has one child
if node_to_delete.left is None or node_to_delete.right is None:
# Check if node to be deleted is root
if node_to_delete == self.root:
# Check if node to be deleted has a left child
if node_to_delete.left is not None:
self.root = node_to_delete.left
# Node to be deleted has a right child
else:
self.root = node_to_delete.right
return
# Find parent node
parent = self._find_parent(key)
# Check if node to be deleted has a left child
if node_to_delete.left is not None:
parent.left = node_to_delete.left
else:
parent.right = node_to_delete.left
return
# Node to be deleted has a right child
else:
parent.left = node_to_delete.right
else:
parent.right = node_to_delete.right
return
# Node to be deleted has two children
if node_to_delete.left is not None and node_to_delete.right is not None:
# Find the in-order successor of the node to be deleted
successor = self._find_successor(node_to_delete)
# Copy the successor's key and value to the node to be deleted
node_to_delete.key = successor.key
node_to_delete.value = successor.value
# Find the parent node of the successor
parent = self._find_parent(successor.key)
# Delete the successor
if parent.left == successor:
parent.left = None
else:
parent.right = None
return
Conclusion
In this article, we discussed the time and space complexities associated with
Binary Search Trees (BSTs) and how to implement them in Python. We
discussed the time complexities of BSTs for accessing, searching, inserting,
and deleting nodes. We also discussed the space complexity of BSTs.
Finally, we provided code examples for creating a BST and implementing
the insert(), search(), and delete() methods.
Exercises
What is the time complexity of searching a BST?
What is the time complexity of inserting a node into a BST?
What is the time complexity of deleting a node from a BST?
What is the space complexity of a BST?
What is the difference between a BST and a binary tree?
Solutions
What is the time complexity of searching a BST?
The time complexity of searching a BST is O(log n), where n is the number
of nodes in the tree.
What is the time complexity of inserting a node into a BST?

The time complexity of inserting a node into a BST is O(log n), where n is
the number of nodes in the tree.
What is the time complexity of deleting a node from a BST?

The time complexity of deleting a node from a BST is O(log n), where n is
the number of nodes in the tree.
What is the space complexity of a BST?

The space complexity of a BST is O(n), where n is the number of nodes in
the tree.
What is the difference between a BST and a binary tree?

The difference between a BST and a binary tree is that a BST must have the
property that the key of each node must be greater than or equal to the key
of the left child and less than or equal to the key of the right child. A binary
tree is a collection of nodes arranged in a hierarchical structure and does not
have this property.
CARTESIAN TREES
(TREAP)
Cartesian trees, also known as Treap (tree + heap) are a type of binary
search tree that offers a combination of the performance of a self-balancing
tree with the efficiency of a heap. Cartesian trees are used to store and
organize data in a way that allows for quick access, search, insertion, and
deletion. This makes them one of the most efficient data structures for
dealing with large datasets. In this article, we will explore the time and
space complexities associated with access, search, insertion, and deletion in
Cartesian trees. We will also provide coding examples to illustrate how
these operations are performed in Python.
What is a Cartesian Tree?

A Cartesian tree is a binary tree that consists of a root node and two
subtrees, each of which is also a Cartesian tree. Each node in the tree stores
a value, and the elements in a Cartesian tree are arranged according to a
specific ordering rule. The Cartesian tree is typically constructed using a
heap-ordered tree structure, with the root node having the highest priority.
Each node in the tree has a priority which is used to determine the ordering
of the elements.
How does Cartesian Trees Work?

Cartesian Trees are a data structure used to store binary search trees (BSTs)
in an array. A Cartesian Tree consists of a root node and a number of other
nodes representing the elements that make up the BST. Each node has three
fields:
The value of the node

The index of its left child
The index of its right child
The root node is always located at index 0. The left and right child nodes of
each node can be determined by knowing the index of the node and its left
and right child values.
Cartesian Trees are used to speed up certain operations on BSTs. For

example, searching for a particular element can be done in O(log n) time
instead of O(n) time with a regular BST. This is because the nodes of the
Cartesian Tree are stored in an array, which allows for quicker access than a
regular BST.
To build a Cartesian Tree, one must first build a BST using the standard
insertion and deletion algorithms. Once the BST is built, the root node is
placed at index 0 and the remaining nodes are placed in the array in an in-
order fashion. For example, if the BST contains the elements 5, 3, 8, 7, 6, 4,
then the array would be [5, 3, 4, 8, 6, 7]. Then, the left and right child
indices for each node can be determined. For example, the left child of the
root node (5) is 3 and the right child is 8.
Once the tree is built, the same operations that can be performed on a
regular BST (such as searching, insertion, and deletion) can be performed
on the Cartesian Tree.
Time Complexity for Access, Search, Insertion,

and Deletion
Access
Accessing an element in a Cartesian tree has an average time complexity of
O(log n). This means that the time required to access an element increases
logarithmically with the size of the tree.
Search
Searching for an element in a Cartesian tree has an average time complexity
of O(log n). This means that the time required to search for an element in
the tree increases logarithmically with the size of the tree.
Insertion
Inserting an element into a Cartesian tree has an average time complexity of
O(log n). This means that the time required to insert an element into the tree
increases logarithmically with the size of the tree.
Deletion
Deleting an element from a Cartesian tree has an average time complexity
of O(log n). This means that the time required to delete an element from the
tree increases logarithmically with the size of the tree.
Worst Case Time Complexity for Access, Search,

Insertion, and Deletion
Access
The worst case time complexity for accessing an element in a Cartesian tree
is O(n). This means that the time required to access an element may
increase linearly with the size of the tree.
Search
The worst case time complexity for searching for an element in a Cartesian
tree is O(n). This means that the time required to search for an element in
the tree may increase linearly with the size of the tree.
Insertion
The worst case time complexity for inserting an element into a Cartesian
tree is O(n). This means that the time required to insert an element into the
tree may increase linearly with the size of the tree.
Deletion
The worst case time complexity for deleting an element from a Cartesian
tree is O(n). This means that the time required to delete an element from the
tree may increase linearly with the size of the tree.
Space Complexity
The space complexity for a Cartesian tree is O(n). This means that the
amount of space required for the tree is proportional to the size of the tree.
Python Implementation
In this section, we will provide coding examples in Python that demonstrate
how to create and manipulate Cartesian trees.
Creating a Cartesian Tree

We will start by creating a simple Cartesian tree in Python.
class Node:
def __init__(self, val):
self.val = val
self.left = None
self.right = None
class CartesianTree:
def __init__(self):
self.root = None
def insert(self, val):
# Create a new node
newNode = Node(val)
# Base Case
self.root = newNode
return
# Traverse and find the correct position
temp = self.root
while temp is not None:
if newNode.val < temp.val:
if temp.left is None:
temp.left = newNode
return
else:
temp = temp.left
else:
if temp.right is None:
temp.right = newNode
return
else:
temp = temp.right
In the above code, we create a Node class that contains the data associated
with each node in the tree. We then create a CartesianTree class, which
contains the methods for manipulating the tree. The insert() method is used
to add a node to the tree. It first checks to see if the tree is empty, and if so
it creates a new node and assigns it to the root. Otherwise, it traverses the
tree to find the correct position for the new node.
Searching in a Cartesian Tree

Next, we will demonstrate how to search for an element in a Cartesian tree.
def search(self, val):

# Base Case
return False
# Traverse and search for the element
temp = self.root
while temp is not None:
if temp.val == val:
return True
elif val < temp.val:
temp = temp.left
else:
temp = temp.right
return False
The search() method is used to search for an element in the tree. It first
checks to see if the tree is empty, and if so it returns False. Otherwise, it
traverses the tree to search for the element. If the element is found, it
returns True; otherwise, it returns False.
Deleting from a Cartesian Tree

Finally, we will demonstrate how to delete an element from a Cartesian
tree.
def delete(self, val):

# Base Case
return
# Find the node to be deleted
temp = self.root
parent = None
while temp is not None and temp.val != val:
parent = temp
if val < temp.val:
temp = temp.left
else:
temp = temp.right
# If node to be deleted is not found
if temp is None:
return
# If node to be deleted has one child
if parent is None:
self.root = temp.right
elif temp is parent.left:
parent.left = temp.right
else:
parent.right = temp.right
# If node to be deleted has two children
elif temp.right is None:
if parent is None:
self.root = temp.left
parent.left = temp.left
else:
parent.right = temp.left
else:
successor = temp.right
while successor.left is not None:
successor = successor.left
temp.val = successor.val
if successor is temp.right:
temp.right = successor.right
else:
successorParent.left = successor.right
The delete() method is used to delete an element from the tree. It first finds
the node to be deleted and its parent. If the node to be deleted has one child,
it deletes the node and assigns its child to the parent. If the node to be
deleted has two children, it finds the in-order successor of the node and
deletes it.
Conclusion
In this article, we have explored the time and space complexities associated
with access, search, insertion, and deletion in Cartesian trees. We have also
provided coding examples in Python to illustrate how these operations are
performed. Cartesian trees are a powerful data structure that are used to
store and organize data in a way that allows for quick access, search,
insertion, and deletion. Coding
Exercises
Write a function to traverse a Cartesian tree in pre-order.
Write a function to traverse a Cartesian tree in post-order.
Write a function to traverse a Cartesian tree in-order.
Write a function to search for an element in a Cartesian tree.
Write a function to delete an element from a Cartesian tree.
Solutions
Write a function to traverse a Cartesian tree in pre-order.
def preOrder(root):
if root is not None:
print root.val
preOrder(root.left)
preOrder(root.right)
Write a function to traverse a Cartesian tree in post-order.
def postOrder(root):
postOrder(root.left)
postOrder(root.right)
print root.val
Write a function to traverse a Cartesian tree in-order.
def inOrder(root):
inOrder(root.left)
print root.val
inOrder(root.right)
Write a function to search for an element in a Cartesian tree.
def search(root, val):
if root is None:
return False
if root.val == val:
return True
elif val < root.val:
return search(root.left, val)
else:
return search(root.right, val)
Write a function to delete an element from a Cartesian tree.
def delete(root, val):
# Base Case
if root is None:
return
# Find the node to be deleted
temp = root
parent = None
while temp is not None and temp.val != val:
parent = temp
if val < temp.val:
temp = temp.left
else:
temp = temp.right
# If node to be deleted is not found
if temp is None:
return
# If node to be deleted has one child
if parent is None:
root = temp.right
parent.left = temp.right
else:
parent.right = temp.right
elif temp.right is None:
if parent is None:
root = temp.left
parent.left = temp.left
else:
parent.right = temp.left
else:
successor = temp.right
while successor.left is not None:
successor = successor.left
temp.val = successor.val
if successor is temp.right:
temp.right = successor.right
else:
successorParent.left = successor.right
B-TREES
B-trees are a type of self-balancing tree structure used to store a large
amount of data in an organized fashion. They are widely used in databases,
file systems, and other applications where the storage of large amounts of
data is required. B-trees are particularly useful when the data must be
accessed quickly, as they provide efficient search, insertion, and deletion
operations. In this article, we will look at the time and space complexity of
B-trees and discuss how to implement them in the Python programming
language. We will also provide coding examples and exercises so that
readers can test their understanding of the concepts presented.
What is a B-Tree?
A B-tree is a type of tree data structure that stores data in a hierarchical
fashion. It is composed of nodes, which are connected by edges. Each node
contains a key, which is used to locate the data in the tree. B-trees have the
following characteristics:
Each node can have a maximum of two children.

There are no more than two children per node.
All nodes at the same level of a B-tree have the same number of
children.
All leaf nodes are at the same level.
All nodes contain at least two keys.
A B-tree is a type of self-balancing tree structure, which means that it can

reorganize its structure as needed to maintain an optimal balance. This
makes B-trees very efficient when it comes to search, insertion, and
deletion.
How does B-Trees Work?

A B Tree is a self-balancing tree data structure that is commonly used to
store and manage large amounts of data. It is an extension of a binary tree,
where each node can have an arbitrary number of children, rather than just
two.
B Trees are used to store data in an ordered fashion, so that it can be

quickly retrieved when needed. This is done by organizing the data into
nodes, where each node contains a set of values and pointers to other nodes.
The structure of a B Tree is based around a root node, which is the topmost
node in the tree. Each node in the tree has two or more subtrees, which are
further divided into nodes. Each node contains a range of values, and the
values are sorted in order.
When a value is inserted into a B Tree, the tree is rearranged to maintain

balance. This is done by comparing the values in the node with the value
being added, and shifting the nodes around until the tree is balanced. This
means that the data is stored in sorted order, which makes it much easier to
search for and retrieve data.
When searching for data in a B Tree, the root node is used as a starting
point. The data is then searched for in each subtree, and once the desired
value is found, it is returned. This process is much faster than searching for
data in a binary tree, since the tree is already in sorted order.
B Trees are used in a wide variety of applications, including databases, file

systems, and operating systems. They are also used to store large amounts
of data, such as in databases or file systems. Since the tree is already in
sorted order, it is much faster to search for and retrieve data.
Time Complexity of B-trees

The time complexity of a B-tree is the amount of time it takes to perform a
certain operation on the tree. The time complexity for accessing, searching,
inserting, and deleting in a B-tree is as follows:
Access: The average time complexity for accessing a node in a B-tree is

O(log n), where n is the number of nodes in the tree. The worst-case time
complexity for accessing a node is O(n).
Search: The average time complexity for searching a node in a B-tree is

O(log n). The worst-case time complexity for searching a node is O(n).
Insertion: The average time complexity for inserting a node in a B-tree is

O(log n). The worst-case time complexity for inserting a node is O(n).
Deletion: The average time complexity for deleting a node in a B-tree is

O(log n). The worst-case time complexity for deleting a node is O(n).
Space Complexity of B-trees

The space complexity of a B-tree is the amount of space it takes to store
data in the tree. The space complexity for a B-tree is O(n), where n is the
number of nodes in the tree. This means that the amount of space required
by a B-tree increases linearly with the number of nodes.
Implementing B-trees in Python

Now that we have discussed the time and space complexity of B-trees, let’s
look at how to implement them in Python. We will create a B-tree class that
contains the following methods:
insert(key): This method will insert a new node with the given
key into the B-tree.
search(key): This method will search for a node with the given
key in the B-tree and return it if it is found.
delete(key): This method will delete a node with the given key
from the B-tree.
The following is the code for the B-tree class:
class B_Tree:
def __init__(self):
self.root = None
def insert(self, key):
if self.root == None:
self.root = Node(key)
else:
self._insert(key, self.root)
def _insert(self, key, current_node):
if key < current_node.key:
if current_node.has_left_child():
self._insert(key, current_node.left_child)
else:
current_node.left_child = Node(key)
else:
if current_node.has_right_child():
self._insert(key, current_node.right_child)
else:
current_node.right_child = Node(key)
if self.root != None:
return self._search(key, self.root)
else:
return None
def _search(self, key, current_node):
if not current_node:
return None
elif current_node.key == key:
return current_node
return self._search(key, current_node.left_child)
else:
return self._search(key, current_node.right_child)
if self.root != None:
self.root = self._delete(key, self.root)
def _delete(self, key, current_node):
if not current_node:
return None
elif current_node.key == key:
if current_node.is_leaf():
return None
elif current_node.has_both_children():
min_node = current_node.find_min()
current_node.key = min_node.key
current_node.right_child = self._delete(min_node.key,
current_node.right_child)
else:
if current_node.has_left_child():
return current_node.left_child
else:
return current_node.right_child
current_node.left_child = self._delete(key, current_node.left_child)
else:
current_node.right_child = self._delete(key,
current_node.right_child)
return current_node
Conclusion
In this article, we have discussed the time and space complexity of B-trees
and how to implement them in Python. B-trees are a type of self-balancing
tree structure that can store large amounts of data in an organized manner.
They provide efficient search, insertion, and deletion operations and have
an average time complexity of O(log n) and a space complexity of O(n). We
have also provided coding examples and exercises so that readers can test
their understanding of the concepts presented.
Exercises
Write a function that takes a B-tree and a key as parameters and
returns the node with the given key, if it exists.
inserts a new node with the given key into the tree.
deletes the node with the given key from the tree.
Write a function that takes a B-tree as a parameter and returns the
minimum key in the tree.
maximum key in the tree.
Solutions
returns the node with the given key, if it exists.
def search(tree, key):
if tree.root != None:
return tree._search(key, tree.root)
else:
return None
inserts a new node with the given key into the tree.
def insert(tree, key):
if tree.root == None:
tree.root = Node(key)
else:
tree._insert(key, tree.root)
deletes the node with the given key from the tree.
def delete(tree, key):
if tree.root != None:
tree.root = tree._delete(key, tree.root)
minimum key in the tree.
def find_min(tree):
return None
else:
return tree.root.find_min()
maximum key in the tree.
def find_max(tree):
return None
else:
return tree.root.find_max()
RED-BLACK TREES
Red-black trees are a type of self-balancing binary search tree. This means
that they are a data structure which consists of nodes that have up to two
children. Each node contains a key and a value, and each node’s key is
greater than the key of its left child and less than the key of its right child.
They are often used in applications such as databases, operating systems,
and search engines. Red-black trees have several advantages over other
types of trees, such as being more efficient in terms of time and space
complexity, and providing faster search and insertion operations.
Time Complexity of Red-black Trees

Red-black trees have an average time complexity of O(log n) for access,
search, insertion, and deletion operations. This means that the time it takes
for these operations is proportional to the logarithm of the number of nodes
in the tree. The worst case time complexity of these operations is O(log n).
This means that the time it takes to perform these operations is proportional
to the logarithm of the maximum number of nodes in the tree.
How does Red-Black Trees Work?

Red-Black Trees (RBTs) are a type of self-balancing binary search tree that
is used to store and quickly retrieve data. RBTs are an efficient data
structure for maintaining an ordered set of elements.
Red-Black Trees (RBTs) are a type of self-balancing binary search tree that
is used to store and quickly retrieve data. RBTs are an efficient data
structure for maintaining an ordered set of elements.
RBTs have the following properties:
Each node is either red or black. 2.

The root node is always black. 3.
All leaves (null nodes) are black. 4.
Both children of every red node are black. 5.
Every path from a node to a descendant leaf has the same
number of black nodes.
RBTs also maintain the ordering of the data. The data is sorted into the tree
according to a certain comparison function. In an RBT, when a node is
inserted, the tree is rebalanced to make sure the properties of the tree are
maintained.
When a node is inserted, the rules of the RBT are checked to see if they are
violated. If they are violated, the tree is rebalanced to restore the properties.
There are two types of rebalancing that can be done on an RBT: rotation
and recoloring.
Rotation is the process of moving a node from one position in the tree to
another in order to restore the balance. This is done by rotating the nodes
around the tree so that the structure is maintained.
Recoloring is the process of changing the color of a node from red to black
or from black to red. This is done to restore the properties of the tree.
RBTs are a very efficient data structure for maintaining an ordered set of
elements. They provide quick insertion, deletion, and lookup of elements.
They also maintain the order of the data and can be quickly rebalanced
when needed.
Space Complexity of Red-black Trees

The worst case space complexity of red-black trees is O(n). This means that
the amount of memory needed to store the tree is proportional to the
number of nodes in the tree.
In order to demonstrate the time and space complexity of red-black trees,
we will look at a few coding examples.
Access Operation
In this example, we will look at the time complexity for an access operation
on a red-black tree. We will use the following code to access a node with a
key of 10 in a red-black tree with 10 nodes.
def access(key):
current = root
while current is not None:
if current.key == key:
return current
elif current.key > key:
current = current.left
else:
current = current.right
return None
In this example, the time complexity of the access operation is O(log n).
This is because, in the worst case, the access operation takes log n steps to
traverse the tree.
Search Operation
In this example, we will look at the time complexity for a search operation
on a red-black tree. We will use the following code to search for a node
with a key of 10 in a red-black tree with 10 nodes.
def search(key):
current = root
return True
else:
return False
In this example, the time complexity of the search operation is O(log n).
This is because, in the worst case, the search operation takes log n steps to
traverse the tree.
Insertion Operation
In this example, we will look at the time complexity for an insertion
operation on a red-black tree. We will use the following code to insert a
node with a key of 10 in a red-black tree with 10 nodes.
def insert(key):
current = root
parent = None
parent = current
if current.key > key:
else:
new_node = Node(key)
if parent is None:
root = new_node
elif parent.key > key:
parent.left = new_node
else:
parent.right = new_node
In this example, the time complexity of the insertion operation is O(log n).
This is because, in the worst case, the insertion operation takes log n steps
to traverse the tree.
Deletion Operation
In this example, we will look at the time complexity for a deletion operation
on a red-black tree. We will use the following code to delete a node with a
key of 10 in a red-black tree with 10 nodes.
def delete(key):
current = root
parent = None
break
parent = current
else:
parent = current
if current is None:
return
# Case 1: Node is a leaf
if current.left is None and current.right is None:
if parent is None:
root = None
elif parent.left == current:
parent.left = None
else:
parent.right = None
# Case 2: Node has one child
elif current.left is None:
if parent is None:
root = current.right
parent.left = current.right
else:
parent.right = current.right
elif current.right is None:
if parent is None:
root = current.left
parent.left = current.left
else:
parent.right = current.left
# Case 3: Node has two children
else:
successor = get_successor(current)
if parent is None:
root = successor
parent.left = successor
else:
parent.right = successor
successor.left = current.left
In this example, the time complexity of the deletion operation is O(log n).
This is because, in the worst case, the deletion operation takes log n steps to
traverse the tree.
Conclusion
In conclusion, red-black trees are a type of self-balancing binary search tree
that have an average time complexity of O(log n) for access, search,
insertion, and deletion operations, and a worst case time complexity of
O(log n). They also have a worst case space complexity of O(n). This
makes red-black trees a popular choice for applications such as databases,
operating systems, and search engines.
Exercises
Implement a function to search an element in a Red-Black Tree using
Python.
Write a function to delete a node from a Red-Black Tree in Python.
Write a function to find the maximum value in a Red-Black Tree using
Python.
Implement a function to insert a node into a Red-Black Tree using
Python.
Write a function to traverse a Red-Black Tree in order using Python.
Solutions
Implement a function to search an element in a Red-Black Tree using
Python.
def search_rb_tree(node, key):
if node is None or node.key == key:
return node
if key < node.key:
return search_rb_tree(node.left, key)
return search_rb_tree(node.right, key)
Write a function to delete a node from a Red-Black Tree in Python.
def delete_rb_tree_node(node, key):
if node is None:
return node
if key < node.key:
node.left = delete_rb_tree_node(node.left, key)
elif key > node.key:
node.right = delete_rb_tree_node(node.right, key)
else:
if node.left is None:
temp = node.right
node = None
return temp
elif node.right is None:
temp = node.left
node = None
return temp
temp = min_value_node(node.right)
node.key = temp.key
node.right = delete_rb_tree_node(node.right, temp.key)
return node
Write a function to find the maximum value in a Red-Black Tree using
Python.
def max_value_rb_tree(node):
if node is None:
return -1
current = node
while current.right is not None:
return current.key
Implement a function to insert a node into a Red-Black Tree using
Python.
def insert_rb_tree_node(root, key):
if root is None:
return Node(key)
if root.key > key:
root.left = insert_rb_tree_node(root.left, key)
else:
root.right = insert_rb_tree_node(root.right, key)
return root
Write a function to traverse a Red-Black Tree in order using Python.
def traverse_rb_tree(node):
if node is None:
return
traverse_rb_tree(node.left)
print(node.key)
traverse_rb_tree(node.right)
SPLAY TREES
Data structures and algorithms with Python is a great course to learn the
fundamentals of data structures and algorithms. One of the data structures
covered in this course is the splay tree. A splay tree is a self-balancing data
structure that is an extension of the binary search tree. Splay trees are useful
because they provide efficient access to elements while also supporting
insertions and deletions. In this article, we will discuss the time and space
complexity of splay trees when performing access, search, insertion, and
deletion operations. We will also provide Python code to illustrate the
concepts we discuss.
What are Splay Trees?

A splay tree is a binary search tree with a special property. Whenever an
element is accessed (whether for searching, insertion, or deletion), the
element is moved to the root of the tree. This property, known as the splay
operation, is what makes splay trees self-balancing. While a regular binary
search tree can become unbalanced if its elements are accessed in a certain
order, a splay tree will remain balanced no matter what order the elements
are accessed in.
How does Splay Trees Work?

Splay Trees, also known as self-adjusting search trees, are a type of binary
search tree that rearranges recently accessed nodes to the root of the tree.
The idea behind Splay Trees is to make recently accessed elements easier to
access in the future. This is done by restructuring the tree after each node
access.
The restructuring of the tree is done through a series of rotations. The type
of rotation used depends on the location of the accessed node. After each
rotation, the tree is balanced so that the distance from the root to any of its
leaves is approximately equal.
There is a variety of operations that can be performed on Splay Trees,
including insert, delete, search, min, max, and predecessor/successor. When
an element is inserted into the tree, the tree is restructured to make the
newly inserted element the root of the tree. When an element is deleted, the
tree is restructured so that the node’s parent is the new root.
The search operation finds the node with the requested value and makes it
the root of the tree. The min, max, predecessor and successor operations
also find the requested node and make it the root.
Splay Trees provide efficient access to recently accessed elements, making

them an ideal choice for applications that require fast access to recently
used elements.
Time Complexity
The time complexity of splay trees is best discussed in terms of the
operations we can perform on them. We will cover the average and worst-
case time complexity for access, search, insertion, and deletion.
Access Time Complexity

The average time complexity for accessing an element in a splay tree is
O(log n). This is the same as the average time complexity of a regular
binary search tree. The worst-case time complexity for accessing an
element in a splay tree, however, is O(n). This is because the element must
be moved to the root of the tree, which can take up to n steps if the element
is at the bottom of the tree.
Search Time Complexity

The average time complexity for searching an element in a splay tree is also
O(log n). This is because the splay operation will move the element to the
root of the tree, making it much easier to find. The worst-case time
complexity for searching an element in a splay tree is also O(n), as the
element must be moved to the root of the tree before it can be found.
Insertion Time Complexity

The time complexity for inserting an element into a splay tree is O(log n).
This is because the insertion process is similar to that of a regular binary
search tree, and the splay operation does not add additional time
complexity. The worst-case time complexity for insertion is also O(log n).
Deletion Time Complexity

The time complexity for deleting an element from a splay tree is also O(log
n). This is because the splay operation does not add any additional time
complexity, and the deletion process is similar to that of a regular binary
search tree. The worst-case time complexity for deletion is also O(log n).
Space Complexity
The space complexity of splay trees is O(n). This is the same as the space
complexity of a regular binary search tree.
Example in Python
Now that we have discussed the time and space complexity of splay trees,
let’s look at an example in Python. We will use the following code to create
a splay tree and insert, search, and delete elements from it.
# Create a class for the Node object

class Node:
self.data = data
self.left = None
self.right = None
# Create a class for the Splay Tree object
class SplayTree:
def __init__(self):
self.root = None
# Function to insert a node into the splay tree
def insert(self, data):
self.root = Node(data)
else:
self._insert(data, self.root)
# Helper function for insert
def _insert(self, data, cur_node):
if data < cur_node.data:
if cur_node.left is None:
cur_node.left = Node(data)
else:
self._insert(data, cur_node.left)
elif data > cur_node.data:
if cur_node.right is None:
cur_node.right = Node(data)
else:
self._insert(data, cur_node.right)
else:
print("Value already in tree!")
# Function to search for a node in the splay tree
def search(self, data):
if self.root:
return self._search(data, self.root)
else:
return False
# Helper function for search
def _search(self, data, cur_node):
if data > cur_node.data and cur_node.right:
return self._search(data, cur_node.right)
elif data < cur_node.data and cur_node.left:
return self._search(data, cur_node.left)
if data == cur_node.data:
return True
# Function to delete a node from the splay tree
def delete(self, data):
if self.root is not None:
self.root = self._delete(data, self.root)
# Helper function for delete
def _delete(self, data, cur_node):
if data > cur_node.data and cur_node.right:
cur_node.right = self._delete(data, cur_node.right)
elif data < cur_node.data and cur_node.left:
cur_node.left = self._delete(data, cur_node.left)
elif data == cur_node.data:
if cur_node.right is None:
return cur_node.left
elif cur_node.left is None:
return cur_node.right
else:
temp_node = cur_node.right
while temp_node.left:
temp_node = temp_node.left
cur_node.data = temp_node.data
cur_node.right = self._delete(temp_node.data, cur_node.right)
return cur_node
Conclusion
Splay trees are an efficient and self-balancing data structure. They provide
time complexity of O(log n) for access, search, insertion, and deletion
operations, as well as space complexity of O(n). With the example Python
code provided in this article, you should now be able to understand and
implement splay trees in your own programs.
Exercises
Write a function to count the number of nodes in a splay tree.
Write a function to find the maximum value in a splay tree.
Write a function to find the minimum value in a splay tree.
Write a function to calculate the height of a splay tree.
Write a function to traverse a splay tree in-order.
Solutions
Write a function to count the number of nodes in a splay tree.
def count_nodes(root):
if root is None:
return 0
return 1 + count_nodes(root.left) + count_nodes(root.right)
Write a function to find the maximum value in a splay tree.
def find_max(root):
if root is None:
return None
if root.right is None:
return root.data
return find_max(root.right)
Write a function to find the minimum value in a splay tree.
def find_min(root):
if root is None:
return None
return root.data
return find_min(root.left)
Write a function to calculate the height of a splay tree.
def height(root):
if root is None:
return -1
return 1 + max(height(root.left), height(root.right))
Write a function to traverse a splay tree in-order.
def in_order_traversal(root):
if root is None:
return
in_order_traversal(root.left)
print(root.data)
in_order_traversal(root.right)
AVL TREES
Data Structures and Algorithms with Python is a course that provides an in-
depth look at the different types of data structures and algorithms used in
programming. One of the key data structures covered in this course is the
AVL Tree. An AVL tree is a self-balancing binary search tree, which means
that it is a type of tree that is used to store data in an organized and efficient
manner. In this article, we will discuss the time and space complexity of
AVL trees, as well as provide examples of Python code to help illustrate the
concepts. We will also provide five coding exercises with solutions at the
end of the article to help test the reader’s understanding of the material.
What is an AVL Tree?

An AVL tree is a self-balancing binary search tree. This means that it is a
type of tree that is used to store data in an organized and efficient manner. It
is named after its inventors, Adelson-Velskii and Landis, who first
published their algorithm in 1962. An AVL tree is similar to a regular
binary search tree, but it has a few additional features that make it more
efficient.
The most important feature of an AVL tree is that it is self-balancing. This

means that when new data is inserted or deleted from the tree, it will
automatically balance itself to ensure that the tree remains as balanced and
efficient as possible. This is done by comparing the heights of the left and
right subtrees of each node in the tree and ensuring that the difference
between them is not greater than one. If it is, then the tree is rebalanced to
restore the balance.
How does AVL Trees Work?

In an AVL tree, each node stores a key and the associated data. Each node
also has a balance factor, which is the difference between the heights of the
left and right subtrees. The balance factor can be either -1, 0, or 1. If the
balance factor is negative, the node is considered left-heavy; if it is positive,
the node is considered right-heavy; and if it is 0, the node is balanced.
The AVL tree works by maintaining the balance factor of each node. When
a node is inserted or deleted, the balance factor of the node and its children
is recalculated. If the balance factor of any node is greater than 1 (right-
heavy) or less than -1 (left-heavy), the tree is considered unbalanced and
needs to be rebalanced.
To rebalance the tree, the AVL tree rotates the subtrees around the node
with the unbalanced balance factor. This ensures that the balance factor of
each node is always between -1 and 1.
AVL trees are used in a variety of applications, including databases, file

systems, and search engines. They are a popular choice for data structures
because they can provide quick access to data and can quickly be
rebalanced when needed.
Time Complexity
Now that we have discussed what an AVL tree is, let’s look at the time
complexity of access, search, insertion, and deletion in an AVL tree.
Access
Accessing an element in an AVL tree has an average time complexity of
O(log n) and a worst-case time complexity of O(n). This is because the tree
is self-balancing and it takes time to traverse the tree in order to find the
desired element.
Search
Searching for an element in an AVL tree has an average time complexity of
desired element.
Insertion
Inserting an element into an AVL tree has an average time complexity of
correct position for the new element.
Deletion
Deleting an element from an AVL tree has an average time complexity of
desired element and then delete it.
Space Complexity
The space complexity of an AVL tree is O(n), which means that it requires
O(n) memory to store all the elements in the tree. This is because each node
in the tree requires a certain amount of memory in order to store the data
and the pointers to its left and right subtrees.
Examples of Python Code

Now that we have discussed the time and space complexity of AVL trees,
let’s look at some examples of Python code to help illustrate these
concepts.
Inserting an Element
The following code shows how to insert an element into an AVL tree.

self.root = self._insert_helper(self.root, key)
def _insert_helper(self, root, key):
if root is None:
return Node(key)
if key < root.data:
root.left = self._insert_helper(root.left, key)
else:
root.right = self._insert_helper(root.right, key)
root.height = 1 + max(self.get_height(root.left),
self.get_height(root.right))
balance = self.get_balance(root)
# Case 1: Left Left
if balance > 1 and key < root.left.data:
return self._right_rotate(root)
# Case 2: Right Right
if balance < -1 and key > root.right.data:
return self._left_rotate(root)
# Case 3: Left Right
if balance > 1 and key > root.left.data:
root.left = self._left_rotate(root.left)
# Case 4: Right Left
if balance < -1 and key < root.right.data:
root.right = self._right_rotate(root.right)
return root
Deleting an Element
The following code shows how to delete an element from an AVL tree.

self.root = self._delete_helper(self.root, key)
def _delete_helper(self, root, key):
if root is None:
return root
if key < root.data:
root.left = self._delete_helper(root.left, key)
elif key > root.data:
root.right = self._delete_helper(root.right, key)
else:
temp = root.right
root = None
return temp
temp = root.left
root = None
return temp
temp = self.get_min_value_node(root.right)
root.data = temp.data
root.right = self._delete_helper(root.right, temp.data)
if root is None:
return root
# Case 1: Left Left
if balance > 1 and self.get_balance(root.left) >= 0:
if balance < -1 and self.get_balance(root.right) <= 0:
if balance > 1 and self.get_balance(root.left) < 0:
if balance < -1 and self.get_balance(root.right) > 0:
return root
Conclusion
In conclusion, an AVL tree is a self-balancing binary search tree that is used
to store data in an organized and efficient manner. It has an average time
complexity of O(log n) for access, search, insertion, and deletion, and a
worst-case time complexity of O(n). It also has a space complexity of O(n).
We have provided examples of Python code to help illustrate the concepts
discussed in this article. Finally, we have provided five coding exercises
with solutions at the end of the article to help test the reader’s
understanding of the material.
Exercises
Write a function to insert an element into an AVL tree.
Write a function to delete an element from an AVL tree.
Write a function to search for an element in an AVL tree.
Write a function to access an element in an AVL tree.
Write a function to calculate the height of an AVL tree.
Solutions
Write a function to insert an element into an AVL tree.
self.root = self._insert_helper(self.root, key)
def _insert_helper(self, root, key):
if root is None:
return Node(key)
if key < root.data:
root.left = self._insert_helper(root.left, key)
else:
root.right = self._insert_helper(root.right, key)
# Case 1: Left Left
if balance > 1 and key < root.left.data:
if balance < -1 and key > root.right.data:
if balance > 1 and key > root.left.data:
if balance < -1 and key < root.right.data:
return root
Write a function to delete an element from an AVL tree.
self.root = self._delete_helper(self.root, key)
def _delete_helper(self, root, key):
if root is None:
return root
if key < root.data:
root.left = self._delete_helper(root.left, key)
elif key > root.data:
root.right = self._delete_helper(root.right, key)
else:
temp = root.right
root = None
return temp
temp = root.left
root = None
return temp
temp = self.get_min_value_node(root.right)
root.data = temp.data
root.right = self._delete_helper(root.right, temp.data)
if root is None:
return root
# Case 1: Left Left
if balance > 1 and self.get_balance(root.left) >= 0:
if balance < -1 and self.get_balance(root.right) <= 0:
if balance > 1 and self.get_balance(root.left) < 0:
if balance < -1 and self.get_balance(root.right) > 0:
return root
Write a function to search for an element in an AVL tree.
return self._search_helper(self.root, key)
def _search_helper(self, root, key):
if root is None or root.data == key:
return root
if key < root.data:
return self._search_helper(root.left, key)
else:
return self._search_helper(root.right, key)
Write a function to access an element in an AVL tree.
def access(self, key):
return self._access_helper(self.root, key)
def _access_helper(self, root, key):
if root is None or root.data == key:
return root.data
if key < root.data:
return self._access_helper(root.left, key)
else:
return self._access_helper(root.right, key)
Write a function to calculate the height of an AVL tree.
def get_height(self, root):
if root is None:
return -1
return root.height
K-DIMENSIONAL (K-D)
TREES
KD Trees (also known as K-Dimensional Trees or K-D Trees) are a type of
data structure used for efficient searching in multidimensional spaces. KD
Trees are used in many applications including computer graphics, image
processing, medical image analysis, machine learning, and data mining. In
this article, we will discuss the advantages of KD Trees, the time and space
complexities of common operations on KD Trees, and how to implement a
KD Tree in Python. We will also cover five coding exercises to test your
What is a KD Tree?
A KD Tree is a binary search tree that stores data points in k-dimensional
space. A KD Tree is a tree data structure that is used to quickly search for
points in a k-dimensional space, such as a 3D space. To search for a point in
a KD Tree, the tree is navigated by comparing the query point to the data
points stored in the nodes. Each node contains a point in k-dimensional
space and a hyperplane that divides the space into two regions. The search
begins at the root node and progresses down the tree by comparing the
query point to the data point in the node. If the query point is on one side of
the hyperplane, the search continues in the corresponding subtree. If the
query point is on the other side, the search continues in the other subtree.
How does K-Dimensional Trees Work?

K-Dimensional Trees (K-D Trees) is a data structure used for organizing
and storing data points in a k-dimensional space. The data points can be
organized in a hierarchical tree structure, with the root node representing
the entire data set and each successive level representing a subset of the
original data set.
K-D Trees are a type of spatial indexing structure, meaning that they are
used to quickly identify which points in the data set are closest to a given
point. To build a K-D Tree, the data points are first grouped according to
their coordinate values in each of the k-dimensions. For example, if the data
set contains points in three dimensions (x, y, z), then the points are grouped
according to their x-coordinate values, then by their y-coordinate values,
and then by their z-coordinate values.
The data points are then sorted into a binary tree structure. The root node of
the tree represents the entire data set and its children represent the subsets
of the data set that are split based on the coordinate values. Each node in the
tree has a left child and a right child. The left child of the node represents
the data points that have a lower coordinate value than the parent node,
while the right child represents the data points that have a higher coordinate
value than the parent node.
The K-D Tree can then be used for searching for points in the data set that
are close to a given point. To search for points in the data set, the search
algorithm begins at the root node and then traverses the tree structure,
comparing the coordinate values of the search point to the coordinate values
of the nodes in the tree. The algorithm continues to traverse the tree
structure until it reaches a node with a coordinate value that is greater than
or equal to the search point’s coordinate value. Once the algorithm reaches
this node, it can then search the tree for points that are close to the search
point.
The K-D Tree is a powerful tool for organizing and storing data points in a
k-dimensional space. It can be used to quickly identify the points in the data
set that are closest to a given point and is especially useful for applications
that require fast search operations.
Time and Space Complexity

The time and space complexities of KD Trees depend on the operations
being performed. In this section, we will discuss the time and space
complexities of common operations on KD Trees, including access, search,
insertion, and deletion.
Access
The time complexity of accessing an element in a KD Tree is O(log n) on
average and O(n) in the worst case. This is because the tree is organized in a
way that allows it to be quickly navigated, so the search time is proportional
to the height of the tree.
Search
The time complexity of searching for an element in a KD Tree is O(log n)
on average and O(n) in the worst case. This is because the tree is organized
in a way that allows it to be quickly navigated, so the search time is
proportional to the height of the tree.
Insertion
The time complexity of inserting an element into a KD Tree is O(log n) on
way that allows it to be quickly navigated, so the insertion time is
Deletion
The time complexity of deleting an element from a KD Tree is O(log n) on
way that allows it to be quickly navigated, so the deletion time is
Space Complexity
The space complexity of a KD Tree is O(n) in the worst case. This is
because the tree must store all of the data points and hyperplanes in the tree,
so the space complexity is proportional to the number of points stored in the
tree.
Implementing a KD Tree in Python

In this section, we will discuss how to implement a KD Tree in Python. We
will use the following class to represent a KD Tree node:
class Node:
def __init__(self, point, left=None, right=None):
self.point = point
self.left = left
self.right = right
The point attribute stores the data point stored in the node. The left and
right attributes store the left and right subtrees.
To create a KD Tree, we will use a recursive function to add nodes to the

tree. The function takes a list of points and the current depth as input and
returns a KD Tree.
def create_kd_tree(points, depth=0):

n = len(points)
# Base Case
if n == 0:
return None
# Select the axis based on the current depth
axis = depth % len(points[0])
# Sort the points based on the axis
points.sort(key=lambda point: point[axis])
# Find the median point
mid = n//2
# Create the node
node = Node(points[mid])
# Recursively create the left and right subtrees
node.left = create_kd_tree(points[:mid], depth+1)
node.right = create_kd_tree(points[mid+1:], depth+1)
# Return the node
return node
The function takes a list of points and the current depth as input and returns
a KD Tree. The current depth is used to select the axis that the points will
be sorted on. The points are sorted and the median point is selected. The
median point is used to create a node and the left and right subtrees are
created by recursively calling the function with the left and right halves of
the list of points.
Conclusion
KD Trees are a powerful data structure for efficient searching in
multidimensional spaces. They have excellent time and space complexities
for common operations and can be easily implemented in Python. In this
article, we covered the advantages of KD Trees, the time and space
complexities of common operations on KD Trees, and how to implement a
KD Tree in Python.
Exercises
Write a function that takes a KD Tree and a point and returns the
nearest neighbor in the tree.
Write a function that takes a KD Tree and a range and returns all of
the points in the range.
parent of the node containing the point.
Write a function that takes a KD Tree and two points and returns the
lowest common ancestor of the two points.
depth of the node containing the point.
Solutions
nearest neighbor in the tree.
def find_nearest_neighbor(kd_tree, point):
# Initialize the best distance and best node
best_dist = float('inf')
best_node = None
# Start the search at the root node
node = kd_tree
# Loop until a leaf node is reached
while node is not None:
# Calculate the distance between the query point and the current node
dist = distance(point, node.point)
# Update the best distance and best node if necessary
if dist < best_dist:
best_dist = dist
best_node = node
# Select the subtree to search
axis = depth % len(point)
if point[axis] < node.point[axis]:
node = node.left
else:
node = node.right
# Return the best node
return best_node
Write a function that takes a KD Tree and a range and returns all of
the points in the range.
def find_points_in_range(kd_tree, start, end):
# Initialize an empty list
points = []
node = kd_tree
# Check if the current node is in range
if start <= node.point <= end:
points.append(node.point)
if start[axis] <= node.point[axis]:
node = node.left
else:
node = node.right
# Return the list of points
return points
parent of the node containing the point.
def find_parent(kd_tree, point):
# Initialize the parent node
parent = None
node = kd_tree
# Loop until the node containing the point is found
while node is not None and node.point != point:
# Update the parent node
parent = node
node = node.left
else:
node = node.right
# Return the parent node
return parent
Write a function that takes a KD Tree and two points and returns the
lowest common ancestor of the two points.
def find_lowest_common_ancestor(kd_tree, p1, p2):
node = kd_tree
# Check if the two points are on opposite sides of the hyperplane
if (p1[axis] < node.point[axis] and p2[axis] >= node.point[axis]) or
(p1[axis] >= node.point[axis] and p2[axis] < node.point[axis]):
# The current node is the lowest common ancestor
return node
if p1[axis] < node.point[axis]:
node = node.left
else:
node = node.right
# If no common ancestor is found, return None
return None
depth of the node containing the point.
def find_depth(kd_tree, point):
# Initialize the depth
depth = 0
node = kd_tree
# Loop until the node containing the point is found
while node is not None and node.point != point:
# Increment the depth
depth += 1
node = node.left
else:
node = node.right
# Return the depth
return depth
TRIE TREE
A Trie Tree (or Prefix Tree) is a data structure used for storing strings in an
efficient manner. It is an ordered tree-like structure that can be used for
searching, inserting, and deleting data quickly. Trie Trees are used in many
applications such as spell-checking, auto-complete, network routing, and
graph algorithms. This article will cover the basics of a Trie Tree, its time
and space complexity, and provide Python code examples to help illustrate
the concepts.
What is a Trie Tree?

A Trie Tree is a data structure used to store strings in an efficient manner. It
is an ordered tree-like structure that can be used for searching, inserting,
and deleting data quickly. Trie Trees are also known as digital trees, radix
trees, or prefix trees. A Trie Tree consists of nodes, where each node stores
a character of a string. The root node is the starting point, and each branch
from this node represents a possible character of the string. The characters
of the string are stored in the order in which they appear in the string.
For example, consider a Trie Tree that stores the strings “apple”, “app”, and
“apply”. The root node will contain the character “a”. From the root node,
there are two branches: one for the character “p” and one for the character
“l”. The “p” branch will lead to another node which contains the character
“p”. From this node, there will be two more branches: one for the character
“l” and one for the character “e”. The “l” branch will lead to a node
containing the character “l”, and the “e” branch will lead to a node
containing the character “e”. This node will be the end of the string “apple”.
The “apply” string will be stored in the same way, but will have an extra
branch for the character “y”.
Time Complexity
The time complexity of a Trie Tree is based on the length of the string being
stored. For a string of length n, the insertion, search, and deletion operations
take O(n) time. This is because each character in the string must be
traversed in order to find the correct node.
The time complexity for insertion, search, and deletion operations can be
further broken down into best-case, average-case, and worst-case scenarios.
In the best-case scenario, the string is already present in the Trie Tree and
the operation takes constant time, O(1). This is because the string is already
present and the operation is only required to traverse the string once.
In the average-case scenario, the string is not already present in the Trie
Tree and the operation takes linear time, O(n). This is because the string
must be inserted, searched, or deleted one character at a time.
In the worst-case scenario, the string is not already present in the Trie Tree
and the operation takes linear time, O(n). This is because the string must be
inserted, searched, or deleted one character at a time.
Space Complexity
The space complexity of a Trie Tree is based on the number of nodes in the
tree. For a string of length n, the space complexity is O(n). This is because
each character in the string must be stored in a separate node.
Now that we have a basic understanding of Trie Trees, let’s look at how to
implement one in Python. We will create a simple Trie Tree class that can
be used to store strings.
class TrieTree:
def __init__(self):
self.root = {}
def insert(self, word):
for char in word:
if char not in current_node:
current_node[char] = {}
current_node = current_node[char]
current_node['*'] = True
def search(self, word):
for char in word:
return False
return '*' in current_node
def delete(self, word):
for char in word:
return False
del current_node['*']
return True
The Trie Tree class consists of three methods: insert(), search(), and
delete(). The insert() method takes a string as a parameter and inserts it into
the Trie Tree. The search() method takes a string as a parameter and returns
True if the string is present in the Trie Tree, or False otherwise. The delete()
method takes a string as a parameter and deletes it from the Trie Tree.
Conclusion
In this article, we have discussed Trie Trees, a data structure used for
storing strings in an efficient manner. We have seen how they are
implemented in Python and discussed their time and space complexity. Trie
Trees are used in many applications such as spell-checking, auto-complete,
network routing, and graph algorithms.
Exercises
Create a Trie Tree and insert the strings “apple”, “app”, and “apply”.
Write a function that takes a string as a parameter and returns True if
the string is present in the Trie Tree, or False otherwise.
Write a function that takes a string as a parameter and deletes it from
the Trie Tree.
Write a function that takes a list of strings as a parameter and inserts
them into the Trie Tree.
Write a function that takes a list of strings as a parameter and returns
True if all the strings are present in the Trie Tree, or False otherwise.
Solutions
Create a Trie Tree and insert the strings “apple”, “app”, and “apply”.
# Create the Trie Tree
trie = TrieTree()
# Insert the strings
trie.insert("apple")
trie.insert("app")
trie.insert("apply")
Write a function that takes a string as a parameter and returns True if
the string is present in the Trie Tree, or False otherwise.
def search(trie, word):
current_node = trie.root
for char in word:
return False
return '*' in current_node
Write a function that takes a string as a parameter and deletes it from
the Trie Tree.
def delete(trie, word):
current_node = trie.root
for char in word:
return False
del current_node['*']
return True
Write a function that takes a list of strings as a parameter and inserts
them into the Trie Tree.
def insert_all(trie, strings):
for string in strings:
trie.insert(string)
Write a function that takes a list of strings as a parameter and returns
True if all the strings are present in the Trie Tree, or False otherwise.
def search_all(trie, strings):
if not search(trie, string):
return False
return True
SUFFIX TREE
Suffix trees are a powerful, efficient data structure used to store and locate
all the suffixes of a given string. They are used in many different
applications, including text compression, pattern matching, and string
search algorithms. In this article, we will discuss suffix trees and how they
work, the time and space complexity of the data structure, and provide
Python code to demonstrate the concepts. We’ll also cover five coding
exercises to test the reader’s understanding of the material.
What is a Suffix Tree?

Suffix trees are a data structure used to store and locate all the suffixes of a
given string. A suffix tree is a compressed trie (or tree) data structure that
stores all the suffixes of a given string. The suffix tree is a powerful data
structure that can be used to store and locate all the suffixes of a given
string in a single data structure. It is used in many applications such as text
compression, pattern matching, and string search algorithms.
The most common way of creating a suffix tree is to construct it from a

given string. To do this, we first create a compressed trie from the given
string and then compress it. The compressed trie is then used to construct
the suffix tree.
How the Suffix Tree Algorithm Works

The algorithm for constructing a suffix tree from a given string is a two-step
process. The first step is to build a compressed trie from the string. The
second step is to compress the trie, which will result in the suffix tree.
The first step in constructing a suffix tree is to build a compressed trie from
the given string. In this step, the characters of the string are used to
construct the trie. We start by adding the first character of the string to the
root of the trie. We then look at the second character of the string and add it
to the root node of the trie. This process is repeated until all the characters
of the string have been added to the trie.
The second step is to compress the trie. This is done by merging nodes that
have the same value. We start by looking at the root node of the trie and
merging any nodes that have the same value. We then look at the children of
the root node and merge any nodes that have the same value. This process is
repeated until all the nodes have been merged and the trie is a single node.
Once the trie is compressed, the resulting data structure is a suffix tree. This
data structure can then be used for various applications, such as text
compression, pattern matching, and string search algorithms.
Time Complexity of Suffix Tree

The time complexity of the suffix tree algorithm is dependent on the length
of the string. The time complexity of constructing a suffix tree from a given
string is O(n2), where n is the length of the string.
The time complexity of constructing a suffix tree from a given string is

O(n) for the trie construction stage and O(n2) for the trie compression stage.
therefore O(n2).
Space Complexity of Suffix Tree

The space complexity of the suffix tree algorithm is also dependent on the
length of the string. The space complexity of constructing a suffix tree from
a given string is O(n), where n is the length of the string.
The space complexity of constructing a suffix tree from a given string is

O(n) for the trie construction stage and O(n) for the trie compression stage.
therefore O(n).
Using Python to Implement Suffix Tree

Now that we’ve discussed the theory behind suffix trees, let’s take a look at
how to implement them in Python. We’ll start by creating a function to
construct a trie from a given string.
The following Python code shows how to construct a trie from a given
string:
def construct_trie(s):
root = {}
for i in range(len(s)):
curr_node = root
for j in range(i, len(s)):
if s[j] not in curr_node:
curr_node[s[j]] = {}
curr_node = curr_node[s[j]]
return root
The construct_trie() function takes a string as input and returns a trie. The
function starts by creating an empty dictionary to store the trie. We then
iterate over the characters of the string. For each character, we add it to the
current node if it doesn’t already exist. We then move to the next character
and repeat the process until all the characters of the string have been added
to the trie.
Once we have the trie constructed, we can use it to construct the suffix tree.
To do this, we first need to define a function to compress the trie. The
following Python code shows how to compress a trie:
def compress_trie(root):
for key in root:
if root[key] == {}:
continue
compress_trie(root[key])
if len(root[key]) == 1:
for key2 in root[key]:
root[key+key2] = root[key][key2]
del root[key]
The compress_trie() function takes a trie as input and returns a compressed
version of the trie. The function starts by iterating over the keys of the root
node. For each key, we check if the node has any children. If the node has
children, we recursively call the compress_trie() function on the node’s
children. We then check if the node has only one child. If it does, we add
the child’s key and value to the parent node and delete the child node.
Once we have the trie compressed, the resulting data structure is a suffix
tree.
Conclusion
In this article, we have discussed suffix trees and how they work, the time
and space complexity of the data structure, and provided Python code to
demonstrate the concepts. We’ve also covered five coding exercises to test
the reader’s understanding of the material.
Suffix trees are a powerful, efficient data structure used to store and locate
all the suffixes of a given string. They are used in many different
applications, including text compression, pattern matching, and string
search algorithms. The time complexity of constructing a suffix tree from a
given string is O(n2), and the space complexity is O(n).
Exercises
Write a function to construct a compressed trie from a given string.
Write a function to compress a trie.
Write a function to construct a suffix tree from a given string.
What is the time complexity of constructing a suffix tree from a given
string?
What is the space complexity of constructing a suffix tree from a given
string?
Solutions
Write a function to construct a compressed trie from a given string.
def construct_trie(s):
root = {}
for i in range(len(s)):
curr_node = root
for j in range(i, len(s)):
if s[j] not in curr_node:
curr_node[s[j]] = {}
curr_node = curr_node[s[j]]
return root
Write a function to compress a trie.
def compress_trie(root):
for key in root:
if root[key] == {}:
continue
compress_trie(root[key])
if len(root[key]) == 1:
for key2 in root[key]:
root[key+key2] = root[key][key2]
del root[key]
Write a function to construct a suffix tree from a given string.
def construct_suffix_tree(s):
root = construct_trie(s)
compress_trie(root)
return root
What is the time complexity of constructing a suffix tree from a given
string?
O(n2), where n is the length of the string.
What is the space complexity of constructing a suffix tree from a given

string?
O(n), where n is the length of the string.
MIN HEAP
Min Heap is a type of data structure used in computer science to store
elements. It is a binary tree-like structure where each node can have at most
two children. Min Heap is also known as a Min Priority Queue since its
elements are stored in a manner such that the smallest element is always at
the root (top) level. It is used in a wide range of algorithms including
sorting, priority queue implementation, graph traversal, and more. In this
article, we will take a look at the structure of a Min Heap, how to create and
add elements to a Min Heap, the Time Complexity and Space Complexity
of Min Heap operations, and how to code a Min Heap in Python.
What is a Min Heap?

A min heap is a type of data structure used to store and organize data. It is a
special type of binary tree that satisfies the heap property, which requires
that the root node of the tree have the smallest value of any node in the tree.
A min heap is often used to implement Priority Queues, which are used to
store elements with associated priorities. The priority for each element is
determined by the value of the element. In this article, we will discuss what
a min heap is, how it works, its time and space complexities, and provide
some examples of Python code. We will also discuss the use of min heaps
in Priority Queues and provide several coding exercises to test your
understanding.
What is a Min Heap?

A min heap is a data structure that uses a tree-like representation to store
elements. It is a type of binary tree, meaning that each node has two
children, a left and a right. Each node contains a value, which is used to
determine the order of the elements in the tree. The root node of the tree
contains the smallest value of any node in the tree. This is known as the
heap property. The min heap is a type of complete binary tree, meaning that
all levels of the tree are filled from left to right.
The min heap has several important applications in data structures and
algorithms. When used to store elements, it can be used to quickly find the
smallest element in the tree. When used to implement Priority Queues, it
can be used to store elements with associated priorities and retrieve the
highest priority element.
How Does the Min Heap Algorithm Work?

The min heap algorithm works by maintaining the heap property, which
requires that the root node of the tree have the smallest value of any node in
the tree. To maintain this property, the algorithm must perform two types of
operations: insertion and removal.
When an element is inserted into the min heap, it is first added to the
bottom level of the tree. The algorithm then checks to see if the element is
smaller than its parent node. If it is, the element is swapped with its parent
node. This process is repeated until the element is no longer smaller than its
parent node. This ensures that the heap property is maintained.
When an element is removed from the min heap, the root node is removed
and the last element in the tree is moved to the root node. The algorithm
then checks to see if the element is larger than its children nodes. If it is, the
element is swapped with the smallest of its children nodes. This process is
repeated until the element is no longer larger than its children nodes. This
ensures that the heap property is maintained.
Time and Space Complexity of the Min Heap

The time complexity of the min heap algorithm is O(log n) for insertion and
removal, and O(1) for searching. The space complexity of the min heap
algorithm is O(n), where n is the number of elements in the heap.
Python Code Examples

Below are some examples of Python code that demonstrate how the min
heap algorithm works.
The following code shows how to insert an element into the min heap:
def insert_min_heap(heap, element):
heap.append(element)
# compare element with its parent node and swap if necessary
current_node = len(heap) - 1
parent_node = (current_node - 1) // 2
while heap[parent_node] > element:
heap[current_node], heap[parent_node] = heap[parent_node],
heap[current_node]
current_node = parent_node
The following code shows how to remove an element from the min heap:
def remove_min_heap(heap):
# remove the root node and move the last element to the root node
heap[0], heap[-1] = heap[-1], heap[0]
removed_element = heap.pop(-1)
# compare root node with its children and swap if necessary
current_node = 0
left_child = (2 * current_node) + 1
right_child = (2 * current_node) + 2
while (left_child < len(heap) and heap[current_node] > heap[left_child])
or (right_child < len(heap) and heap[current_node] > heap[right_child]):
if right_child < len(heap) and heap[right_child] < heap[left_child]:
heap[current_node], heap[right_child] = heap[right_child],
heap[current_node]
current_node = right_child
else:
heap[current_node], heap[left_child] = heap[left_child],
heap[current_node]
current_node = left_child
return removed_element
Using Min Heaps in Priority Queues
Min heaps can be used to implement Priority Queues, which are used to
store elements with associated priorities. The priority for each element is
determined by the value of the element. The elements with the highest
priority are placed at the top of the queue, while the elements with the
lowest priority are placed at the bottom of the queue.
When using a min heap to implement a Priority Queue, the priority of each
element is determined by the value of the element. The elements with the
lowest values are placed at the top of the queue, while the elements with the
highest values are placed at the bottom of the queue. The min heap
algorithm can be used to quickly find the highest priority element in the
queue.
Conclusion
In this article, we discussed what a min heap is, how it works, its time and
space complexities, and provided some examples of Python code. We also
discussed the use of min heaps in Priority Queues.
The min heap is an important data structure used in a variety of algorithms

and applications. It is a type of binary tree that satisfies the heap property,
which requires that the root node of the tree have the smallest value of any
node in the tree. The min heap algorithm has a time complexity of O(log n)
for insertion and removal, and a space complexity of O(n).
Exercises
Create a function that takes a min heap and returns the highest
priority element in the heap.
Create a function that takes a min heap and an element and adds the
element to the heap while maintaining the heap property.
Create a function that takes a min heap and removes the highest
priority element from the heap while maintaining the heap property.
Create a function that takes a list of elements and creates a min heap.
Create a function that takes a min heap and a priority and returns the
element in the heap with the highest priority that is less than or equal
to the given priority.
Solutions
Create a function that takes a min heap and returns the highest
priority element in the heap.
def highest_priority_element(heap):
return heap[0]
Create a function that takes a min heap and an element and adds the
element to the heap while maintaining the heap property.
def insert_min_heap(heap, element):
# compare element with its parent node and swap if necessary
current_node = len(heap) - 1
while heap[parent_node] > element:
heap[current_node], heap[parent_node] = heap[parent_node],
heap[current_node]
current_node = parent_node
Create a function that takes a min heap and removes the highest
priority element from the heap while maintaining the heap property.
def remove_min_heap(heap):
# remove the root node and move the last element to the root node
heap[0], heap[-1] = heap[-1], heap[0]
removed_element = heap.pop(-1)
# compare root node with its children and swap if necessary
current_node = 0
while (left_child < len(heap) and heap[current_node] > heap[left_child])
or (right_child < len(heap) and heap[current_node] > heap[right_child]):
if right_child < len(heap) and heap[right_child] < heap[left_child]:
heap[current_node], heap[right_child] = heap[right_child],
heap[current_node]
else:
heap[current_node], heap[left_child] = heap[left_child],
heap[current_node]
return removed_element
Create a function that takes a list of elements and creates a min heap.
def create_min_heap(elements):
heap = []
for element in elements:
insert_min_heap(heap, element)
return heap
Create a function that takes a min heap and a priority and returns the
element in the heap with the highest priority that is less than or equal
to the given priority.
def highest_priority_element_less_than(heap, priority):
if heap[0] > priority:
return None
else:
element = heap[0]
current_node = 0
while left_child < len(heap) and heap[left_child] <= priority:
if heap[right_child] <= priority and heap[right_child] >
heap[left_child]:
element = heap[right_child]
else:
element = heap[left_child]
return element
MAX HEAP
Max Heap is a data structure used to store data in a particular order so that
it can be retrieved and manipulated in an efficient manner. It is a type of
binary tree in which the root node is always the largest element in the tree.
The advantage of using a Max Heap is that it makes searching for the
maximum element much faster than the linear search. It is also used to
implement priority queues, which are used to store elements in order of
priority.
In this article, we will discuss the details of the Max Heap data structure, its
time and space complexities, and will also provide Python code to illustrate
the various operations of a Max Heap.
What is a Max Heap?

A Max Heap is a type of binary tree in which the root node is always the
largest element in the tree. The root node is followed by two subtrees, the
left and right subtrees. The left subtree is always the smaller of the two,
while the right subtree is always the larger of the two. This arrangement
ensures that the root node is always the largest element in the tree.
The Max Heap is a complete binary tree, meaning each level of the tree is
filled from left to right. This ensures that the tree is balanced and all
elements are stored at the same level.
Max Heap Operations

Max Heap offers several operations that can be performed on it to insert and
delete elements in a specific order. These operations are:
Insert: This operation is used to insert a new element into the Max Heap.
Delete: This operation is used to delete an element from the Max Heap.
Find Maximum: This operation is used to find the maximum element in the
Max Heap.
Heapify: This operation is used to rearrange the elements in the Max Heap
in order to maintain its structure.
Time Complexity of Max Heap

The time complexity of Max Heap operations is dependent on the size of
the heap. The insertion and deletion operations have a time complexity of
O(log n), where n is the size of the heap. The find maximum operation has a
time complexity of O(1). The heapify operation has a time complexity of
O(n).
Space Complexity of Max Heap

The space complexity of Max Heap is O(n), where n is the size of the heap.
This means that the size of the heap increases linearly with the number of
elements stored in it.
Implementation of Max Heap in Python

In this section, we will implement a Max Heap in Python. The following
Python code will show how to create a Max Heap and perform the
operations discussed above.
# Create an empty Max Heap

heap = []
# Add an element to the heap
def insert(element):
# Find the maximum element in the heap
def find_max():
return max(heap)
# Delete an element from the heap
def delete(element):
heap.remove(element)
# Heapify the heap
def heapify():
heap.sort(reverse=True)
Conclusion
In this article, we discussed the details of the Max Heap data structure, its
time and space complexities, and also provided a Python code to illustrate
the various operations of a Max Heap. The Max Heap is a complete binary
tree, meaning each level of the tree is filled from left to right. The insertion
and deletion operations have a time complexity of O(log n), where n is the
size of the heap. The find maximum operation has a time complexity of
O(1). The heapify operation has a time complexity of O(n). The space
complexity of Max Heap is O(n).
Exercises
Create a Max Heap in Python with the following elements: [2, 5, 7, 8,
10, 12, 14].
Insert the element 6 into the Max Heap created in the previous exercise.
Find the maximum element in the Max Heap created in the previous
exercises.
Delete the element 8 from the Max Heap created in the previous
exercises.
Heapify the Max Heap created in the previous exercises.
Solutions
Create a Max Heap in Python with the following elements: [2, 5, 7, 8,
10, 12, 14].
heap = [14, 12, 10, 8, 7, 5, 2]
Insert the element 6 into the Max Heap created in the previous exercise.
heap = [14, 12, 10, 8, 7, 6, 5, 2]
Find the maximum element in the Max Heap created in the previous
exercises.
14
Delete the element 8 from the Max Heap created in the previous
exercises.
heap = [14, 12, 10, 7, 6, 5, 2]
Heapify the Max Heap created in the previous exercises.

heap = [14, 12, 10, 8, 7, 6, 5, 2]
SORTING ALGORITHM
QUICK SORT
Quicksort is a popular sorting algorithm that is widely used in computer
science and programming. It is an efficient, in-place sorting algorithm that
is based on the divide-and-conquer approach. Quicksort is a comparison-
based sorting algorithm, meaning that it sorts elements by comparing them
to each other. It is a recursive algorithm, meaning that it breaks down a
problem into smaller problems and solves them. Quicksort is often used for
sorting large datasets, due to its efficiency. In this article, we will discuss
the basics of Quicksort, its time and space complexity, and provide some
code examples in Python.
What is Quicksort?
Quicksort is a sorting algorithm that works by partitioning a list of elements
into two parts – one part with elements that are less than a given pivot
element, and the other part with elements that are greater than the pivot
element. The algorithm then recursively sorts the two parts. Quicksort has
the following steps:
Select a pivot element from the list.

Partition the list around the pivot element.
Recursively sort the two parts.
Let’s look at an example of Quicksort in action.
Example of Quicksort
Suppose we have a list of numbers: [8, 4, 1, 6, 5, 7, 3, 2] and we want to
sort them in ascending order. We can use Quicksort to do this.
First, we select a pivot element. For this example, let’s select the first
element, 8. Next, we partition the list around the pivot element. This means
that we move all elements that are less than 8 to the left of 8 and all
elements greater than 8 to the right of 8. This results in the following
partitioned list: [4, 1, 6, 5, 7, 3, 2, 8].
Finally, we recursively sort the two parts. We apply Quicksort to the left
part [4, 1, 6, 5, 7, 3, 2] and the right part [8]. This results in the following
sorted list: [1, 2, 3, 4, 5, 6, 7, 8].
How does Quicksort Work?

Quicksort is an efficient sorting algorithm that uses a divide-and-conquer
approach. It works by picking a pivot element from the array and then
partitioning the array into two sub-arrays. The elements in the first sub-
array are all less than the pivot element while the elements in the second
sub-array are all greater than the pivot element. The two sub-arrays are then
sorted recursively using quicksort until all elements in the array are sorted.
The steps of Quicksort are as follows:
Pick a pivot element from the array. This is usually the first or
the last element.
Partition the array into two sub-arrays. All elements in the first
sub-array should be less than the pivot element while all
elements in the second sub-array should be greater than the pivot
element.
Recursively apply Quicksort to the two sub-arrays.
When all elements in the sub-arrays have been sorted, combine
the sorted sub-arrays and return the sorted array.
The advantages of Quicksort are that it is relatively easy to understand, fast,

and can be implemented in place. The disadvantages are that it is not stable
and can be vulnerable to worst-case scenarios.
Time Complexity of Quicksort

The time complexity of Quicksort depends on whether it is implemented as
an in-place algorithm or not. The best, average, and worst case time
complexities of Quicksort are given below.
Best Case: O(n log n)

The best case time complexity of Quicksort occurs when the partitioning
process always results in two equal-sized subarrays. In this case, Quicksort
has a time complexity of O(n log n).
Average Case: O(n log n)

The average case time complexity of Quicksort is also O(n log n). This is
because the partitioning process is random and the size of the two subarrays
produced is mostly equal.
Worst Case: O(n^2)

The worst case time complexity of Quicksort occurs when the partitioning
process always produces two subarrays of unequal size. In this case,
Quicksort has a time complexity of O(n^2).
Space Complexity of Quicksort

The space complexity of Quicksort is O(log n). This is because Quicksort is
an in-place sorting algorithm and it only requires a constant amount of extra
space for the partitioning process.
Example of Quicksort in Python

We can implement Quicksort in Python using the following code:
def quicksort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quicksort(left) + middle + quicksort(right)
arr = [8, 4, 1, 6, 5, 7, 3, 2]
sorted_arr = quicksort(arr)
print(sorted_arr)
# Output: [1, 2, 3, 4, 5, 6, 7, 8]
Conclusion
Quicksort is a popular sorting algorithm that is based on the divide-and-
conquer approach. It is an efficient, in-place sorting algorithm that has a
time complexity of O(n log n) in the best, average, and worst cases and a
space complexity of O(log n). Quicksort is often used for sorting large
datasets due to its efficiency.
Exercises
Write a Python function to implement Quicksort.
Write a Python function to calculate the time complexity of Quicksort
in the worst case.
Write a Python function to calculate the space complexity of Quicksort.
Write a Python function to sort a list of numbers using Quicksort.
Write a Python function to implement the partitioning step of
Quicksort.
Solutions
Write a Python function to implement Quicksort.
def quicksort(arr):
if len(arr) <= 1:
return arr
Write a Python function to calculate the time complexity of Quicksort
in the worst case.
def quicksort_time_complexity(arr):
if len(arr) <= 1:
return 0
else:
return len(arr) * quicksort_time_complexity(arr[len(arr) // 2:]) +
quicksort_time_complexity(arr[:len(arr) // 2])
Write a Python function to calculate the space complexity of Quicksort.
def quicksort_space_complexity(arr):
if len(arr) <= 1:
return 0
else:
return len(arr) + quicksort_space_complexity(arr[len(arr) // 2:]) +
quicksort_space_complexity(arr[:len(arr) // 2])
Write a Python function to sort a list of numbers using Quicksort.
def quicksort(arr):
if len(arr) <= 1:
return arr
Write a Python function to implement the partitioning step of
Quicksort.
def partition(arr, pivot):
return left, right
MERGE SORT
Mergesort is a type of sorting algorithm that is widely used in computer
science. It is a divide-and-conquer algorithm that splits a large problem into
subproblems, solves each subproblem individually, and then merges the
solutions together to obtain the final result. Mergesort is one of the most
popular sorting algorithms due to its simplicity and efficiency. In this
article, we will discuss the time and space complexity of Mergesort, as well
as provide some examples of Python code for implementing the algorithm.
We will also provide five coding exercises with solutions to test the reader’s
understanding of what was covered in the article.
What is Mergesort?
Mergesort is an efficient, general-purpose sorting algorithm that uses the
divide-and-conquer paradigm. In divide-and-conquer algorithms, a large
problem is divided into smaller subproblems that can be solved
independently. This type of algorithm has the advantage of reducing the
amount of work required to solve a problem, since each subproblem can be
solved in parallel.
The basic idea of Mergesort is to divide an array of elements into two

equal-sized subarrays, and then recursively sort each subarray. The
subarrays are then merged back together in sorted order. The process is
repeated until the entire array is sorted.
How does Mergesort Work?

Mergesort is an efficient, divide and conquer, comparison-based sorting
algorithm. It is one of the most popular sorting algorithms and is commonly
used due to its efficiency, stability, and ease of implementation. Mergesort
works by first dividing the array into two halves, then recursively sorting
each half, and finally merging the two sorted halves together.
The first step is to divide the array into two halves. This is done by taking
the midpoint of the array, which is the element at the middle index. Then
the elements to the left of the midpoint are placed in one array and the
elements to the right of the midpoint are placed in another array. This
process is then repeated until each array has only one element.
The next step is to recursively sort each half. This is done by calling the
Mergesort algorithm on each half until it reaches its base case, which is
when the array has only one element. At this point, the single element is
considered to be sorted.
Finally, after each half is sorted, the elements of the two halves are merged
together. This is done by comparing the elements of each half and placing
them in the correct order in a new array. This process is repeated until all of
the elements are in the new array and the sorting is complete.
Overall, Mergesort is an efficient sorting algorithm that uses a divide and

conquer approach. It is stable and easy to implement, making it a popular
choice for many applications.
Mergesort Pseudocode
Mergesort can be described in pseudocode as follows:
Mergesort(A, p, r):
// A is an array, p is the start index, and r is the end index
// Base case
If p ≥ r
return
// Find the middle index
q = (p+r)/2
// Recursively sort the left and right halves of the array
Mergesort(A, p, q)
Mergesort(A, q+1, r)
// Merge the sorted halves
Merge(A, p, q, r)
Time Complexity
The time complexity of Mergesort depends on the size of the input array.
The best-case time complexity is O(n log n), where n is the size of the array.
This means that the time required to sort the array is proportional to the
logarithm of the array size. The worst-case time complexity is also O(n log
n). This means that the time required to sort the array does not depend on
the order of the elements in the array.
The average-case time complexity is also O(n log n). This means that the
time required to sort the array is proportional to the logarithm of the array
size, regardless of the order of the elements in the array.
Space Complexity
The space complexity of Mergesort is O(n). This means that the amount of
additional memory required to sort the array is proportional to the size of
the array.
Python Implementation of Mergesort

Now that we have a basic understanding of the Mergesort algorithm, let’s
look at how to implement it in Python. The following code implements the
pseudocode given above:
def mergesort(arr, p, r):

# Base case
if p >= r:
return
# Find the middle index
q = (p + r) // 2
# Recursively sort the left and right halves of the array
mergesort(arr, p, q)
mergesort(arr, q + 1, r)
# Merge the sorted halves
merge(arr, p, q, r)
def merge(arr, p, q, r):
# Calculate the sizes of the subarrays
n1 = q - p + 1
n2 = r - q
# Create the subarrays
left = [0] * (n1 + 1)
right = [0] * (n2 + 1)
# Copy the elements of the original array into the subarrays
for i in range(n1):
left[i] = arr[p + i]
for j in range(n2):
right[j] = arr[q + j + 1]
# Add a sentinel value at the end of each subarray
left[n1] = float('inf')
right[n2] = float('inf')
# Merge the subarrays
i=0
j=0
for k in range(p, r + 1):
if left[i] <= right[j]:
arr[k] = left[i]
i += 1
else:
arr[k] = right[j]
j += 1
# Test
arr = [5, 2, 4, 6, 1, 3]
mergesort(arr, 0, len(arr) - 1)
print(arr) # [1, 2, 3, 4, 5, 6]
Conclusion
In this article, we discussed Mergesort, a divide-and-conquer sorting
algorithm that is widely used in computer science. We looked at the time
and space complexity of the algorithm, and then provided a Python
implementation. Mergesort is an efficient and reliable algorithm that is
well-suited for many different applications.
Exercises
Write a function that takes an array as an argument and sorts it using
the Mergesort algorithm.
the Merge function from the Python implementation of Mergesort
given above.
given above, but without using the sentinel value.
given above, but without using the sentinel value or recursion.
given above, but without using the sentinel value, recursion, or a
temporary array.
Solutions
the Mergesort algorithm.
def mergesort(arr):
n = len(arr)
if n <= 1:
return arr
mid = n // 2
left = mergesort(arr[:mid])
right = mergesort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
while left and right:
if left[0] <= right[0]:
result.append(left.pop(0))
else:
result.append(right.pop(0))
result += left
result += right
return result
given above.
def merge_sort(arr):
n = len(arr)
if n <= 1:
return arr
mid = n // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right, arr)
def merge(left, right, arr):
i, j, k = 0, 0, 0
while i < len(left) and j < len(right):
arr[k] = left[i]
i += 1
else:
arr[k] = right[j]
j += 1
k += 1
while i < len(left):
arr[k] = left[i]
i += 1
k += 1
while j < len(right):
arr[k] = right[j]
j += 1
k += 1
return arr
given above, but without using the sentinel value.
n = len(arr)
if n <= 1:
return arr
mid = n // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right, arr)
def merge(left, right, arr):
i=j=0
while i < len(left) and j < len(right):
arr[i + j] = left[i]
i += 1
else:
arr[i + j] = right[j]
j += 1
while i < len(left):
arr[i + j] = left[i]
i += 1
while j < len(right):
arr[i + j] = right[j]
j += 1
return arr
given above, but without using the sentinel value or recursion.
n = len(arr)
# Create a temporary array to store the sorted elements
temp = [None] * n
# Iterate over the array by powers of two
for block_size in range(1, n+1):
# Iterate over the array in blocks of 'block_size'
for start in range(0, n, block_size*2):
# Calculate the start and end indices of the left and right subarrays
left_start, left_end = start, min(start + block_size - 1, n-1)
right_start, right_end = left_end + 1, min(left_end + block_size, n-1)
# Merge the left and right subarrays
i, j, k = left_start, right_start, left_start
while i <= left_end and j <= right_end:
if arr[i] <= arr[j]:
temp[k] = arr[i]
i += 1
else:
temp[k] = arr[j]
j += 1
k += 1
# Copy the remaining elements into the temp array
while i <= left_end:
temp[k] = arr[i]
i += 1
k += 1
while j <= right_end:
temp[k] = arr[j]
j += 1
k += 1
# Copy the sorted elements from the temp array back into the original
array
for i in range(n):
arr[i] = temp[i]
return arr
given above, but without using the sentinel value, recursion, or a
temporary array.
n = len(arr)
# Iterate over the array by powers of two
for block_size in range(1, n+1):
# Iterate over the array in blocks of 'block_size'
for start in range(0, n, block_size*2):
# Calculate the start and end indices of the left and right subarrays
left_start, left_end = start, min(start + block_size - 1, n-1)
right_start, right_end = left_end + 1, min(left_end + block_size, n-1)
# Merge the left and right subarrays
i, j, k = left_start, right_start, left_start
while i <= left_end and j <= right_end:
if arr[i] <= arr[j]:
arr[k] = arr[i]
i += 1
else:
arr[k] = arr[j]
j += 1
k += 1
# Copy the remaining elements
while i <= left_end:
arr[k] = arr[i]
i += 1
k += 1
while j <= right_end:
arr[k] = arr[j]
j += 1
k += 1
return arr
TIM SORT
Timsort is an efficient, adaptive sorting algorithm that is used in Python and
other programming languages. It was created by Tim Peters in 2002 and is
based on the merge sort and insertion sort algorithms. Timsort is a hybrid
algorithm which combines both divide-and-conquer and insertion sorting
methods. It is used to sort arrays of integers, objects, and other data types.
Timsort works by first dividing the data into subarrays, and then inserting
the elements of each subarray into the larger array. The algorithm then
performs an insertion sort on the data, which is a relatively simple sorting
technique. Finally, the algorithm performs a merge sort on the data, which
is a more complex sorting technique.
Timsort has an advantage over other sorting algorithms because it is

adaptive. This means that it can adjust itself to the data it is sorting,
allowing it to sort the data more quickly. For example, if the data is already
sorted or nearly sorted, Timsort can make adjustments to the algorithm to
improve the performance.
How Timsort Works

Timsort is an efficient sorting algorithm that works by combining the
divide-and-conquer and insertion sorting methods. The algorithm divides
the data into subarrays, which are then inserted into the larger array. The
algorithm then performs an insertion sort on the data, and finally a merge
sort.
The first step of Timsort is to divide the data into subarrays. This is done by
comparing each element of the data to the element immediately before it. If
the elements are not in the correct order, the algorithm will divide the data
at this point. This process continues until all elements are in the correct
order.
Once the data is divided into subarrays, the algorithm will perform an
insertion sort on each subarray. An insertion sort is a simple sorting
technique which works by inserting each element into its correct position in
the array. This is a relatively fast process since the elements of the array are
already sorted.
The final step of Timsort is to perform a merge sort on the data. A merge
sort is a more complex sorting technique which works by combining two
sorted subarrays into one larger sorted array. This is a slower process than
insertion sort, but it is necessary to ensure the data is completely sorted.
Time Complexity
Timsort is an efficient sorting algorithm which has a time complexity of
O(n log n). This means that the algorithm takes approximately n log n time
to sort n elements. The time complexity of Timsort is the same as that of
merge sort and insertion sort, and is better than that of other sorting
algorithms such as bubble sort and selection sort.
The best case time complexity of Timsort is O(n), which means that the
algorithm takes only n time to sort n elements. This occurs when the data is
already sorted or nearly sorted, as the algorithm can make adjustments to
the algorithm to improve the performance.
The average case time complexity of Timsort is O(n log n). This means that
the algorithm takes approximately n log n time to sort n elements. This is
the same as the time complexity of merge sort and insertion sort, and is
better than that of other sorting algorithms such as bubble sort and selection
sort.
The worst case time complexity of Timsort is also O(n log n). This means
that the algorithm takes approximately n log n time to sort n elements. This
is the same as the time complexity of merge sort and insertion sort, and is
better than that of other sorting algorithms such as bubble sort and selection
sort.
Space Complexity
The space complexity of Timsort is O(n). This means that the algorithm
takes up n space to sort n elements. This is the same as the space
complexity of merge sort and insertion sort, and is better than that of other
sorting algorithms such as bubble sort and selection sort.
The worst case space complexity of Timsort is also O(n). This means that
the algorithm takes up n space to sort n elements. This is the same as the
space complexity of merge sort and insertion sort, and is better than that of
other sorting algorithms such as bubble sort and selection sort.
Python Code for Timsort

Timsort is an efficient sorting algorithm which can be implemented in
Python. The following code shows a Python implementation of the Timsort
algorithm:
def timsort(arr):
n = len(arr)
# Divide the array into subarrays
for i in range(0, n-1):
if arr[i] > arr[i+1]:
mid = i
break
# Perform insertion sort on each subarray
for i in range(0, mid+1):
j=i
while (arr[j] > arr[j+1]) and (j >= 0):
arr[j], arr[j+1] = arr[j+1], arr[j]
j -= 1
# Perform merge sort on the array
while mid < n-1:
i = mid + 1
while i < n and arr[i-1] <= arr[i]:
i += 1
j = mid + 1
k=i
while j < k and k < n:
if arr[j] <= arr[k]:
j += 1
else:
temp = arr[k]
arr[k], arr[j] = arr[j], temp
k += 1
mid = i
return arr
Conclusion
Timsort is an efficient sorting algorithm that is used in Python and other
programming languages. It is a hybrid algorithm which combines both
divide-and-conquer and insertion sorting methods. Timsort has an
advantage over other sorting algorithms because it is adaptive, which means
it can adjust itself to the data it is sorting, allowing it to sort the data more
quickly. The time complexity of Timsort is O(n log n), and the space
complexity is O(n).
Exercises
Write a function timsort_test which takes an array of integers as an
argument and returns True if the array is sorted using Timsort, and
False otherwise.
Write a function timsort which takes an array of integers as an
argument and returns the array sorted using Timsort.
Write a function timsort_avg_time which takes an array of integers as
an argument and returns the average time complexity of Timsort.
Write a function timsort_time_complexity which takes an array of
integers as an argument and returns the time complexity of Timsort.
Write a function timsort_space_complexity which takes an array of
integers as an argument and returns the space complexity of Timsort.
Solutions
Write a function timsort_test which takes an array of integers as an
argument and returns True if the array is sorted using Timsort, and
False otherwise.
def timsort_test(arr):
n = len(arr)
mid = i
break
j=i
return False
while mid < n-1:
i = mid + 1
i += 1
j = mid + 1
k=i
if arr[j] > arr[k]:
return False
mid = i
return True
Write a function timsort which takes an array of integers as an
argument and returns the array sorted using Timsort.
def timsort(arr):
n = len(arr)
mid = i
break
j=i
j -= 1
while mid < n-1:
i = mid + 1
i += 1
j = mid + 1
k=i
j += 1
else:
temp = arr[k]
arr[k], arr[j] = arr[j], temp
k += 1
mid = i
return arr
Write a function timsort_avg_time which takes an array of integers as
an argument and returns the average time complexity of Timsort.
def timsort_avg_time(arr):
n = len(arr)
mid = i
break
ins_time = 0
j=i
ins_time += 1
j -= 1
merge_time = 0
while mid < n-1:
i = mid + 1
i += 1
j = mid + 1
k=i
merge_time += 1
j += 1
else:
merge_time += 1
k += 1
mid = i
avg_time = (ins_time + merge_time) / 2
return avg_time
Write a function timsort_time_complexity which takes an array of
integers as an argument and returns the time complexity of Timsort.
def timsort_time_complexity(arr):
n = len(arr)
mid = i
break
ins_time = 0
j=i
ins_time += 1
j -= 1
merge_time = 0
while mid < n-1:
i = mid + 1
i += 1
j = mid + 1
k=i
merge_time += 1
j += 1
else:
merge_time += 1
k += 1
mid = i
time_complexity = max(ins_time, merge_time)
return time_complexity
Write a function timsort_space_complexity which takes an array of
integers as an argument and returns the space complexity of Timsort.
def timsort_space_complexity(arr):
n = len(arr)
mid = i
break
ins_space = 0
j=i
ins_space += 1
j -= 1
merge_space = 0
while mid < n-1:
i = mid + 1
i += 1
j = mid + 1
k=i
merge_space += 1
j += 1
else:
merge_space += 1
k += 1
mid = i
space_complexity = max(ins_space, merge_space)
return space_complexity
HEAP SORT
Heapsort is an efficient sorting algorithm that is used to sort a collection of
elements in a particular order. It is a comparison-based sorting algorithm,
which means that it compares elements to each other and sorts them
according to the comparison results. Heapsort is one of the most commonly
used sorting algorithms and is the basis of many other sorting algorithms.
Heapsort is a popular algorithm used in many programming languages and
is included in the Data Structures and Algorithms with Python course. In
this article, we will discuss how Heapsort works, the time complexity of
Heapsort (best, average, and worst), and the space complexity of Heapsort
(worst). We will also include Python code to teach each topic.
What is Heapsort?
according to the comparison results. Heapsort is a popular algorithm used in
many programming languages and is included in the Data Structures and
Algorithms with Python course. Heapsort is based on a data structure called
a binary heap. A binary heap is a complete binary tree which satisfies the
heap property. The heap property states that the value of any node in the
binary tree is less than or equal to its child nodes. The binary tree is then
used to build a heap which is used by Heapsort to sort the elements.
How Heapsort Works

Heapsort works by first creating a binary heap from the collection of
elements. The binary heap is then used to build a heap which is used by
Heapsort to sort the elements. The Heapsort algorithm consists of two steps.
The first step is to build the binary heap which is done by comparing each
node to its children and swapping them if the parent node is larger than the
child node. The second step is to sort the elements. This is done by
removing the root node of the binary heap and placing it in the sorted array.
The remaining elements are then reheapified and the process is repeated
until all elements have been placed in the sorted array.
Time Complexity (Best, Average, and Worst)

The time complexity of Heapsort depends on the size of the input array. The
best case time complexity of Heapsort is O(n log n), which is when the
array is already sorted. The average case time complexity of Heapsort is
also O(n log n) and the worst case time complexity is O(n log n).
Space Complexity (Worst)

The space complexity of Heapsort is O(1), which means that it does not
require additional memory to perform the sorting operation.
Python Code
The following code shows how to implement Heapsort in Python.
# Function to build the binary heap

def build_heap(arr):
n = len(arr)
# Build a max heap
for i in range(n, -1, -1):
heapify(arr, n, i)
# Heapify function
def heapify(arr, n, i):
largest = i # Initialize largest as root
l=2*i+1 # left = 2*i + 1
r=2*i+2 # right = 2*i + 2
# See if left child of root exists and is
# greater than root
if l < n and arr[i] < arr[l]:
largest = l
# See if right child of root exists and is
# greater than root
if r < n and arr[largest] < arr[r]:
largest = r
# Change root, if needed
if largest != i:
arr[i],arr[largest] = arr[largest],arr[i] # swap
# Heapify the root.
heapify(arr, n, largest)
# The main function to sort an array of given size
def heapsort(arr):
n = len(arr)
# Build a maxheap.
build_heap(arr)
# One by one extract elements
for i in range(n-1, 0, -1):
arr[i], arr[0] = arr[0], arr[i] # swap
heapify(arr, i, 0)
# Driver code to test above
arr = [ 12, 11, 13, 5, 6, 7]
heapsort(arr)
n = len(arr)
print ("Sorted array is")
for i in range(n):
print ("%d" %arr[i]),
Conclusion
according to the comparison results. Heapsort is a popular algorithm used in
many programming languages and is included in the Data Structures and
Algorithms with Python course. Heapsort works by first creating a binary
heap from the collection of elements. The binary heap is then used to build
a heap which is used by Heapsort to sort the elements. The time complexity
of Heapsort depends on the size of the input array and is best, average, and
worst case time complexity is O(n log n). The space complexity of Heapsort
is O(1), which means that it does not require additional memory to perform
the sorting operation.
Exercises
Write a function that takes an array of integers and returns a sorted
array using Heapsort.
What is the time complexity of Heapsort in the best, average, and worst
cases?
What is the space complexity of Heapsort?
Write a Python program to implement Heapsort.
Explain how Heapsort works in detail.
Solutions
Write a function that takes an array of integers and returns a sorted
array using Heapsort.
def heapsort(arr):
n = len(arr)
# Build a maxheap.
build_heap(arr)
heapify(arr, i, 0)
return arr
What is the time complexity of Heapsort in the best, average, and worst
cases?
The time complexity of Heapsort in the best, average, and worst cases is
O(n log n).
What is the space complexity of Heapsort?

The space complexity of Heapsort is O(1), which means that it does not
require additional memory to perform the sorting operation.
Write a Python program to implement Heapsort.

# Function to build the binary heap
def build_heap(arr):
n = len(arr)
# Build a max heap
for i in range(n, -1, -1):
heapify(arr, n, i)
# Heapify function
def heapify(arr, n, i):
largest = i # Initialize largest as root
l=2*i+1 # left = 2*i + 1
r=2*i+2 # right = 2*i + 2
# See if left child of root exists and is
# greater than root
if l < n and arr[i] < arr[l]:
largest = l
# See if right child of root exists and is
# greater than root
if r < n and arr[largest] < arr[r]:
largest = r
# Change root, if needed
if largest != i:
arr[i],arr[largest] = arr[largest],arr[i] # swap
# Heapify the root.
heapify(arr, n, largest)
# The main function to sort an array of given size
def heapsort(arr):
n = len(arr)
# Build a maxheap.
build_heap(arr)
heapify(arr, i, 0)
# Driver code to test above
arr = [ 12, 11, 13, 5, 6, 7]
heapsort(arr)
n = len(arr)
print ("Sorted array is")
for i in range(n):
print ("%d" %arr[i]),
Explain how Heapsort works in detail.
Heapsort works by first creating a binary heap from the collection of
elements. The binary heap is then used to build a heap which is used by
Heapsort to sort the elements. The Heapsort algorithm consists of two steps.
The first step is to build the binary heap which is done by comparing each
node to its children and swapping them if the parent node is larger than the
child node. The second step is to sort the elements. This is done by
removing the root node of the binary heap and placing it in the sorted array.
The remaining elements are then reheapified and the process is repeated
until all elements have been placed in the sorted array.
BUBBLE SORT
Data Structures and Algorithms are fundamental concepts in programming
and software engineering. Bubble Sort is one of the most popular sorting
algorithms due to its simplicity and ease of implementation. It is an in-place
comparison-based sorting algorithm that can be used to sort a collection of
elements, such as an array or a list. In this article, we will discuss how
Bubble Sort works in detail, its time complexity (best, average, and worst
cases), and its space complexity (worst). We will also look at some
examples of Bubble Sort written in Python.
What is Bubble Sort?

Bubble Sort is an algorithm that works by going through an array of
elements and swapping adjacent elements if they are out of order. This
process is repeated until the array is sorted. It is a simple sorting algorithm
that is often used to introduce the concept of sorting algorithms to
beginners.
How Does Bubble Sort Work?

As mentioned before, Bubble Sort works by going through an array of
elements, comparing adjacent elements and swapping them if they are out
of order. This process is repeated until the array is sorted.
Let’s look at an example. We have an array of numbers: [3, 5, 2, 7, 1]. We

will use Bubble Sort to sort this array in ascending order.
First, we compare the first two elements, 3 and 5. Since 3 is less than 5, we
do not need to swap them.
Next, we compare the second and third elements, 5 and 2. Since 5 is greater
than 2, we need to swap them. Our array now looks like this: [3, 2, 5, 7, 1].
Next, we compare the third and fourth elements, 5 and 7. Since 5 is less
than 7, we do not need to swap them.
Finally, we compare the fourth and fifth elements, 7 and 1. Since 7 is

greater than 1, we need to swap them. Our array now looks like this: [3, 2,
5, 1, 7].
This is one iteration of the algorithm. We need to repeat this process until
the array is sorted. We repeat the process until our array looks like this: [1,
2, 3, 5, 7].
The Bubble Sort algorithm can be broken down into two main steps:
Compare adjacent elements and swap them if they are out of

order.
Repeat this process until the array is sorted.
Time Complexity
The time complexity of Bubble Sort is determined by the number of
iterations or passes that are needed to sort the array. In the best case, the
array is sorted in one pass, so the time complexity is O(n). In the average
case, the array is sorted in n/2 passes, so the time complexity is O(n2). In
the worst case, the array is sorted in n passes, so the time complexity is
O(n2).
Space Complexity
The space complexity of Bubble Sort is O(1). This is because the algorithm
works in-place, meaning that it does not require any additional storage
space.
Examples
Now that we have discussed how Bubble Sort works and its time and space
complexities, let’s look at some examples of Bubble Sort written in Python.
First, we will look at a simple example of Bubble Sort.
def bubble_sort(arr):
# Iterate over the array
for i in range(len(arr)-1):
# Iterate over the unsorted part of the array
for j in range(len(arr)-i-1):
# If an element is out of order, swap it
if arr[j] > arr[j+1]:
arr = [3, 5, 2, 7, 1]
bubble_sort(arr)
print(arr) # [1, 2, 3, 5, 7]
In the above example, we define a function, bubble_sort(), that takes an
array as an argument. Then, we iterate over the array, comparing adjacent
elements and swapping them if they are out of order. Finally, we print the
sorted array.
Now, let’s look at an example of Bubble Sort using Python’s built-in sorting
function.
arr = [3, 5, 2, 7, 1]
arr.sort()
print(arr) # [1, 2, 3, 5, 7]
In the above example, we create an array and then use Python’s built-in
sort() function to sort the array. This is a much simpler way to sort an array
in Python.
Conclusion
In this article, we discussed Bubble Sort, an in-place comparison-based
sorting algorithm. We looked at how the algorithm works in detail, its time
complexity (best, average, and worst), and its space complexity (worst). We
also looked at some examples of Bubble Sort written in Python.
Exercises
Write a function that takes an array as an argument and returns a
sorted array using Bubble Sort.
Write a function that takes an array as an argument and returns the
number of iterations needed to sort the array using Bubble Sort.
number of swaps needed to sort the array using Bubble Sort.
sorted array in reverse order using Bubble Sort.
Write a function that takes an array as an argument and a number as
an argument and returns the sorted array with the number in the
correct position using Bubble Sort.
Solutions
Write a function that takes an array as an argument and returns a
sorted array using Bubble Sort.
def bubble_sort(arr):
return arr
number of iterations needed to sort the array using Bubble Sort.
def bubble_sort_iterations(arr):
count = 0
count += 1
return count
number of swaps needed to sort the array using Bubble Sort.
def bubble_sort_swaps(arr):
count = 0
count += 1
return count
sorted array in reverse order using Bubble Sort.
def bubble_sort_reverse(arr):
if arr[j] < arr[j+1]:
return arr
Write a function that takes an array as an argument and a number as
an argument and returns the sorted array with the number in the
correct position using Bubble Sort.
def bubble_sort_with_number(arr, num):
# Insert the number into the correct position
arr.append(num)
if arr[i] > num:
arr[i], arr[-1] = arr[-1], arr[i]
return arr
INSERTION SORT
Insertion sort is one of the most widely-used sorting algorithms, and it is a
staple of data structures and algorithms courses. Insertion sort is a simple,
straightforward algorithm that is easy to understand and implement. It is
also relatively efficient in terms of time and space complexity. In this
article, we will explore the mechanics of insertion sort, its time complexity,
and its space complexity. We will also learn how to implement insertion
sort with Python code.
What is Insertion Sort?

Insertion sort is an algorithm that sorts a given list by building up a sorted
list one element at a time. The algorithm begins by sorting the first two
elements of the list. It then compares each subsequent element to the
elements already in the sorted list, and inserts it in the correct place. This
process is repeated until the entire list is sorted.
Insertion sort is a simple algorithm, but it can be surprisingly efficient. It is

also a stable algorithm, meaning that elements with equal values maintain
their relative order in the sorted list.
How Does Insertion Sort Work?

Insertion sort works by comparing each element to the elements already in
the sorted list. To understand how insertion sort works, we can use the
following example. Suppose we have the following list of numbers:
[5, 3, 7, 1, 4]
The algorithm begins by sorting the first two elements, [5, 3], resulting in
the following sorted list:
[3, 5]
Next, the algorithm compares the third element, 7, to the elements already
in the sorted list. Since 7 is greater than 5, it is inserted after 5:
[3, 5, 7]
The algorithm then compares the fourth element, 1, to the elements in the
sorted list. Since 1 is less than 3, it is inserted before 3:
[1, 3, 5, 7]
Finally, the algorithm compares the fifth element, 4, to the elements in the
sorted list. Since 4 is greater than 3 and less than 5, it is inserted between 3
and 5:
[1, 3, 4, 5, 7]
And the list is now sorted.
Time Complexity of Insertion Sort

The time complexity of insertion sort is dependent on the size of the list
being sorted. The best-case time complexity is O(n), which occurs when the
list is already sorted. The average-case time complexity is O(n^2), which
occurs when the list is in random order. The worst-case time complexity is
also O(n^2), which occurs when the list is in reverse order.
Space Complexity of Insertion

Sort Insertion sort has a space complexity of O(1), meaning that it requires
only a small amount of extra space to operate. This makes it an ideal
algorithm for sorting lists in-place, since it does not require additional
memory to operate. Implementing
Insertion Sort with Python

Now that we understand the mechanics of insertion sort, let’s learn how to
implement it with Python code. We will begin by defining a function to sort
a given list:
def insertion_sort(list):
for i in range(1, len(list)):
key = list[i]
j=i-1
while j >= 0 and list[j] > key:
list[j + 1] = list[j]
j -= 1
list[j + 1] = key
This function takes a list as an argument and sorts it using the insertion sort
algorithm. The function begins by looping through the list, starting at the
second element. The current element is stored as the key, while the previous
element is stored as j.
The function then enters a while loop that checks if the previous element is
greater than the key. If so, the element is shifted to the right and the key is
inserted in its place. This process is repeated until the list is sorted.
Conclusion
In this article, we have explored the mechanics of insertion sort, its time and
space complexity, and how to implement it with Python code. Insertion sort
is a simple and efficient algorithm that is used for sorting lists of elements.
With its O(n) best-case time complexity and O(1) space complexity, it is an
ideal algorithm for sorting lists in-place.
Exercises
Write a Python function that takes a list as an argument and sorts it
using insertion sort.
Write a Python function that takes a list as an argument and returns
the sorted list using insertion sort.
Write a Python function that takes a list as an argument and prints the
sorted list using insertion sort.
the index of a given element using insertion sort.
time complexity of insertion sort.
Solutions
Write a Python function that takes a list as an argument and sorts it
using insertion sort.
key = list[i]
j=i-1
j -= 1
list[j + 1] = key
the sorted list using insertion sort.
sorted_list = list.copy()
for i in range(1, len(sorted_list)):
key = sorted_list[i]
j=i-1
while j >= 0 and sorted_list[j] > key:
sorted_list[j + 1] = sorted_list[j]
j -= 1
sorted_list[j + 1] = key
return sorted_list
sorted list using insertion sort.
key = list[i]
j=i-1
j -= 1
list[j + 1] = key
print(list)
the index of a given element using insertion sort.
def insertion_sort(list, element):
sorted_list = list.copy()
for i in range(1, len(sorted_list)):
key = sorted_list[i]
j=i-1
while j >= 0 and sorted_list[j] > key:
sorted_list[j + 1] = sorted_list[j]
j -= 1
sorted_list[j + 1] = key
if element in sorted_list:
return sorted_list.index(element)
else:
return -1
time complexity of insertion sort.
def insertion_sort_time_complexity(list):
n = len(list)
if n == 0 or n == 1:
print("Best case time complexity: O(n)")
else:
print("Average case time complexity: O(n^2)")
print("Worst case time complexity: O(n^2)")
SELECTION SORT
Selection Sort is one of the classic sorting algorithms used to sort a given
array or collection of elements. It works by selecting the smallest element
from the unsorted part of the array and placing it at the beginning of the
array. This process is repeated until all elements are sorted. Selection Sort is
an in-place sorting algorithm with a time complexity of O(n2) in the worst,
average, and best cases. It is not an efficient algorithm because it requires
O(n) space in the worst case. In this article, we will take a detailed look at
how Selection Sort works and its time and space complexities. We will also
look at a Python implementation of Selection Sort and some coding
exercises to test your understanding.
What is Selection Sort?

Selection Sort is a sorting algorithm that sorts an array by repeatedly
finding the minimum element from the unsorted part of the array and
placing it at the beginning of the array. This process is repeated until all
elements are sorted. The algorithm divides the array into two parts: a sorted
part, which is initially empty, and an unsorted part, which contains all the
elements. Then, it selects the smallest element from the unsorted part and
places it at the end of the sorted part. This process is repeated until all
elements are sorted.
Selection Sort Algorithm

The Selection Sort algorithm works as follows:
Divide the array into two parts: a sorted part and an unsorted
part.
Select the smallest element from the unsorted part of the array.
Swap the selected element with the element at the beginning of
the unsorted part of the array.
Move the element at the beginning of the unsorted part of the
array to the end of the sorted part of the array.
Repeat steps 2-4 until all elements are sorted.
Selection Sort in Python

Let’s now look at a Python implementation of the Selection Sort algorithm.
The following Python code implements the Selection Sort algorithm:
def selection_sort(arr):
for i in range(len(arr)):
# Find the minimum element in the unsorted part of the array
min_idx = i
for j in range(i+1, len(arr)):
if arr[min_idx] > arr[j]:
min_idx = j
# Swap the minimum element with the element at the beginning of the
unsorted part
arr[i], arr[min_idx] = arr[min_idx], arr[i]
# Example
arr = [3, 4, 1, 5, 2]
selection_sort(arr)
print(arr) # Output: [1, 2, 3, 4, 5]
In the above code, we first define a function selection_sort(). This function
takes an array as an argument and sorts it using the Selection Sort
algorithm. The function iterates over the array and finds the minimum
element in the unsorted part of the array. Then, it swaps the minimum
element with the element at the beginning of the unsorted part. This process
is repeated until all elements are sorted. Finally, we test the code by creating
an array and passing it to the selection_sort() function.
Time Complexity
The time complexity of Selection Sort depends on the number of elements
in the array. The best case time complexity of Selection Sort is O(n2). This
occurs when the array is already sorted and the algorithm needs to iterate
over the array only once. The average and worst case time complexities of
Selection Sort are also O(n2). This is because the algorithm needs to
compare all elements in the array for each iteration.
Space Complexity
The space complexity of Selection Sort is O(n). This is because the
algorithm needs to store the minimum element for each iteration.
Conclusion
In this article, we discussed Selection Sort, a classic sorting algorithm used
to sort an array. We looked at how Selection Sort works and its time and
space complexities. We also looked at a Python implementation of
Selection Sort and some coding exercises to test your understanding.
Selection Sort is an in-place sorting algorithm with time complexity of
O(n2) in the worst, average, and best cases. It is not an efficient algorithm
because it requires O(n) space in the worst case.
Exercises
Write a Python program to sort a list of numbers using the Selection
Sort algorithm.
Write a Python program to sort a list of strings using the Selection Sort
algorithm.
Write a Python program to sort a list of tuples using the Selection Sort
algorithm.
Write a Python program to sort a list of dictionaries using the Selection
Sort algorithm.
Write a Python program to sort a list of custom objects using the
Selection Sort algorithm.
Solutions
Write a Python program to sort a list of numbers using the Selection
Sort algorithm.
min_idx = i
min_idx = j
unsorted part
# Example
arr = [3, 4, 1, 5, 2]
selection_sort(arr)
print(arr) # Output: [1, 2, 3, 4, 5]
Write a Python program to sort a list of strings using the Selection Sort
algorithm.
min_idx = i
min_idx = j
unsorted part
# Example
arr = ["cat", "dog", "bird", "fish"]
selection_sort(arr)
print(arr) # Output: ["bird", "cat", "dog", "fish"]
Write a Python program to sort a list of tuples using the Selection Sort
algorithm.
min_idx = i
if arr[min_idx][0] > arr[j][0]:
min_idx = j
unsorted part
# Example
arr = [(3, "cat"), (4, "dog"), (1, "bird"), (5, "fish")]
selection_sort(arr)
print(arr) # Output: [(1, "bird"), (3, "cat"), (4, "dog"), (5, "fish")]
Write a Python program to sort a list of dictionaries using the Selection
Sort algorithm.
min_idx = i
if arr[min_idx]["age"] > arr[j]["age"]:
min_idx = j
unsorted part
# Example
arr = [{"name": "John", "age": 32}, {"name": "Jane", "age": 28}, {"name":
"Bob", "age": 45}]
selection_sort(arr)
print(arr) # Output: [{"name": "Jane", "age": 28}, {"name": "John", "age":
32}, {"name": "Bob", "age": 45}]
Write a Python program to sort a list of custom objects using the
Selection Sort algorithm.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
min_idx = i
if arr[min_idx].age > arr[j].age:
min_idx = j
unsorted part
# Example
arr = [Person("John", 32), Person("Jane", 28), Person("Bob", 45)]
selection_sort(arr)
print([p.name for p in arr]) # Output: ["Jane", "John", "Bob"]
TREE SORT
Tree sort is an efficient sorting algorithm that uses a binary tree data
structure to sort data. It is a comparison-based sorting algorithm, meaning it
compares two elements at a time to determine their relative order. Tree sort
is a stable sorting algorithm, meaning it preserves the relative order of equal
elements. Tree sort has a time complexity of O(n log n) on average and in
the worst case, and a space complexity of O(n) in the worst case.
What is a Binary Tree?

A binary tree is a data structure that stores data in nodes. A node has two
children, a left child and a right child. The left child is always less than the
parent node and the right child is always greater than the parent node. This
allows the tree to be sorted in an efficient manner.
How Tree Sort Works

Tree sort works by inserting the elements of an unsorted list into a binary
tree. The tree is then traversed in-order to retrieve the elements in sorted
order. Tree sort is an efficient sorting algorithm as it only requires one
comparison per item, making it faster than other comparison-based sorting
algorithms such as quicksort and merge sort.
Python Code
The following Python code shows how tree sort works:
# Define a Node class

class Node:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
# Define a Tree class
class Tree:
def __init__(self):
self.root = None
# Insert a new node into the tree
def insert(self, value):
if self.root == None:
self.root = new_node
else:
curr_node = self.root
while True:
if value <= curr_node.value:
if curr_node.left == None:
curr_node.left = new_node
break
else:
curr_node = curr_node.left
else:
if curr_node.right == None:
curr_node.right = new_node
break
else:
curr_node = curr_node.right
# Traverse the tree in-order to retrieve the elements
# in sorted order
def in_order_traversal(self, node):
if node != None:
self.in_order_traversal(node.left)
print(node.value)
self.in_order_traversal(node.right)
# Sort the elements of an unsorted list
# using tree sort
def tree_sort(unsorted_list):
tree = Tree()
for item in unsorted_list:
tree.insert(item)
sorted_list = []
tree.in_order_traversal(tree.root, sorted_list)
return sorted_list
Time Complexity
Tree sort has a time complexity of O(n log n) in the average and worst case.
This is because the tree must be traversed in-order to retrieve the elements
in sorted order, which requires O(n log n) time.
Space Complexity
Tree sort has a space complexity of O(n) in the worst case. This is because
the tree data structure requires O(n) space to store the elements.
Conclusion
Tree sort is an efficient sorting algorithm that uses a binary tree data
structure to sort data. It is a comparison-based sorting algorithm, meaning it
compares two elements at a time to determine their relative order. Tree sort
has a time complexity of O(n log n) in the average and worst case, and a
space complexity of O(n) in the worst case.
Exercises
Write a function that takes an unsorted list and sorts it using the tree
sort algorithm.
Write a function to traverse a binary tree in pre-order.
Write a function to traverse a binary tree in post-order.
Given the following binary tree, write a function to return the deepest
node.
1
/\
23
/\/\
4567
Write a function to calculate the height of a binary tree.
Solutions
Write a function that takes an unsorted list and sorts it using the tree
sort algorithm.
def tree_sort(unsorted_list):
tree = Tree()
for item in unsorted_list:
tree.insert(item)
sorted_list = []
tree.in_order_traversal(tree.root, sorted_list)
return sorted_list
Write a function to traverse a binary tree in pre-order.
def pre_order_traversal(self, node):
if node != None:
print(node.value)
self.pre_order_traversal(node.left)
self.pre_order_traversal(node.right)
Write a function to traverse a binary tree in post-order.
def post_order_traversal(self, node):
if node != None:
self.post_order_traversal(node.left)
self.post_order_traversal(node.right)
print(node.value)
Given the following binary tree, write a function to return the deepest
node.
1
/\
23
/\/\
4567
def deepest_node(root):
if root is None:
return None
queue = [root]
deepest_node = None
while queue:
node = queue.pop(0)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
deepest_node = node
return deepest_node
Write a function to calculate the height of a binary tree.
def height(root):
if root is None:
return 0
else:
left_height = height(root.left)
right_height = height(root.right)
if left_height > right_height:
return left_height + 1
else:
return right_height + 1
SHELL SORT
Shell Sort is an efficient sorting algorithm that falls under the category of
insertion sort. It was developed by Donald Shell in 1959, and is a type of
comparison sort. Shell Sort works by comparing elements that are far apart,
and then gradually reducing the gap between the elements until the array is
eventually sorted. This technique allows Shell Sort to move larger elements
to their correct positions more quickly than other sorting algorithms.
Shell Sort is a general-purpose sorting algorithm that is relatively simple to

understand and implement. It works by comparing elements that are far
apart and then gradually reducing the gap between the elements until the
array is eventually sorted. This article will provide a detailed explanation of
how Shell Sort works, as well as its time and space complexities. We will
also provide a python code example for each of the topics covered.
How Does Shell Sort Work?

Shell Sort is a sorting algorithm that works by comparing elements that are
far apart and gradually reducing the gap between the elements until the
array is eventually sorted. It works by first comparing elements that are far
apart, and then gradually reducing the gap between the elements until the
array is eventually sorted.
First, the array is divided into subarrays. Each subarray consists of elements
with a certain gap between them. The gap is usually set to be the length of
the array divided by 2. The array is then sorted using insertion sort. After
the insertion sort is complete, the gap is decreased by half and the process
repeats. This process is repeated until the gap is 1 and the array is sorted.
Let’s look at an example to understand how Shell Sort works. Consider the
following array of integers:
[5, 4, 1, 8, 7, 2, 9, 6, 3]
We will use a gap of 4 for this example. The array is then divided into
subarrays with the following elements:
Subarray 1: [5, 1, 7, 9]
Subarray 2: [4, 8, 2, 6]
Subarray 3: [3]
We then sort each of the subarrays using insertion sort. The sorted subarrays
are as follows:
Subarray 1: [1, 5, 7, 9]
Subarray 2: [2, 4, 6, 8]
Subarray 3: [3]
Now, we reduce the gap to 2. The array is then divided into subarrays with
the following elements:
Subarray 1: [1, 5, 7]
Subarray 2: [2, 4, 6, 8]
Subarray 3: [3]
are as follows:
Subarray 1: [1, 5, 7]
Subarray 2: [2, 4, 6, 8]
Subarray 3: [3]
Finally, we reduce the gap to 1. The array is then divided into subarrays
with the following elements:
Subarray 1: [1, 5, 7]
Subarray 2: [2, 4, 6]
Subarray 3: [3, 8]
are as follows:
Subarray 1: [1, 5, 7]
Subarray 2: [2, 4, 6]
Subarray 3: [3, 8]
After the subarrays are sorted, the array is combined and sorted using
insertion sort. The final sorted array is:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Time Complexity of Shell Sort

The time complexity of Shell Sort depends on the gap sequence used. The
best case time complexity is O(n). This occurs when the gap sequence is
defined as 2^k – 1, where k is the number of elements in the array.
The average time complexity of Shell Sort is O(n^2). This occurs when the
gap sequence is defined as 2^k – 1, where k is the number of elements in
the array.
The worst case time complexity of Shell Sort is O(n^2). This occurs when
the gap sequence is defined as 2^k – 1, where k is the number of elements
in the array.
Space Complexity of Shell Sort

The space complexity of Shell Sort is O(1). This is because the algorithm
does not require any additional storage space other than the array being
sorted.
Python Code Example

Now that we have a good understanding of how Shell Sort works, the time
and space complexities, let’s look at a Python code example.
# Function to sort the array

def shellSort(arr):
# Start with a big gap, then reduce the gap
n = len(arr)
gap = n//2
# Do a gapped insertion sort for this gap size.
# The first gap elements a[0..gap-1] are already in gapped
# order keep adding one more element until the entire array
# is gap sorted
while gap > 0:
for i in range(gap,n):
# add a[i] to the elements that have been gap sorted
# save a[i] in temp and make a hole at position i
temp = arr[i]
# shift earlier gap-sorted elements up until the correct
# location for a[i] is found
j=i
while j >= gap and arr[j-gap] > temp:
arr[j] = arr[j-gap]
j -= gap
# put temp (the original a[i]) in its correct location
arr[j] = temp
gap //= 2
# Driver Code
arr = [ 5, 4, 1, 8, 7, 2, 9, 6, 3 ]
shellSort(arr)
print ("Sorted array:")
print(arr[i]),
Conclusion
In this article, we discussed Shell Sort, a type of comparison sorting
algorithm. We discussed how it works, its time and space complexities, and
provided a Python code example. We hope this article provided a clear
understanding of Shell Sort and its various aspects.
Exercises
Write a function that takes in an array and sorts it using Shell Sort.
Write a function that takes in a gap sequence and sorts an array using
Shell Sort.
Write a function that takes in an array and returns its time complexity
using Shell Sort.
Write a function that takes in an array and returns its space complexity
using Shell Sort.
Write a program to sort an array using Shell Sort.
Solutions
Write a function that takes in an array and sorts it using Shell Sort.
def shellSort(arr):
n = len(arr)
gap = n//2
while gap > 0:
temp = arr[i]
j=i
arr[j] = arr[j-gap]
j -= gap
arr[j] = temp
gap //= 2
Write a function that takes in a gap sequence and sorts an array using
Shell Sort.
def shellSort(arr, gap_sequence):
n = len(arr)
for gap in gap_sequence:
temp = arr[i]
j=i
arr[j] = arr[j-gap]
j -= gap
arr[j] = temp
Write a function that takes in an array and returns its time complexity
using Shell Sort.
def shellSortTimeComplexity(arr):
n = len(arr)
gap = n//2
time_complexity = 0
while gap > 0:
time_complexity += 1
temp = arr[i]
j=i
arr[j] = arr[j-gap]
j -= gap
time_complexity += 1
arr[j] = temp
gap //= 2
return time_complexity
Write a function that takes in an array and returns its space complexity
using Shell Sort.
def shellSortSpaceComplexity(arr):
n = len(arr)
space_complexity = 0
for i in range(n):
space_complexity += 1
return space_complexity
Write a program to sort an array using Shell Sort.
def shellSort(arr):
n = len(arr)
gap = n//2
while gap > 0:
temp = arr[i]
j=i
arr[j] = arr[j-gap]
j -= gap
arr[j] = temp
gap //= 2
arr = [ 5, 4, 1, 8, 7, 2, 9, 6, 3 ]
shellSort(arr)
print ("Sorted array:")
print(arr[i]),
BUCKET SORT
Bucket sort is an efficient sorting algorithm that uses buckets to sort a
collection of items. It is one of the most efficient sorting algorithms, with an
average time complexity of O(n) and a worst-case time complexity of
O(n^2). Bucket sort is often used in data structures and algorithms with
Python due to its efficient performance and ease of implementation.
In this article, we will cover the basics of bucket sort, including how the
algorithm works, its time and space complexity, and a Python code example
to illustrate the algorithm. We will also provide some coding exercises at
the end of the article to test the reader’s understanding of bucket sort.
What is Bucket Sort?

Bucket sort is an efficient sorting algorithm that works by dividing a
collection of items into buckets, then sorting each bucket independently. It
is a comparison-based sorting algorithm, meaning it uses comparisons
between elements to determine the order of the elements.
Bucket sort is often used to sort a collection of items with a small range of
values, such as integers between 0 and 10. The algorithm works by first
creating a number of buckets, then distributing the items into the buckets
based on the item’s value. Once the items are distributed into the buckets,
the buckets are sorted using a sorting algorithm of choice (typically
insertion sort or selection sort). Finally, the sorted buckets are combined
into a single sorted collection.
How Does Bucket Sort Work?

Bucket sort works by first dividing a collection of items into buckets, then
sorting each bucket independently. The algorithm works as follows:
Create a number of buckets.

Distribute the items into the buckets based on the item’s value.
Sort each bucket using a sorting algorithm of choice (typically
insertion sort or selection sort).
Combine the sorted buckets into a single sorted collection.
Let’s look at an example to illustrate how bucket sort works. Suppose we

have the following collection of integers:
[7, 3, 5, 2, 1, 9, 4, 8, 6]
We can divide the collection into 8 buckets, with each bucket containing a
range of values. For example, the first bucket could contain all integers
from 0 to 1, the second from 2 to 3, and so on. The buckets would look like
this:
Bucket 1 [0, 1]
Bucket 2 [2, 3]
Bucket 3 [4, 5]
Bucket 4 [6, 7]
Bucket 5 [8, 9]
Once the buckets are created, we can distribute the items into the buckets
based on their value. For example, the number 7 would go into the fourth
bucket, 3 into the second bucket, and so on. The buckets would now look
like this:
Bucket 1 [1]
Bucket 2 [2, 3]
Bucket 3 [4, 5]
Bucket 4 [6, 7]
Bucket 5 [8, 9]
Next, we can sort each bucket using a sorting algorithm of choice. For this
example, we will use insertion sort to sort each bucket. After sorting, the
buckets would look like this:
Bucket 1 [1]
Bucket 2 [2, 3]
Bucket 3 [4, 5]
Bucket 4 [6, 7]
Bucket 5 [8, 9]
Finally, we can combine the sorted buckets into a single sorted collection.
The resulting collection would look like this:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Time Complexity of Bucket Sort

The time complexity of bucket sort is dependent on the sorting algorithm
used to sort each bucket. In general, the best-case time complexity of
bucket sort is O(n), while the worst-case time complexity is O(n^2).
The best-case time complexity of bucket sort occurs when the buckets are
already sorted, meaning the sorting algorithm used to sort each bucket has a
time complexity of O(1). In this scenario, the time complexity of bucket
sort is O(n), since it only takes one pass through the buckets to combine
them into a single sorted collection.
The worst-case time complexity of bucket sort occurs when the buckets are
not sorted, meaning the sorting algorithm used to sort each bucket has a
time complexity of O(n^2). In this scenario, the time complexity of bucket
sort is O(n^2), since it takes n passes through the buckets to combine them
into a single sorted collection.
Space Complexity of Bucket Sort
The space complexity of bucket sort is O(n). This is because, in the worst
case, the algorithm requires additional space to store the buckets and the
sorted items.
Python Code Example

Now that we have covered the basics of bucket sort, let’s look at a Python
code example to illustrate the algorithm. The following code implements
bucket sort using the insertion sort algorithm to sort each bucket.
# Function to sort an array using bucket sort

def bucket_sort(arr):
# Get the maximum and minimum values in the array
max_val = max(arr)
min_val = min(arr)
# Create buckets for each value
buckets = [[] for _ in range(min_val, max_val + 1)]
# Distribute the array values into the buckets
buckets[arr[i] - min_val].append(arr[i])
# Sort each bucket using insertion sort
for i in range(len(buckets)):
insertion_sort(buckets[i])
# Combine the sorted buckets
sorted_arr = []
sorted_arr.extend(buckets[i])
return sorted_arr
# Function to sort a bucket using insertion sort
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i-1
while j >= 0 and key < arr[j] :
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
# Driver code
arr = [7, 3, 5, 2, 1, 9, 4, 8, 6]
sorted_arr = bucket_sort(arr)
# Print the sorted array
print(sorted_arr)
# Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Conclusion
In this article, we have covered the basics of bucket sort, including how the
algorithm works, its time and space complexity, and a Python code example
to illustrate the algorithm. Bucket sort is an efficient sorting algorithm with
an average time complexity of O(n) and a worst-case time complexity of
O(n^2). It is often used to sort a collection of items with a small range of
values, such as integers between 0 and 10.
Exercises
Write a Python function that implements bucket sort using selection
sort to sort each bucket.
Write a Python function that implements bucket sort using quick sort
to sort each bucket.
Write a Python program to generate a collection of random integers
between 0 and 10 and sort them using bucket sort.
Write a Python program to generate a collection of random items and
sort them using bucket sort.
What is the space complexity (worst) of Bucket Sort?
Solutions
Write a Python function that implements bucket sort using selection
sort to sort each bucket.
max_val = max(arr)
min_val = min(arr)
# Sort each bucket using selection sort
selection_sort(buckets[i])
sorted_arr = []
return sorted_arr
# Function to sort a bucket using selection sort
# Find the minimum element in the unsorted array
min_idx = i
min_idx = j
# Swap the found minimum element with the first element
Write a Python function that implements bucket sort using quick sort
to sort each bucket.
max_val = max(arr)
min_val = min(arr)
# Sort each bucket using quick sort
quick_sort(buckets[i], 0, len(buckets[i])-1)
sorted_arr = []
return sorted_arr
# Function to sort a bucket using quick sort
def quick_sort(arr, low, high):
if low < high:
# Partition the array
pi = partition(arr, low, high)
# Sort the elements before and after the partition
quick_sort(arr, low, pi-1)
quick_sort(arr, pi+1, high)
# Function to partition the array
def partition(arr, low, high):
i = (low-1) # Index of smaller element
pivot = arr[high] # Pivot
for j in range(low, high):
# If current element is smaller than or
# equal to pivot
if arr[j] <= pivot:
# Increment index of smaller element

i = i+1
arr[i],arr[j] = arr[j],arr[i]
arr[i+1],arr[high] = arr[high],arr[i+1]
return (i+1)
Write a Python program to generate a collection of random integers
between 0 and 10 and sort them using bucket sort.
max_val = max(arr)
min_val = min(arr)
sorted_arr = []
return sorted_arr
key = arr[i]
j = i-1
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
# Function to generate a collection of random integers
def generate_random_ints(n):
arr = []
for _ in range(n):
arr.append(random.randint(0, 10))
return arr
# Driver code
arr = generate_random_ints(10)
print(sorted_arr)
Write a Python program to generate a collection of random items and
sort them using bucket sort.
import random
max_val = max(arr)
min_val = min(arr)
sorted_arr = []
return sorted_arr
key = arr[i]
j = i-1
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
# Function to generate a collection of random items
def generate_random_items(n):
arr = []
for _ in range(n):
arr.append(random.randint(0, 10))
return arr
# Driver code
arr = generate_random_items(10)
print(sorted_arr)
What is the space complexity (worst) of Bucket Sort?
O(n)
RADIX SORT
Radix sort is an efficient algorithm that has been used to sort data since the
1950s. It is a non-comparative sorting technique which is based on the
distribution of the elements in an array. It is one of the oldest sorting
algorithms still in use today and is primarily used in computer science and
data analysis.
In this article, we’ll cover the basics of radix sort and how it works in detail,
its time complexity and space complexity, and a few examples of Python
code to help you understand the algorithm better. We’ll also include some
coding exercises with solutions that test your understanding of what was
covered in the article.
What is Radix Sort?

Radix sort is a non-comparative sorting algorithm that works by sorting
data in a particular order based on the digits of the elements in the array. It
is used to sort the elements of an array in linear time, which is much faster
than other sorting algorithms like insertion or selection sort.
The algorithm works by first dividing the elements of the array into groups
based on their individual digits and then sorting the groups in order from
least to greatest. This process is repeated until all the elements have been
sorted.
How Does Radix Sort Work?

Radix sort works by dividing the elements of the array into groups based on
their individual digits and then sorting the groups in order from least to
greatest. This process is repeated until all the elements have been sorted.
Let’s look at an example to understand the algorithm better. Suppose we

have an array of numbers:
[314, 299, 4, 8, 99]
If we want to sort this array using radix sort, we can divide the elements
into groups based on their individual digits:
Group 1: [4, 8]
Group 2: [99, 299]
Group 3: [314]
Now, we can sort the groups in order from least to greatest:
Group 1: [4, 8]
Group 2: [99, 299]
Group 3: [314]
Once the groups have been sorted, we can combine them together to get the
sorted array:
[4, 8, 99, 299, 314]
Time Complexity of Radix Sort

Radix sort has a time complexity of O(nk), where n is the number of
elements in the array and k is the number of digits in the largest element.
This means that the time it takes to sort an array using radix sort is
dependent on the size of the array and the number of digits in the elements.
It is important to note that radix sort is a very fast algorithm and has a better
time complexity than other sorting algorithms such as insertion and
selection sort.
Space Complexity of Radix Sort

The space complexity of radix sort is O(n+k), where n is the number of
This means that the amount of space required to sort an array using radix
sort is dependent on the size of the array and the number of digits in the
elements.
It is important to note that radix sort does not require any additional
memory, as it works in place. This makes radix sort a very efficient
algorithm for sorting large arrays.
Python Code for Radix Sort

Now that we understand how radix sort works and its time and space
complexity, let’s look at a few examples of Python code to help us
understand the algorithm better.
First, we’ll define a function that takes an array and returns the sorted array
using radix sort:
def radix_sort(arr):
# Find the maximum number to know number of digits
max_num = max(arr)
# Loop over each digit
exp = 1
while max_num/exp > 0:
# Create buckets
buckets = [[] for _ in range(10)]
# Put elements in respective buckets
for element in arr:
buckets[(element//exp) % 10].append(element)
# Flatten all the buckets
arr = [x for bucket in buckets for x in bucket]
# Move to next digit
exp *= 10
return arr
Now, let’s look at a few examples of using the radix_sort() function:
# Example 1
arr = [314, 299, 4, 8, 99]
sorted_arr = radix_sort(arr)
print(sorted_arr)
# Output: [4, 8, 99, 299, 314]
# Example 2
arr = [3, 27, 4, 9, 1]
sorted_arr = radix_sort(arr)
print(sorted_arr)
# Output: [1, 3, 4, 9, 27]
Conclusion
In this article, we covered the basics of radix sort and how it works in
detail, its time complexity and space complexity, and a few examples of
Python code to help you understand the algorithm better. We also included
some coding exercises with solutions to test your understanding of what
was covered in the article.
Radix sort is an efficient algorithm that has been used to sort data since the
1950s. It is a non-comparative sorting technique which is based on the
distribution of the elements in an array. It is one of the oldest sorting
algorithms still in use today and is primarily used in computer science and
data analysis.
Radix sort has a time complexity of O(nk), where n is the number of

The space complexity of radix sort is O(n+k), where n is the number of
This makes radix sort a very efficient algorithm for sorting large arrays.
Now that you know the basics of radix sort and how it works in Python, you
can use it to sort large arrays quickly and efficiently.
Exercises
Now that you know the basics of radix sort and how it works in Python,
let’s test your understanding with a few coding exercises.
Write a function that takes an array of integers and uses radix sort to
sort the array in ascending order.
Write a function that takes an array of strings and uses radix sort to
sort the array in alphabetical order.
Write a function that takes an array of floating point numbers and uses
radix sort to sort the array in ascending order.
Write a function that takes an array of characters and uses radix sort
to sort the array in alphabetical order.
Write a function that takes an array of tuples and uses radix sort to
sort the array in ascending order based on the first element of the
tuple.
Solutions
Write a function that takes an array of integers and uses radix sort to
sort the array in ascending order.
def radix_sort(arr):
max_num = max(arr)
exp = 1
# Create buckets
for element in arr:
buckets[(element//exp) % 10].append(element)
exp *= 10
return arr
Write a function that takes an array of strings and uses radix sort to
sort the array in alphabetical order.
def radix_sort_str(arr):
# Find the maximum length string to know number of digits
max_len = max([len(s) for s in arr])
# Loop over each character
for i in range(max_len):
# Create buckets
for element in arr:
if i < len(element):
buckets[ord(element[i]) - ord('a')].append(element)
else:
buckets[0].append(element)
return arr
Write a function that takes an array of floating point numbers and uses
radix sort to sort the array in ascending order.
def radix_sort_float(arr):
max_num = max(arr)
exp = 1
# Create buckets
for element in arr:
buckets[int(element//exp % 10)].append(element)
exp *= 10
return arr
Write a function that takes an array of characters and uses radix sort
to sort the array in alphabetical order.
def radix_sort_char(arr):
# Find the maximum length string to know number of digits
max_len = max([len(s) for s in arr])
# Loop over each character
for i in range(max_len):
# Create buckets
for element in arr:
if i < len(element):
buckets[ord(element[i]) - ord('a')].append(element)
else:
buckets[0].append(element)
return arr
Write a function that takes an array of tuples and uses radix sort to
sort the array in ascending order based on the first element of the
tuple.
def radix_sort_tuple(arr):
max_num = max([t[0] for t in arr])
exp = 1
# Create buckets
for element in arr:
buckets[int(element[0]//exp % 10)].append(element)
exp *= 10
return arr
COUNTING SORT
Counting Sort is an efficient sorting algorithm used with linear time
complexity in the best, average, and worst cases. It is a non-comparative
sorting algorithm that operates by counting the number of objects present in
a collection and then creating a new collection with the objects based on the
number of times they appear. Counting Sort is a stable sort, which means
that equal elements retain their original position relative to each other in the
sorted output.
This article will discuss the Counting Sort algorithm in detail and its time
and space complexities. It will also include Python code examples for each
topic, as well as five coding exercises with solutions to test the reader’s
What is Counting Sort?

Counting Sort is a sorting algorithm used to sort a collection of elements. It
is a non-comparative sorting algorithm that works by counting the number
of objects present in a collection and then creating a new collection with the
objects based on the number of times they appear. This is done by mapping
the elements to the frequency of their occurrence in the collection.
Counting Sort works best on collections that have a small number of

distinct elements. It is also a stable sort, which means that equal elements
retain their original position relative to each other in the sorted output.
Counting Sort Algorithm

The Counting Sort algorithm works in two steps. The first step is to create
an array, often referred to as a frequency array, that stores the number of
times each element appears in the collection. The second step is to use the
frequency array to create a sorted output.
Step 1: Create a frequency array
The first step of the Counting Sort algorithm is to create a frequency array.
This array stores the number of times each element appears in the
collection.
To create the frequency array, we first need to find the range of the elements
in the collection. The range is the difference between the largest and
smallest elements in the collection.
For example, if the collection contains elements from 0 to 9, the range is 9

(9 – 0 = 9).
Once we have the range, we can create an array with the same number of
elements as the range. Each element in the array corresponds to an element
in the collection. The value of each element in the array is the number of
times the corresponding element appears in the collection.
For example, if the collection contains elements from 0 to 9, we would

create an array of size 10 (0 to 9). The value of each element in this array is
the number of times the corresponding element appears in the collection.
Let’s look at an example. Consider the following array:
collection = [2, 5, 3, 0, 2, 3, 0, 3]
The range of this array is 5 (5 – 0 = 5). So, we need to create an array of

size 5. The value of each element in this array is the number of times the
corresponding element appears in the collection.
For example, the value of the first element in the array is 2, because the
element 0 appears twice in the collection. The value of the second element
in the array is 2, because the element 1 does not appear in the collection.
The value of the third element in the array is 3, because the element 2
appears three times in the collection, and so on.
The frequency array for the collection above is:
frequency_array = [2, 0, 3, 2, 0]
Step 2: Create a sorted output
The second step of the Counting Sort algorithm is to use the frequency
array to create a sorted output. To do this, we first need to create a prefix
sum array. A prefix sum array stores the cumulative sum of the elements in
the frequency array.
For example, consider the frequency array from the example above:
frequency_array = [2, 0, 3, 2, 0]
The prefix sum array for this frequency array is:
prefix_sum_array = [2, 2, 5, 7, 7]
The prefix sum array stores the cumulative sum of the elements in the
frequency array. The first element in the prefix sum array is the same as the
first element in the frequency array, because there is no element before it.
The second element in the prefix sum array is the sum of the first and
second elements in the frequency array. The third element in the prefix sum
array is the sum of the first, second, and third elements in the frequency
array, and so on.
Once we have the prefix sum array, we can use it to create the sorted output.
We start at the end of the prefix sum array and traverse backwards. For each
element in the prefix sum array, we subtract 1 from its value. We then use
this value as an index in the frequency array to find the corresponding
element. This element is the element we want to add to the sorted output.
For example, for the prefix sum array above, we start at the end and
traverse backwards. The last element in the prefix sum array is 7. We
subtract 1 from this value and get 6. We then use this value (6) as an index
in the frequency array and find the element at that index. The element at
index 6 in the frequency array is 0. So, the element we want to add to the
sorted output is 0.
We then repeat this process for the remaining elements in the prefix sum
array. The next element in the prefix sum array is 7. We subtract 1 from this
value and get 6. We then use this value (6) as an index in the frequency
array and find the element at that index. The element at index 6 in the
frequency array is 0. So, the element we want to add to the sorted output is
0.
We continue until we reach the first element in the prefix sum array. The
sorted output for the example above is:
sorted_output = [0, 0, 2, 2, 3, 3, 3, 5]
Time Complexity
The time complexity of Counting Sort is linear in the best, average, and
worst cases. The time complexity is O(n + k), where n is the number of
elements in the collection and k is the range of the elements in the
collection.
In the best case, when the elements in the collection are already sorted,
Counting Sort will take O(n) time since we only need to traverse the
collection once to create the frequency array.
In the average case, when the elements in the collection are randomly
distributed, Counting Sort will take O(n + k) time since we need to traverse
the collection once to create the frequency array and then traverse the
frequency array once to create the sorted output.
In the worst case, when the elements in the collection are in reverse order,
Counting Sort will take O(n + k) time since we need to traverse the entire
collection and frequency array to create the sorted output.
Space Complexity
The space complexity of Counting Sort is O(k), where k is the range of the
elements in the collection. This is because we need to create an array of size
k to store the frequency of each element in the collection.

Let’s look at some Python code examples of the Counting Sort algorithm.
The first step of the Counting Sort algorithm is to create a frequency array.
We can do this using the following Python code:
def count_sort(collection):
# Get the range of the elements in the collection
min_element = min(collection) # Get the minimum element in the
collection
max_element = max(collection) # Get the maximum element in the
collection
range = max_element - min_element + 1 # Calculate the range of the
elements in the collection
# Create an array of size range to store the frequencies of each element
frequency_array = [0] * range
# Iterate through the collection to count the frequency of each element
for element in collection:
frequency_array[element - min_element] += 1
return frequency_array
The second step of the Counting Sort algorithm is to use the frequency
array to create a sorted output. We can do this using the following Python
code:
collection
collection
# Create a prefix sum array
prefix_sum_array = [0] * range
for i in range(1, len(prefix_sum_array)):
prefix_sum_array[i] = prefix_sum_array[i - 1] + frequency_array[i - 1]
# Create a sorted output array
sorted_output = [0] * len(collection)
sorted_output[prefix_sum_array[element - min_element]] = element
prefix_sum_array[element - min_element] += 1
return sorted_output
Conclusion
In this article, we discussed the Counting Sort algorithm in detail and its
time and space complexities. We also saw some Python code examples of
the algorithm. Counting Sort is a sorting algorithm used to sort a collection
of elements. It is a non-comparative sorting algorithm that works by
counting the number of objects present in a collection and then creating a
new collection with the objects based on the number of times they appear.
Counting Sort is an efficient sorting algorithm used with linear time
complexity in the best, average, and worst cases. It is a stable sort, which
means that equal elements retain their original position relative to each
other in the sorted output.
Exercises
What is the Space Complexity of Counting Sort?
What is the worst case Time Complexity of Counting Sort?
Write a Python program to sort the following array using the Counting
Sort algorithm: [6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2]
Sort algorithm: [-2, -5, -45, -66, -1000, 0, 1, 2, 5, 10]
Sort algorithm: [2, 1, 0, -1, -2, 0, 1, 0, -2]
Solutions
What is the Space Complexity of Counting Sort?
O(k), where k is the range of the elements in the collection.
What is the worst case Time Complexity of Counting Sort?

Worst case, when the elements in the collection are in reverse order,
Counting Sort will take O(n + k).
Sort algorithm: [6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2]
collection
collection
collection = [6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2]
sorted_output = count_sort(collection)
print(sorted_output)
# Output: [0, 0, 1, 1, 2, 2, 3, 3, 4, 6, 6]
Sort algorithm: [-2, -5, -45, -66, -1000, 0, 1, 2, 5, 10]
collection
collection
collection = [-2, -5, -45, -66, -1000, 0, 1, 2, 5, 10]
# Output: [-1000, -66, -45, -5, -2, 0, 1, 2, 5, 10]
Sort algorithm: [2, 1, 0, -1, -2, 0, 1, 0, -2]
collection
collection
collection = [2, 1, 0, -1, -2, 0, 1, 0, -2]
# Output: [-2, -2, -1, 0, 0, 0, 1, 1, 2]
CUBE SORT
Cube sort is an efficient sorting algorithm that works on real-world data. It
is based on the idea of partitioning the data set into “cubes” and sorting the
elements within each cube. The algorithm works by scanning the given data
set and grouping elements into cubes. It then sorts each cube separately and
then merges the sorted cubes together. Cube sort is one of the most efficient
sorting algorithms and is often used in applications such as database
sorting.
In this article, we will discuss the cube sort algorithm in detail, including its
time and space complexity. We will also provide Python code examples to
illustrate how the algorithm works.
How Cube Sort Works

The cube sort algorithm works by dividing the given data set into cubes.
Each cube is a subset of the data set that contains elements that are similar
to each other. The elements in each cube are then sorted using the
appropriate sorting algorithm. The sorted cubes are then merged together to
form the sorted data set.
The cube sort algorithm begins by scanning the given data set and dividing
it into cubes. This is done by first finding the minimum and maximum
values in the data set. The difference between the minimum and maximum
values is then divided into a predetermined number of cubes. This
predetermined number can be changed to adjust the speed and accuracy of
the sorting algorithm.
Once the cubes are determined, the elements in each cube are sorted using
an appropriate sorting algorithm. For example, if the elements in the cube
are integers, then a quick sort might be used. If the elements in the cube are
strings, then a merge sort might be used. Once each cube is sorted, the
cubes are then merged together to form the sorted data set.
Time Complexity of Cube Sort

The time complexity of cube sort depends on the size of the data set and the
sorting algorithm used to sort the elements within each cube. The time
complexity of cube sort is O(n log n) in the best case, O(n log n) in the
average case, and O(n2) in the worst case.
The best case time complexity of cube sort is O(n log n). This occurs when
the elements in each cube are already sorted, so no further sorting is
required. The average case time complexity of cube sort is also O(n log n).
This occurs when the elements in each cube are randomly distributed and
require sorting. The worst case time complexity of cube sort is O(n2). This
occurs when the elements in each cube are sorted in reverse order and
require a lot of sorting.
Space Complexity of Cube Sort

The space complexity of cube sort is O(n). This is because the algorithm
requires an additional array to store the sorted cubes. The space complexity
remains constant regardless of the size of the data set.

The following Python code examples show how the cube sort algorithm
works.
# Example 1: Cube Sort

# Input list of numbers
numbers = [6, 4, 8, 2, 5, 9, 7, 1, 3]
# Find the minimum and maximum values
min_value = min(numbers)
max_value = max(numbers)
# Calculate the number of cubes
num_cubes = int(max_value - min_value + 1)
# Create a list of cubes
cubes = [[] for _ in range(num_cubes)]
# Partition the list into cubes
for num in numbers:
cubes[num - min_value].append(num)
# Sort each cube
for cube in cubes:
cube.sort()
# Merge the sorted cubes
sorted_numbers = []
for cube in cubes:
sorted_numbers.extend(cube)
# Print the sorted list
print(sorted_numbers)
Here is another example:
# Example 2: Cube Sort using Quick Sort

numbers = [6, 4, 8, 2, 5, 9, 7, 1, 3]
for num in numbers:
# Sort each cube using Quick Sort
for cube in cubes:
quick_sort(cube, 0, len(cube) - 1)
sorted_numbers = []
for cube in cubes:
Conclusion
In this article, we discussed cube sort, a sorting algorithm that is based on
the idea of partitioning the data set into cubes and then sorting the elements
within each cube. We also discussed the time and space complexity of cube
sort, as well as provided Python code examples to illustrate how the
algorithm works. Cube sort is an efficient sorting algorithm that is often
used in applications such as database sorting.
Exercises
Write a Python program using cube sort to sort a list of numbers in
ascending order.
Write a Python program using cube sort to sort a list of strings in
alphabetical order.
Modify the Python code from Example 1 to sort the numbers in
descending order.
Write a Python program to calculate the time complexity of cube sort
in the worst case.
Write a Python program to calculate the space complexity of cube sort.
Solutions
Write a Python program using cube sort to sort a list of numbers in
ascending order.
numbers = [6, 4, 8, 2, 5, 9, 7, 1, 3]
for num in numbers:
# Sort each cube
for cube in cubes:
cube.sort()
sorted_numbers = []
for cube in cubes:
Write a Python program using cube sort to sort a list of strings in
alphabetical order.
# Input list of strings
strings = ["cat", "dog", "bird", "fish", "mouse"]
min_value = ord(min(strings))
max_value = ord(max(strings))
cubes[ord(string) - min_value].append(string)
# Sort each cube using Merge Sort
for cube in cubes:
merge_sort(cube, 0, len(cube) - 1)
sorted_strings = []
for cube in cubes:
sorted_strings.extend(cube)
print(sorted_strings)
Modify the Python code from Example 1 to sort the numbers in
descending order.
numbers = [6, 4, 8, 2, 5, 9, 7, 1, 3]
for num in numbers:
# Sort each cube
for cube in cubes:
cube.sort(reverse=True)
sorted_numbers = []
for cube in cubes:
Write a Python program to calculate the time complexity of cube sort
in the worst case.
def cube_sort_time_complexity(n):
# Worst case time complexity is O(n^2)
return n**2
# Test cases
print(cube_sort_time_complexity(5)) # 25
print(cube_sort_time_complexity(10)) # 100
Write a Python program to calculate the space complexity of cube sort.
def cube_sort_space_complexity(n):
# Space complexity is O(n)
return n
# Test cases
print(cube_sort_space_complexity(5)) # 5
print(cube_sort_space_complexity(10)) # 10
SEARCHING
ALGORITHMS
LINEAR SEARCH
Welcome to Data Structures and Algorithms with Python! In this course, we
will be learning how to use Python to solve data structure and algorithm
problems. This article will provide an in-depth look at the Linear Search
Algorithm, including how it works, its time and space complexities, and
examples of how to implement it in Python. At the end of the article, you
will also find five coding exercises with solutions to help you test your
What is Linear Search?

Linear search is an algorithm used to search for an element in a given list or
array of elements. It is a simple algorithm that starts at the beginning of the
list and traverses through each element until it finds a match or reaches the
end of the list. Linear search can be used to search for a specific element in
an array, or to find the index of an element in an array.
How Does Linear Search Work?

Linear search works by starting at the beginning of the list and checking
each element in the list until it finds a match or reaches the end of the list. It
does this by comparing each element in the list to the element we are
searching for. If the element we are searching for is found, the Linear
Search algorithm returns the index of the element in the array. If it is not
found, the algorithm returns -1.
The following is an example of how the Linear Search algorithm works.

Let’s say we have the following array:
arr = [1, 3, 4, 5, 6, 7, 8]
We want to search for the element 5. The Linear Search algorithm starts at
the beginning of the list and checks each element in the list until it finds a
match or reaches the end of the list. In this case, the algorithm finds 5 at
index 3 and returns the index of the element (3).
Time Complexity
The time complexity of the Linear Search algorithm is O(n). This means
that the time taken by the algorithm to search for an element increases
linearly with the size of the list or array.
The best case time complexity of the Linear Search algorithm is O(1). This
means that the time taken by the algorithm to search for an element is
constant regardless of the size of the list or array. This happens when the
element we are searching for is at the beginning of the list.
The worst case time complexity of the Linear Search algorithm is O(n).
This means that the time taken by the algorithm to search for an element
increases linearly with the size of the list or array. This happens when the
element we are searching for is at the end of the list.
Space Complexity
The space complexity of the Linear Search algorithm is O(1). This means
that the space taken by the algorithm to search for an element is constant
regardless of the size of the list or array.
Now that we have an understanding of how the Linear Search algorithm
works and its time and space complexities, let’s look at how to implement it
in Python.
The following is an example of how to implement the Linear Search

algorithm in Python:
def linear_search(arr, target):

# Set pointer to first element
pointer = 0
# Loop through array
while pointer < len(arr):
# Check if element is target value
if arr[pointer] == target:
# Return index if found
return pointer
# Move pointer to next element
pointer += 1
# Target value not found
return -1
The code above is a basic implementation of linear search in Python. It
takes in an array or list (arr) and a target value (target), and returns the
index of the target value if it is found in the array. If the target value is not
found, it will return -1.
Conclusion
In this article, we have discussed the Linear Search algorithm and looked at
how it works, its time and space complexities, and how to implement it in
Python. Linear search is a simple algorithm that can be used to search for an
element in an array or to find the index of an element in an array. The time
complexity of the Linear Search algorithm is O(n) and the space complexity
is O(1).
Exercises
Write a function that takes in an array and a target value, and returns
the index of the target value if it is found. If the target value is not
found, return -1.
true if the target value is found in the array, and false if it is not.
Write a function that takes in an array, a target value, and a start
index. The function should return the index of the target value if it is
found starting from the given start index. If the target value is not
found, the function should return -1.
the index of the last occurrence of the target value in the array. If the
target value is not found, the function should return -1.
the number of times the target value appears in the array.
Solutions
the index of the target value if it is found. If the target value is not
found, return -1.
pointer = 0
return pointer
pointer += 1
return -1
true if the target value is found in the array, and false if it is not.
pointer = 0
# Return true if found
return True
pointer += 1
return False
Write a function that takes in an array, a target value, and a start
index. The function should return the index of the target value if it is
found starting from the given start index. If the target value is not
found, the function should return -1.
def linear_search(arr, target, start_index):
# Set pointer to start index
pointer = start_index
# Loop through array starting from start index
return pointer
pointer += 1
return -1
the index of the last occurrence of the target value in the array. If the
target value is not found, the function should return -1.
# Set pointer to last element
pointer = len(arr) - 1
# Loop through array in reverse
while pointer >= 0:
return pointer
# Move pointer to previous element
pointer -= 1
return -1
the number of times the target value appears in the array.
# Set counter to 0
counter = 0
pointer = 0
# Increment counter if found
counter += 1
pointer += 1
# Return counter
return counter
BINARY SEARCH
Binary search is an incredibly important and popular algorithm in computer
science. It is a search algorithm that works by dividing a list of elements
into two halves until the desired element is found. Binary search is an
efficient way of searching for a specific item in a large dataset and is often
used in applications where time is of the essence, such as web search
engines. Binary search is also commonly used in sorting algorithms such as
quicksort and heapsort.
In this article, we will discuss binary search in detail. We will cover how the
algorithm works, its time complexity, and its space complexity. We will also
provide examples in Python to help illustrate each concept.
How Binary Search Works

Binary search is a divide and conquer algorithm. It works by dividing a list
of elements into two halves until the desired element is found. The
algorithm begins by searching the middle element of the list. If the element
is not the one desired, the algorithm will search the left or right half of the
list, depending on whether the desired element is greater or less than the
middle element. This process is repeated until the desired element is found.
The following Python code is a more detailed implementation of a binary

search algorithm:
def binary_search(list, target):

left = 0
right = len(list) - 1
while left <= right:
mid = (left + right) // 2
if list[mid] == target:
return mid
elif list[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
def binary_search_recursive(list, target, left, right):
if left > right:
return -1
return mid
return binary_search_recursive(list, target, mid + 1, right)
else:
return binary_search_recursive(list, target, left, mid - 1)
Time Complexity
The time complexity of the binary search algorithm is O(log n), where n is
the number of elements in the list. This means that the algorithm will take
logarithmic time to run, which is significantly faster than linear search
algorithms.
In the best case scenario, the binary search algorithm will find the desired
element in the first iteration. This is known as a successful search, and the
time complexity for this is O(1).
In the average case scenario, the binary search algorithm will find the
desired element after a few iterations. The time complexity for this is O(log
n), which is still quite fast.
In the worst case scenario, the binary search algorithm will have to search
through the entire list before finding the desired element. The time
complexity for this is O(log n), which is still quite fast.
Space Complexity
The space complexity of the binary search algorithm is O(1). This means
that the algorithm does not require any additional memory to store data. As
a result, the algorithm is very efficient in terms of its memory usage.
Conclusion
In this article, we discussed binary search in detail. We covered how the
algorithm works, its time complexity, and its space complexity. We also
provided examples in Python to help illustrate each concept.
We learned that binary search is an efficient way of searching for a specific

item in a large dataset. The algorithm works by dividing a list of elements
into two halves until the desired element is found. We also learned that the
time complexity of the algorithm is O(log n), where n is the number of
elements in the list. This means that the algorithm will take logarithmic
time to run, which is significantly faster than linear search algorithms.
Finally, we learned that the space complexity of the algorithm is O(1),
which means that the algorithm does not require any additional memory to
store data.
Exercises
Write a function that takes a list of integers and a target value and
returns the index of the target value in the list. If the target value is not
in the list, the function should return -1.
returns the index of the target value in the list using a recursive
approach. If the target value is not in the list, the function should
return -1.
returns the index of the target value in the list using a tail recursive
return -1.
returns the index of the target value in the list using an iterative
return -1.
returns the index of the target value in the list using a divide and
conquer approach. If the target value is not in the list, the function
should return -1.
Solutions
returns the index of the target value in the list. If the target value is not
in the list, the function should return -1.
def binary_search(list, target):
left = 0
return mid
left = mid + 1
else:
right = mid - 1
return -1
returns the index of the target value in the list using a recursive
return -1.
def binary_search_recursive(list, target, left, right):
if left > right:
return -1
return mid
return binary_search_recursive(list, target, mid + 1, right)
else:
return binary_search_recursive(list, target, left, mid - 1)
returns the index of the target value in the list using a tail recursive
return -1.
def binary_search_tail_recursive(list, target, left, right):
if left > right:
return -1
return mid
left = mid + 1
return binary_search_tail_recursive(list, target, left, right)
else:
right = mid - 1
return binary_search_tail_recursive(list, target, left, right)
returns the index of the target value in the list using an iterative
return -1.
def binary_search_iterative(list, target):
left = 0
return mid
left = mid + 1
else:
right = mid - 1
return -1
returns the index of the target value in the list using a divide and
conquer approach. If the target value is not in the list, the function
should return -1.
def binary_search_divide_conquer(list, target):
if len(list) == 0:
return -1
mid = len(list) // 2
return mid
return binary_search_divide_conquer(list[mid+1:], target)
else:
return binary_search_divide_conquer(list[:mid], target)
GRAPH ALGORITHMS
DIJKSTRA’S ALGORITHM
Dijkstra’s algorithm is one of the most well-known algorithms in computer
science. It is an algorithm for finding the shortest path between two nodes
in a graph. It is an example of a greedy algorithm, meaning that it makes
decisions on which path to take based on the immediate rewards it will
receive. It’s named after Edsger Dijkstra, who was a Dutch computer
scientist.
Dijkstra’s algorithm is widely used in many fields such as robotics,

networking, and operations research. It is also often used in data structures
and algorithms classes to teach students about graph traversal and shortest
path finding. This article will provide an in-depth look at Dijkstra’s
algorithm in the context of the Python programming language. We will
discuss how the algorithm works, its time and space complexities, and
provide sample code that can be used to implement the algorithm.
What Is Dijkstra’s Algorithm?

Dijkstra’s algorithm is an algorithm used to find the shortest path between
two nodes in a graph. It can also be used to find the shortest path between
all nodes in a graph. The algorithm works by starting at the source node and
exploring all of its neighbors. It then visits the neighbor with the lowest cost
and continues in this fashion until it reaches the destination node.
The algorithm assigns each node a score, which is the distance from the
source node. This score is used to determine which node to visit next. If two
nodes have the same score, the algorithm will visit the one with the lowest
cost.
Time Complexity
The time complexity of Dijkstra’s algorithm is O(|V|^2), where |V| is the
number of nodes in the graph. This means that the algorithm will take
longer to run as the number of nodes increases.
In the worst case, the algorithm will visit every node in the graph, which
takes O(|V|) time. For each node, the algorithm must explore all of its
neighbors, which takes an additional O(|V|) time. Therefore, the total time
complexity is O(|V|^2).
Space Complexity
The space complexity of Dijkstra’s algorithm is O(|V|). The algorithm uses
an array to keep track of the scores for each node, which takes up O(|V|)
space.
Python Code for Dijkstra’s Algorithm

We can use the following Python code to implement Dijkstra’s algorithm:
def dijkstra(graph, source_node):

# Create an array to store the scores for each node
scores = [float('inf') for _ in range(len(graph))]
scores[source_node] = 0
# Create a set to store the visited nodes
visited = set()
# Loop until all nodes have been visited
while len(visited) != len(graph):
# Find the unvisited node with the lowest score
lowest_score = float('inf')
lowest_node = None
for node, score in enumerate(scores):
if node not in visited and score < lowest_score:
lowest_score = score
lowest_node = node
# Visit the node with the lowest score
visited.add(lowest_node)
for neighbor, cost in enumerate(graph[lowest_node]):
# Update the score for each unvisited neighbor
if neighbor not in visited:
scores[neighbor] = min(scores[neighbor], scores[lowest_node] +
cost)
return scores
Conclusion
Dijkstra’s algorithm is a powerful and efficient algorithm for finding the
shortest path between two nodes in a graph. It has a time complexity of
O(|V|^2) and a space complexity of O(|V|). It is used in many fields and is a
popular topic in data structures and algorithms classes. The code provided
in this article can be used as a starting point for implementing the algorithm
in Python.
Exercises
Create a function that takes in a graph and a source node and returns
the number of nodes visited by the algorithm.
Create a function that takes in a graph, a source node, and a
destination node and returns the shortest path from the source to the
destination.
Create a function that takes in a graph and a source node and returns a
dictionary of all the shortest paths from the source to each node.
4. Create a function that takes in a graph, a source node, and a
destination node and returns the total cost of the shortest path from the
source to the destination.
dictionary of all the shortest paths from the source to each node and
their total costs.
Solutions
Create a function that takes in a graph and a source node and returns
the number of nodes visited by the algorithm.
def num_nodes_visited(graph, source):
visited = set()
scores[source] = 0
lowest_node = None
lowest_node = node
cost)
return len(visited)
destination node and returns the shortest path from the source to the
destination.
def shortest_path(graph, source, destination):
visited = set()
scores[source] = 0
paths = [[] for _ in range(len(graph))]
paths[source].append(source)
lowest_node = None
lowest_node = node
if scores[neighbor] > scores[lowest_node] + cost:
scores[neighbor] = scores[lowest_node] + cost
paths[neighbor] = paths[lowest_node] + [neighbor]
return paths[destination]
dictionary of all the shortest paths from the source to each node.
def all_shortest_paths(graph, source):
visited = set()
scores[source] = 0
lowest_node = None
lowest_node = node
return {node: paths[node] for node in range(len(graph))}
destination node and returns the total cost of the shortest path from the
source to the destination.
def total_cost(graph, source, destination):
visited = set()
scores[source] = 0
lowest_node = None
lowest_node = node
cost)
return scores[destination]
dictionary of all the shortest paths from the source to each node and
their total costs.
def all_shortest_paths_costs(graph, source):
visited = set()
scores[source] = 0
lowest_node = None
lowest_node = node
return {node: (paths[node], scores[node]) for node in range(len(graph))}
BREADTH FIRST SEARCH
(BFS)
Breadth first search (BFS) is a fundamental algorithm used in data
structures and algorithms with Python. It is an algorithm for traversing or
searching a tree, graph, or any kind of data structure. BFS is one of the most
widely used graph algorithms and is used to find the shortest path from one
vertex to another in an unweighted graph.
BFS is useful for finding the shortest path from one node to another, or for
finding all nodes that are a given distance away from the start node. It is
also used to solve many other problems, such as finding the minimum
spanning tree, finding the maximum flow in a network, and finding the
maximum independent set in a graph.
The algorithm begins at the root node, and explores all of the neighboring
nodes at the present depth before moving on to the nodes at the next level.
It is also known as level order traversal, as each level of the tree is visited in
order.
How the Algorithm Works in Detail

Breadth first search is an algorithm for traversing or searching a graph. It
starts at the root node and explores all of the neighboring nodes at the
current level before moving on to the nodes at the next level.
The algorithm works by first exploring the root node and then exploring all
of its neighbors. Then, it moves on to explore the neighbors of the
neighbors, and so on. At each level, the algorithm visits all of the nodes at
that level before moving on to the next level.
The algorithm can be implemented using a queue. A queue is a data
structure that stores items in a first-in, first-out (FIFO) order. The algorithm
adds the root node to the queue and then continues to add all of its
neighbors to the queue. It then dequeues the first item in the queue and
explores all of its neighbors. This process is repeated until the queue is
empty, at which point all of the nodes in the graph have been explored.
Time Complexity
The time complexity of breadth first search is O(V+E), where V is the
number of vertices and E is the number of edges in the graph. This means
that the algorithm will take O(V+E) time to explore the entire graph.
The best-case time complexity of BFS is O(V), which occurs when the
graph is a single connected component, meaning all of the nodes are
connected to each other. The worst-case time complexity is O(V+E), which
occurs when the graph is composed of many connected components.
Space Complexity
The space complexity of breadth first search is O(V) in the worst-case, as
the algorithm will need to store all of the vertices in the graph in order to
explore them.
Python Code for Breadth First Search

The following Python code implements the breadth first search algorithm.
# Create a queue to store the nodes to be explored

queue = []
# Add the root node to the queue
queue.append(root)
# Loop while the queue is not empty
while queue:
# Dequeue the first node in the queue
node = queue.pop(0)
# Explore the node
# ...
# Add the node's neighbors to the queue
for neighbor in node.neighbors:
queue.append(neighbor)
Conclusion
In conclusion, breadth first search is a fundamental algorithm used in data
structures and algorithms with Python. It is an algorithm for traversing or
searching a tree, graph, or any kind of data structure. The algorithm begins
at the root node, and explores all of the neighboring nodes at the present
depth before moving on to the nodes at the next level. The time complexity
of BFS is O(V+E), where V is the number of vertices and E is the number
of edges in the graph. The space complexity of BFS is O(V) in the worst-
case, as the algorithm will need to store all of the vertices in the graph in
order to explore them.
Exercises
Implement a breadth first search algorithm in Python to search for a
target value in a binary tree.
Write a breadth first search algorithm in Python to find the shortest
path between two nodes in a graph.
Write a breadth first search algorithm in Python to find the minimum
spanning tree of a graph.
Write a breadth first search algorithm in Python to find the maximum
flow in a network.
independent set in a graph.
Solutions
Implement a breadth first search algorithm in Python to search for a
target value in a binary tree.
def bfs(root, target):
queue = []
queue.append(root)
while queue:
node = queue.pop(0)
if node.val == target:
return node
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return None
Write a breadth first search algorithm in Python to find the shortest
path between two nodes in a graph.
def bfs(start, end):
queue = []
visited = set()
path = []
queue.append((start, [start]))
while queue:
node, path = queue.pop(0)
visited.add(node)
if node == end:
return path
queue.append((neighbor, path + [neighbor]))
return None
Write a breadth first search algorithm in Python to find the minimum
spanning tree of a graph.
def bfs(graph):
queue = []
visited = set()
tree = []
queue.append((graph.root, []))
while queue:
visited.add(node)
queue.append((neighbor, path + [(node, neighbor)]))
for (u, v) in path:
if (v, u) not in path:
tree.append((u, v))
return tree
flow in a network.
def bfs(graph, source, sink):
queue = []
visited = set()
max_flow = 0
queue.append((source, 0))
while queue:
node, flow = queue.pop(0)
visited.add(node)
if node == sink:
max_flow = max(max_flow, flow)
if neighbor not in visited and graph.capacity[node][neighbor] > 0:
queue.append((neighbor, min(flow, graph.capacity[node]
[neighbor])))
return max_flow
independent set in a graph.
def bfs(graph):
queue = []
visited = set()
max_set = []
queue.append(graph.root)
while queue:
node = queue.pop(0)
visited.add(node)
is_independent = True
is_independent = False
if is_independent:
max_set.append(node)
return max_set
DEPTH FIRST SEARCH
(DFS)
Depth First Search (DFS) is a type of graph traversal algorithm used to
search a graph data structure. This article will cover the basics of DFS and
how it works, its time and space complexities, and Python code examples of
the algorithm. Additionally, this article will provide coding exercises with
solutions to test the reader’s understanding of DFS.
What is Depth First Search?

Depth First Search (DFS) is a type of graph traversal algorithm used to
search a graph data structure. It is a recursive algorithm that begins at the
root node and explores as far as possible along each branch before
backtracking. DFS is used to explore a graph data structure to find a
particular node or the path between two nodes.
How Does Depth First Search Work?

Depth First Search begins by selecting a starting node, or the root node, of
the graph. It then explores as far as possible along each branch before
backtracking. This means that the algorithm will explore all of the nodes
connected to the root node before exploring nodes connected to the nodes
connected to the root node. This process is repeated until the algorithm
finds the node it is searching for or all of the nodes in the graph have been
explored.
To illustrate, imagine a graph that has four nodes, A, B, C, and D. A is the

root node and the algorithm is searching for node D. The algorithm will
begin at node A and explore all of the nodes connected to node A, which in
this case is nodes B and C. It will then explore all of the nodes connected to
node B and C, which in this case is node D. The algorithm will then
backtrack to node C and explore all of the nodes connected to node C,
which in this case is node D. Once the algorithm finds node D, it will stop
and the search will be complete.
Time Complexity
Depth First Search has a time complexity of O(V + E), where V is the
number of nodes in the graph and E is the number of edges in the graph.
This time complexity is the same for both the best and worst case
scenarios.
Space Complexity
Depth First Search has a space complexity of O(V). This means that the
algorithm will take up a maximum of O(V) space in memory in the worst
case scenario.
Python Code
Now that we understand the basics of DFS, we can look at some Python
code that implements the algorithm. The following code is a simple
implementation of the Depth First Search algorithm.
def dfs(graph, start):

visited = set()
stack = [start]
while stack:
vertex = stack.pop()
if vertex not in visited:
visited.add(vertex)
stack.extend(graph[vertex] - visited)
return visited
# example graph
graph = {
'A': set(['B', 'C']),
'B': set(['A', 'D', 'E']),
'C': set(['A', 'F']),
'D': set(['B']),
'E': set(['B', 'F']),
'F': set(['C', 'E'])
}
dfs(graph, 'A') # {'E', 'D', 'F', 'A', 'C', 'B'}
Conclusion
In conclusion, Depth First Search (DFS) is a type of graph traversal
algorithm used to search a graph data structure. It is a recursive algorithm
that begins at the root node and explores as far as possible along each
branch before backtracking. DFS has a time complexity of O(V + E), where
V is the number of nodes in the graph and E is the number of edges in the
graph. It also has a space complexity of O(V).
Exercises
Given the following graph, use Depth First Search to find the path
between nodes B and F. graph = { ‘A’: set([‘B’, ‘C’]), ‘B’: set([‘A’, ‘D’,
‘E’]), ‘C’: set([‘A’, ‘F’]), ‘D’: set([‘B’]), ‘E’: set([‘B’, ‘F’]), ‘F’: set([‘C’,
‘E’]) }
Write a function that uses Depth First Search to search a graph for a
given node.
Given the following graph, use Depth First Search to find all the nodes
reachable from node A. graph = { ‘A’: set([‘B’, ‘C’]), ‘B’: set([‘A’, ‘D’,
‘E’]) }
Write a function that uses Depth First Search to find the shortest path
between two nodes in a graph.
that are not connected to node A. graph = { ‘A’: set([‘B’, ‘C’]), ‘B’:
set([‘A’, ‘D’, ‘E’]), ‘C’: set([‘A’, ‘F’]), ‘D’: set([‘B’]), ‘E’: set([‘B’, ‘F’]),
‘F’: set([‘C’, ‘E’]) }
Solutions
Given the following graph, use Depth First Search to find the path
between nodes B and F. graph = { ‘A’: set([‘B’, ‘C’]), ‘B’: set([‘A’, ‘D’,
‘E’]) }
Path: B -> D -> B -> E -> F
Write a function that uses Depth First Search to search a graph for a
given node.
def dfs_search(graph, start, search_val):
visited = set()
stack = [start]
while stack:
vertex = stack.pop()
if vertex == search_val:
return True
visited.add(vertex)
stack.extend(graph[vertex] - visited)
return False
reachable from node A. graph = { ‘A’: set([‘B’, ‘C’]), ‘B’: set([‘A’, ‘D’,
‘E’]) }
Nodes reachable from node A: B, C, D, E, F
Write a function that uses Depth First Search to find the shortest path
between two nodes in a graph.
def dfs_shortest_path(graph, start, end):
visited = set()
stack = [(start, [start])]
while stack:
(vertex, path) = stack.pop()
if vertex == end:
return path
visited.add(vertex)
for node in graph[vertex] - visited:
stack.append((node, path + [node]))
return None
that are not connected to node A. graph = { ‘A’: set([‘B’, ‘C’]), ‘B’:
set([‘A’, ‘D’, ‘E’]), ‘C’: set([‘A’, ‘F’]), ‘D’: set([‘B’]), ‘E’: set([‘B’, ‘F’]),
‘F’: set([‘C’, ‘E’]) }
Nodes not connected to node A: None
ALGORITHM DESIGN
TECHNIQUES
GREEDY ALGORITHMS
When it comes to problem solving, there is no one size fits all approach.
Different algorithms and techniques are necessary to solve different types of
problems. This is especially true when it comes to computer programming.
One of the most popular and effective algorithms is the greedy algorithm.
In this article, we will take a look at what makes the greedy algorithm so
effective and how it can be applied to data structures and algorithms with
Python. We’ll also look at some of the common pitfalls of using the greedy
algorithm and how to avoid them.
What Is a Greedy Algorithm?

A greedy algorithm is an algorithm that uses a greedy approach to problem
solving. That is, it tries to make the most “optimal” choice at each step in
order to solve the problem. It does not consider the future consequences of
its decisions.
The greedy algorithm works by making the most “optimal” choice at each
step. It does not look ahead to consider the consequences of its decisions.
Instead, it focuses on the immediate situation and tries to make the best
decision it can in the current context.
For example, if you are trying to find the shortest path between two points,
the greedy algorithm will choose the route with the fewest steps. It won’t
consider the overall time it takes to get from point A to point B, or the cost
of the journey. It only focuses on the immediate decision at hand.
Advantages of Greedy Algorithms

The greedy algorithm has many advantages which make it a popular choice
for data structures and algorithms with Python.
One of the biggest advantages of the greedy algorithm is its speed. The
algorithm is able to quickly find the optimal solution without having to
consider the future consequences of its decisions. This makes it an ideal
choice for problems that need to be solved quickly.
Another advantage of the greedy algorithm is its simplicity. The algorithm

does not require complex calculations and can usually be implemented in a
few lines of code. This makes it easy to understand and implement.
Finally, the greedy algorithm is often able to find the optimal solution for a
given problem. This means that it is often able to find the best possible
solution without having to consider the future consequences of its decisions.
Disadvantages of Greedy Algorithms

Despite its many advantages, the greedy algorithm also has some
drawbacks. One of the main disadvantages is that it may not always find the
most optimal solution. This is because the algorithm only considers the
immediate situation and does not consider the future consequences of its
decisions.
For example, if you are trying to find the shortest path between two points,
the greedy algorithm may not necessarily find the shortest path. It may find
a shorter path than the optimal one, but it may not be the shortest path
overall.
Another disadvantage of the greedy algorithm is that it can be difficult to

debug. This is because the algorithm is based on making decisions without
considering the future consequences. This can make it difficult to identify
and fix any bugs that may arise.
Applying Greedy Algorithms with Python

Now that we have seen the advantages and disadvantages of the greedy
algorithm, let’s take a look at how it can be applied to data structures and
algorithms with Python.
One of the most common applications of the greedy algorithm is in the field
of graph theory. The algorithm can be used to find the shortest path between
two points on a graph, or to find the minimum spanning tree of a graph.
The following code shows how the greedy algorithm can be used to find the
shortest path between two points on a graph:
ef shortest_path(graph, start, end):

visited = set()
queue = [(start, [start])]
while queue:
if node == end:
return path
if node not in visited:
visited.add(node)
for neighbor in graph[node]:
graph = {'A': ['B', 'C', 'E'],
'B': ['A','D', 'E'],
'C': ['A', 'F', 'G'],
'D': ['B'],
'E': ['A', 'B','D'],
'F': ['C'],
'G': ['C']}
print(shortest_path(graph, 'A', 'D'))
# Output: ['A', 'B', 'D']
Conclusion
In conclusion, the greedy algorithm is a powerful and popular algorithm
that is used in data structures and algorithms with Python. It is fast and
simple to implement, and often finds the optimal solution for a given
problem. However, it can be prone to producing suboptimal solutions, and it
can be difficult to debug.
Exercises
Write a function that takes a graph and a starting point as inputs, and
then uses the greedy algorithm to find the shortest path from the
starting point to every other point in the graph.
then uses the greedy algorithm to find the minimum spanning tree of
the graph.
Write a function that takes a graph and two points as inputs, and then
uses the greedy algorithm to find the shortest path between the two
points.
uses the greedy algorithm to find the minimum cost path between the
two points.
then uses the greedy algorithm to find the maximum spanning tree of
the graph.
Solutions
then uses the greedy algorithm to find the shortest path from the
starting point to every other point in the graph.
def shortest_paths(graph, start):
visited = set()
paths = {start: [start]}
queue = [start]
while queue:
node = queue.pop(0)
visited.add(node)
if neighbor not in paths:
paths[neighbor] = paths[node] + [neighbor]
return paths
then uses the greedy algorithm to find the minimum spanning tree of
the graph.
def minimum_spanning_tree(graph, start):
visited = set()
tree = []
queue = [start]
while queue:
node = queue.pop(0)
visited.add(node)
tree.append((node, neighbor))
return tree
uses the greedy algorithm to find the shortest path between the two
points.
def shortest_path(graph, start, end):
visited = set()
queue = [(start, [start])]
while queue:
if node == end:
return path
visited.add(node)
uses the greedy algorithm to find the minimum cost path between the
two points.
def minimum_cost_path(graph, start, end):
visited = set()
queue = [(start, 0, [start])]
while queue:
node, cost, path = queue.pop(0)
if node == end:
return cost, path
visited.add(node)
new_cost = cost + graph[node][neighbor]
queue.append((neighbor, new_cost, path + [neighbor]))
then uses the greedy algorithm to find the maximum spanning tree of
the graph.
def maximum_spanning_tree(graph, start):
visited = set()
tree = []
queue = [(start, 0)]
while queue:
node, cost = queue.pop(0)
visited.add(node)
tree.append((node, neighbor, graph[node][neighbor]))
queue.append((neighbor, graph[node][neighbor]))
return tree
DYNAMIC
PROGRAMMING
Dynamic programming is an algorithmic technique used to solve complex
problems by breaking them down into smaller, simpler subproblems. It is a
powerful technique used in many areas of computer science, including data
structures and algorithms. In this article, we will explore the fundamentals
of dynamic programming, the different types of dynamic programming, and
how to apply dynamic programming to solve problems with Python. By the
end of this article, you should have a solid understanding of dynamic
programming and its applications.
What is Dynamic Programming?

Dynamic programming is a technique used to solve complex problems by
breaking them down into smaller, simpler subproblems. It is a branch of
algorithmic techniques used to solve optimization problems. It is widely
used to solve problems such as knapsack problem, shortest path problem,
and other optimization problems.
Dynamic programming works by breaking down a problem into a series of

subproblems. Each subproblem is solved and the solutions to the
subproblems are used to solve the original problem. This technique is used
to solve problems that cannot be solved using traditional methods.
Dynamic programming algorithms are usually divided into two types: top-
down and bottom-up. The top-down approach starts from the original
problem and breaks it down into smaller subproblems. The bottom-up
approach starts from the smallest subproblems and builds up to the original
problem.
Example of Dynamic Programming

Let’s look at an example of dynamic programming to better understand how
it works. Consider the classic Fibonacci sequence problem. The Fibonacci
sequence is a series of numbers where each number is the sum of the two
preceding numbers.
The Fibonacci sequence starts with 0 and 1 and continues as follows: 0, 1,

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …
To solve this problem using dynamic programming, we first need to break it

down into smaller subproblems. In the Fibonacci sequence problem, the
subproblem is to find the nth number in the sequence. We can then solve
each subproblem using the following recursive formula:
F(n) = F(n-1) + F(n-2)
Where F(n) is the nth number in the Fibonacci sequence.
We can then use this formula to solve the original problem. To find the 8th
number in the Fibonacci sequence, we can use the following code in
Python:
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(8))
The output of this code is 13, which is the 8th number in the Fibonacci
sequence. This is an example of how dynamic programming can be used to
solve complex problems.
Advantages of Dynamic Programming

Dynamic programming has several advantages over traditional methods. It
is a powerful technique used to solve complex problems. Here are some of
the advantages of dynamic programming:
It is an efficient method of solving problems. Dynamic
programming algorithms are usually much more efficient than
traditional algorithms. This is because they are able to break
down a complex problem into smaller subproblems and solve
each subproblem individually.
It is a versatile technique. Dynamic programming can be used to
solve a wide range of optimization problems.
It is a simple technique. Dynamic programming algorithms are
usually simple and easy to understand.
Types of Dynamic Programming

Dynamic programming algorithms can be divided into two types: top-down
and bottom-up.
The bottom-up approach starts from the smallest subproblems and builds up
to the original problem. This approach is usually used when the
subproblems are independent of each other and can be solved in any order.
Using Dynamic Programming with Python

Now that we have a basic understanding of dynamic programming, let’s
look at how we can use it with Python. Python is a popular language for
implementing dynamic programming algorithms.
We can use the top-down and bottom-up approaches with Python. The top-
down approach can be implemented using recursive functions. The bottom-
up approach can be implemented using a loop.
Let’s look at an example of how we can use dynamic programming with

Python to solve the Fibonacci sequence problem. We can use the following
code to solve the problem using the top-down approach (same as the
example before):
def fibonacci(n):
if n <= 1:
return n
print(fibonacci(8))
The output of this code is 13, which is the 8th number in the Fibonacci
sequence.
We can also use the bottom-up approach to solve the problem. We can use
the following code to solve the problem with the bottom-up approach:
def fibonacci(n):
fib = [0, 1]
for i in range(2, n + 1):
fib.append(fib[i - 1] + fib[i - 2])
return fib[n]
print(fibonacci(8))
The output of this code is also 13, which is the 8th number in the Fibonacci
sequence.
Conclusion
Dynamic programming is an algorithmic technique used to solve complex
problems by breaking them down into smaller, simpler subproblems. It is a
powerful technique used in many areas of computer science, including data
structures and algorithms. In this article, we explored the fundamentals of
dynamic programming, the different types of dynamic programming, and
how to apply dynamic programming to solve problems with Python.
Exercises
Write a program to calculate the nth number in the Fibonacci sequence
using dynamic programming.
Write a program to calculate the minimum number of coins needed to
make a given amount using dynamic programming.
Write a program to calculate the maximum sum of a subarray using
dynamic programming.
Write a program to calculate the longest common subsequence of two
strings using dynamic programming.
Write a program to calculate the Knapsack problem using dynamic
programming.
Solutions
Write a program to calculate the nth number in the Fibonacci sequence
using dynamic programming.
def fibonacci(n):
if n <= 1:
return n
print(fibonacci(n))
Write a program to calculate the minimum number of coins needed to
make a given amount using dynamic programming.
def min_coins(amount):
coins = [1, 5, 10, 25]
dp = [0] + [float("inf")] * amount
for i in range(1, amount+1):
dp[i] = min([dp[i-c] for c in coins if i-c >= 0]) + 1
return dp[amount]
print(min_coins(amount))
Write a program to calculate the maximum sum of a subarray using
dynamic programming.
def max_sum_subarray(arr):
dp = [arr[0]]
dp.append(max(arr[i], arr[i] + dp[i-1]))
return max(dp)
print(max_sum_subarray(arr))
Write a program to calculate the longest common subsequence of two
strings using dynamic programming.
def lcs(x, y):
m = len(x)
n = len(y)
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if x[i-1] == y[j-1]:
dp[i][j] = 1 + dp[i-1][j-1]
else:
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
return dp[m][n]
print(lcs(x, y))
Write a program to calculate the Knapsack problem using dynamic
programming.
def knapsack(items, capacity):
n = len(items)
dp = [[0] * (capacity + 1) for _ in range(n + 1)]
for i in range(1, n+1):
for j in range(1, capacity+1):
if items[i-1][1] > j:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j], items[i-1][0] + dp[i-1][j-items[i-1][1]])
return dp[n][capacity]
print(knapsack(items, capacity))
DIVIDE AND CONQUER
Divide and conquer is a powerful algorithm design technique that can be
used to solve many types of problems in computer science. It is a strategy
that involves breaking down a problem into smaller, manageable parts, then
solving each part individually. This approach can be used to solve complex
problems quickly and efficiently.
Divide and Conquer is a fundamental problem-solving technique that is

widely used in data structures and algorithms with Python. In this article,
we will explore the basics of divide-and-conquer algorithms and how to
implement them in Python. We will also go over a few examples to
illustrate the power of this technique.
What is Divide and Conquer?

Divide and conquer is a problem-solving technique that involves breaking
down a problem into smaller, more manageable pieces. Each of these pieces
can then be solved separately, and the results can be combined to form the
final solution. This approach helps to simplify complex problems, making
them easier to solve.
Divide and conquer algorithms have been used for centuries to solve
various problems. They are particularly useful for solving problems that
involve searching or sorting large data sets. This technique can be used to
reduce the running time of an algorithm, as well as improve its memory
usage.
How Does Divide and Conquer Work?

Divide and conquer algorithms typically follow a three-step process. First,
the problem is divided into smaller, more manageable parts. Then, each part
is solved individually. Finally, the results of each part are combined to form
the final solution.
The key to using divide and conquer is to ensure that the subproblems are
small enough to be solved quickly, but large enough to be meaningful. If the
subproblems are too small, then the overall algorithm may not be efficient.
On the other hand, if the subproblems are too large, then the algorithm may
take too long to complete.
Divide and Conquer Algorithms in Python

Now that we have an understanding of what divide and conquer is, let’s
look at how we can implement it in Python. We will use a classic example
of divide and conquer, the Quicksort algorithm.
Quicksort is a sorting algorithm that uses the divide and conquer technique
to sort a list of numbers. It works by partitioning the list into two parts, then
recursively sorting each part.
Let’s take a look at the code for Quicksort in Python:
def quicksort(arr):
if len(arr) <= 1:
return arr
else:
This code takes an array of integers and partitions it into three parts: the left
side, the middle (the pivot element), and the right side. It then recursively
sorts each part using the same algorithm.
In this case, the pivot is the middle element of the array. The left and right
sides are then sorted using the same algorithm. This process continues until
the list is completely sorted.
Benefits of Divide and Conquer
Divide and conquer algorithms are popular because they offer many
benefits. They can be used to solve a variety of problems, and they can
significantly reduce the running time of an algorithm. They also help to
reduce memory usage, as the subproblems do not need to be stored in
memory.
Divide and conquer algorithms are also relatively easy to implement in

Python. As we have seen with the Quicksort example, the code can be
written quickly and efficiently.
Conclusion
Divide and conquer is a powerful algorithm design technique that can be
used to solve many types of problems in computer science. It is a strategy
that involves breaking down a problem into smaller, manageable parts, then
solving each part individually. This approach can be used to solve complex
problems quickly and efficiently.
Exercises
Using the divide and conquer technique, write a Python function to
find the maximum element in an array.
find the second largest element in an array.
find the kth largest element in an array.
find the median element in an array.
find the closest pair of elements in an array.
Solutions
find the maximum element in an array.
def max_element(arr):
if len(arr) == 1:
return arr[0]
else:
mid = len(arr) // 2
left_max = max_element(arr[:mid])
right_max = max_element(arr[mid:])
return max(left_max, right_max)
find the second largest element in an array.
def second_largest(arr):
if len(arr) == 2:
return max(arr[0], arr[1])
else:
mid = len(arr) // 2
left_second_largest = second_largest(arr[:mid])
right_second_largest = second_largest(arr[mid:])
return max(left_second_largest, right_second_largest)
find the kth largest element in an array.
def kth_largest(arr, k):
if len(arr) == k:
return arr[-1]
else:
mid = len(arr) // 2
left_kth_largest = kth_largest(arr[:mid], k)
right_kth_largest = kth_largest(arr[mid:], k)
if left_kth_largest == right_kth_largest:
return left_kth_largest
else:
return max(left_kth_largest, right_kth_largest)
find the median element in an array.
def median_element(arr):
if len(arr) == 1:
return arr[0]
else:
mid = len(arr) // 2
left_median = median_element(arr[:mid])
right_median = median_element(arr[mid:])
return (left_median + right_median) / 2
find the closest pair of elements in an array.
def closest_pair(arr):
if len(arr) == 2:
return arr[0], arr[1]
else:
mid = len(arr) // 2
left_closest = closest_pair(arr[:mid])
right_closest = closest_pair(arr[mid:])
if abs(left_closest[0] - left_closest[1]) < abs(right_closest[0] -
right_closest[1]):
return left_closest
else:
return right_closest
BACKTRACKING
Backtracking is a powerful technique used to solve certain types of
problems. It is a type of recursion and can be used to solve complex
problems by exploring different paths from a given starting point. In this
article, we will discuss the basics of backtracking and how it can be used to
solve data structures and algorithms problems with Python.
What is Backtracking?
Backtracking is a type of algorithm that is used to find all solutions to a
given problem. It involves searching through all possible solutions and then
discarding those that do not meet the given criteria. It is a form of trial and
error, and is often used when an exact solution is not known. Backtracking
algorithms can be used to find solutions to problems such as the traveling
salesman problem, the knapsack problem, and the 8-queens problem.
Backtracking algorithms start by exploring a possible solution and then

backtracking or undoing the steps if the solution does not lead to a
satisfactory outcome. This process is repeated until a solution is found or all
possible solutions have been explored. The backtracking algorithm can be
thought of as a tree with multiple branches that are explored.
Python Code for Backtracking

Backtracking can be implemented in Python using the following code:
def backtrack(solution, partial):

if is_solution(partial):
solution.append(partial)
else:
for c in generate_candidates(partial):
partial.append(c)
backtrack(solution, partial)
partial.pop()
The code begins by defining a function “backtrack” that takes two
parameters: “solution” and “partial”. The “solution” parameter will contain
the list of all solutions that are found by the algorithm. The “partial”
parameter will contain a partial solution.
The code then checks if the partial solution is a valid solution. If it is, then
the partial solution is added to the list of solutions. If not, the code
generates possible candidates for the partial solution and adds them to the
list. The code then recursively calls itself with the new partial solution. This
process is repeated until all possible solutions have been explored.
Applications of Backtracking
Backtracking algorithms can be used to solve a variety of problems. One of
the most common applications of backtracking is in the field of
combinatorial optimization. It can be used to solve problems such as the
traveling salesman problem, the knapsack problem, and the 8-queens
problem.
Backtracking is also used in constraint satisfaction problems. These are

problems where a set of variables must be assigned values such that certain
constraints are satisfied. Examples of constraint satisfaction problems
include Sudoku, scheduling, and map coloring problems.
Backtracking can also be used for graph problems. It can be used to find a
Hamiltonian cycle in a graph, which is a path that visits each vertex exactly
once. It can also be used to find a minimum spanning tree, which is a tree
that connects all the vertices in a graph with the minimum possible total
weight.
Backtracking can also be used to solve problems related to game theory,

such as finding a Nash equilibrium in a two-player game. It can also be
used for pattern matching, such as finding a substring in a string.
Conclusion
Backtracking is a powerful technique used to solve certain types of
problems. It is a type of recursion and can be used to solve complex
problems by exploring different paths from a given starting point. It is used
to solve problems such as the traveling salesman problem, the knapsack
problem, and the 8-queens problem. It can also be used for graph problems,
constraint satisfaction problems, game theory, and pattern matching.
Exercises
Write a program to solve the 8-queens problem using backtracking.
Write a program to solve the knapsack problem using backtracking.
Write a program to solve the traveling salesman problem using
backtracking.
Write a program to solve a Sudoku puzzle using backtracking.
Write a program to find a Hamiltonian cycle in a graph using
backtracking.
Solutions
Write a program to solve the 8-queens problem using backtracking.
def is_valid_position(board, row, col):
# Check if there is a queen in the same column
for i in range(row):
if board[i][col] == 1:
return False
# Check diagonal
i, j = row - 1, col - 1
while i >= 0 and j >= 0:
if board[i][j] == 1:
return False
i -= 1
j -= 1
i, j = row - 1, col + 1
while i >= 0 and j < len(board):
if board[i][j] == 1:
return False
i -= 1
j += 1
return True
def solve_queens(board, row):
# Base case
if row == len(board):
return True
# Try all columns for current row
for col in range(len(board)):
if is_valid_position(board, row, col):
board[row][col] = 1
if solve_queens(board, row+1):
return True
board[row][col] = 0
return False
Write a program to solve the knapsack problem using backtracking.
def knapsack(items, max_weight):
knapsack_items = []
knapsack_value = 0
def backtrack(i, weight, value):
nonlocal knapsack_items, knapsack_value
if i == len(items) or weight == max_weight:
if value > knapsack_value:
knapsack_items = knapsack_items[:i]
knapsack_value = value
return
# Don't take the item
backtrack(i + 1, weight, value)
# Take the item if there is room
if weight + items[i][1] <= max_weight:
knapsack_items.append(items[i])
backtrack(i + 1, weight + items[i][1], value + items[i][0])
knapsack_items.pop()
backtrack(0, 0, 0)
return knapsack_items, knapsack_value
Write a program to solve the traveling salesman problem using
backtracking.
def tsp(graph):
# Set up initial state
n = len(graph)
visited = [False] * n
visited[0] = True
current_path = [0]
best_path = None
best_cost = float('inf')
def backtrack(i, visited, current_path, current_cost):
nonlocal best_path, best_cost
# Base case, all cities visited
if all(visited):
if current_cost < best_cost:
best_cost = current_cost
best_path = current_path[:]
return
# Try all cities that have not yet been visited
for j in range(n):
if not visited[j]:
visited[j] = True
current_path.append(j)
backtrack(j, visited, current_path, current_cost + graph[i][j])
visited[j] = False
current_path.pop()
backtrack(0, visited, current_path, 0)
return best_path, best_cost
Write a program to solve a Sudoku puzzle using backtracking.
def solve_sudoku(board):
def is_valid_position(board, row, col):
# Check if there is a duplicate in the same row
for i in range(9):
if board[row][i] == board[row][col] and i != col:
return False
# Check if there is a duplicate in the same column
for i in range(9):
if board[i][col] == board[row][col] and i != row:
return False
# Check 3x3 grid
row_start = (row // 3) * 3
col_start = (col // 3) * 3
for i in range(row_start, row_start + 3):
for j in range(col_start, col_start + 3):
if board[i][j] == board[row][col] and (i,j) != (row,col):
return False
return True
def backtrack(board, row, col):
if row == 9:
return True
# Next cell
if col == 8:
return backtrack(board, row + 1, 0)
else:
return backtrack(board, row, col + 1)
# Check if cell is empty
if board[row][col] == 0:
# Try all numbers
for num in range(1, 10):
board[row][col] = num
if is_valid_position(board, row, col):
if backtrack(board, row, col):
return True
# Reset on backtrack
board[row][col] = 0
return False
backtrack(board, 0, 0)
Write a program to find a Hamiltonian cycle in a graph using
backtracking.
def hamiltonian_cycle(graph):
# Set up initial state
n = len(graph)
visited = [False] * n
current_path = [0]
best_path = None
def backtrack(i):
nonlocal best_path
if i == n:
if graph[current_path[-1]][0]:
best_path = current_path[:]
return
# Try all vertices that have not yet been visited
for j in range(n):
if not visited[j] and graph[current_path[-1]][j]:
visited[j] = True
current_path.append(j)
backtrack(i + 1)
visited[j] = False
current_path.pop()
backtrack(1)
return best_path
RANDOMIZED
ALGORITHMS
Randomized algorithms are a type of algorithm that use randomly generated
data to solve a problem. They are used in various fields such as computer
science, mathematics, and engineering. Randomized algorithms are often
used to solve difficult problems because they can find solutions quickly and
with greater accuracy than other types of algorithms.
In this article, we will explore the concept of randomized algorithms and

how they are used in the Python programming language. We will also look
at some examples of randomized algorithms and discuss the advantages and
disadvantages of using them.
What is a Randomized Algorithm?

A randomized algorithm is a type of algorithm that uses random data to
solve a problem. This random data can come from a variety of sources such
as random number generators, or from randomly generated data sets. The
random data is then used to find solutions to the problem.
Randomized algorithms are used to solve complex problems that are

difficult to solve with traditional algorithms. They can often find solutions
faster, and with greater accuracy than other types of algorithms.
How do Randomized Algorithms Work?

Randomized algorithms work by randomly generating data and then using
this data to find solutions to the problem. The data is generated randomly,
meaning that the algorithm does not know what the solution will be before
it is generated. This is different from traditional algorithms, which are
designed to solve a specific problem.
The data is then used to find a solution to the problem. The algorithm will
generate a set of solutions, and then choose the best one. The algorithm will
then repeat this process until it has found a solution that is close to optimal.
Advantages of Using Randomized Algorithms

Randomized algorithms have several advantages over traditional
algorithms. They can often find solutions faster and with greater accuracy
than other types of algorithms. Randomized algorithms can also be used to
solve problems that are too difficult for traditional algorithms to solve.
Randomized algorithms are also useful for solving problems in which the
data is uncertain. For example, if the data is incomplete or noisy, then a
randomized algorithm can be used to find a solution that is close to optimal.
Disadvantages of Using Randomized Algorithms

Randomized algorithms also have some disadvantages. They can be
difficult to debug, as it can be difficult to determine why the algorithm
failed to find a solution. Randomized algorithms also require more
computing power than traditional algorithms, as they must generate and
analyze a large amount of data.
Finally, randomized algorithms can be expensive, as they require a large

amount of computing resources.
Examples of Randomized Algorithms

Randomized algorithms are used in many different fields. Here are some
examples of randomized algorithms:
Monte Carlo Algorithm – This algorithm is used in many areas, such as

finance and engineering. It is a simulation-based algorithm that uses
random data to solve problems.
Simulated Annealing Algorithm – This is an optimization algorithm that is

used in many areas, such as engineering and computer science. It is a
probabilistic technique that uses random data to find an optimal solution to
a problem.
Randomized Quicksort Algorithm – This is a sorting algorithm that uses
random data to sort a list of numbers.
Randomized Greedy Algorithm – This is an algorithm that is used in many

optimization problems. It is a greedy algorithm that uses random data to
find an optimal solution to a problem.
Randomized Search Algorithm – This is a search algorithm that uses

random data to find a solution to a problem.
Python Code for Randomized Algorithms

The following is a Python code example for a Monte Carlo Algorithm. This
algorithm is used to simulate a system and find an optimal solution.
# Import the random library

import random
# Define the number of iterations
num_iterations = 100
# Set up the list of possible solutions
solutions = [1,2,3,4,5]
# Initialize the best solution and its value
best_solution = None
best_value = 0
# Iterate through the algorithm
for i in range(num_iterations):
# Generate a random solution
solution = random.choice(solutions)
# Calculate the value of the solution
value = calculate_value(solution)
# Update the best solution and its value
if value > best_value:
best_solution = solution
best_value = value
# Print the best solution
print(best_solution)
Conclusion
Randomized algorithms are a powerful tool for solving complex problems.
They can be used to find solutions quickly and with greater accuracy than
traditional algorithms. They are also useful for solving problems in which
the data is uncertain. Finally, randomized algorithms can be expensive, as
they require a large amount of computing power.
Exercises
Write a Python program to generate a random permutation of the
numbers from 1 to 10.
Write a Python program to generate a random string of length 10.
Write a Python program to generate a random array of size 10.
Write a Python program to generate a random graph of size 10.
Write a Python program to generate a random color.
Solutions
Write a Python program to generate a random permutation of the
numbers from 1 to 10.
import random
# Generate a list of numbers from 1 to 10
nums = [i for i in range(1, 11)]
# Shuffle the list of numbers
random.shuffle(nums)
# Print the result
print(nums)
Write a Python program to generate a random string of length 10.
import random
import string
# Generate a random string of length 10
random_string = ''.join(random.choices(string.ascii_letters + string.digits,
k=10))
# Print the result
print(random_string)
Write a Python program to generate a random array of size 10.
import random
# Generate a random array of size 10
random_array = [random.random() for i in range(10)]
# Print the result
print(random_array)
Write a Python program to generate a random graph of size 10.
import networkx as nx
import random
# Generate a random graph of size 10
G = nx.gnp_random_graph(10, 0.5)
# Print the result
print(G.edges())
Write a Python program to generate a random color.
import random
# Generate a random color
random_color = '#' + ''.join([random.choice('0123456789ABCDEF') for j in
range(6)])
# Print the result
print(random_color)
CONCLUSION
RECAP
In conclusion, this course on “Data Structures and Algorithms with Python”
has provided you with a comprehensive introduction to the fundamental
concepts of data structures and algorithms. You’ve learned about a wide
range of data structures, including arrays, stacks, queues, linked lists, skip
lists, hash tables, binary search trees, Cartesian trees, B-trees, red-black
trees, splay trees, AVL trees, and KD trees. You’ve also learned about a
variety of sorting and searching algorithms, as well as algorithm design
techniques such as greedy algorithms, dynamic programming, divide and
conquer, backtracking, and randomized algorithms.
You’ve also learned about Time and Space Complexity analysis, which will
help you understand the trade-offs between different data structures and
algorithms. You’ve had the opportunity to practice and apply the concepts
you’ve learned through hands-on exercises and examples.
By completing this course, you’ve acquired the knowledge and skills you
need to become proficient in data structures and algorithms. With this
knowledge, you’ll be able to choose the right data structure or algorithm for
a given problem, and implement it efficiently and effectively in Python.
This will help you to improve your skills as a developer and to prepare for a
career in computer science or data science.
Thank you for taking this course, and I hope you’ve found it informative
and helpful. I encourage you to continue to explore and practice data
structures and algorithms, and to keep learning new skills as you continue
to grow as a programmer.
THANK YOU
Thank you again for choosing "Data Structures and Algorithms with
Python". I hope it helps you in your journey to learn DSA with Python and
achieve your goals. Please take a small portion of your time and share this
with your friends and family and write a review for this book. I hope your
programming journey does not end here. If you are interested, check out
other books that I have or find more coding challenges at:
https://codeofcode.org

Data Structures and Algorithms With Python 100 Coding Q A Code of Code by Cakal Yasin 1

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Data Structures and Algorithms With Python 100 Coding Q A Code of Code by Cakal Yasin 1

Uploaded by

Copyright:

Available Formats

D ATA S T R U C T U R E S

All rights reserved

What are Data Structures and Algorithms?

Algorithms are the instructions used to process data in a given data

Python is a great language for data structure and algorithm development. It

Types of Data Structures

Search algorithms are used to search for a specific element in a data

What is a linked list?

What are graph algorithms used for?

Importance of Data Structures and Algorithms in

Finally, data structures and algorithms are important for software

Data Structures and Algorithms in Python

What are some examples of data structures?

What is the purpose of algorithms?

Name two sorting algorithms that are available in Python.

What is the purpose of using a graph algorithm?

What is a Data Structure and an Algorithm?

An algorithm is a set of steps used to solve a problem or achieve a goal. It is

The Different Types of Data Structures and

How to Choose the Right Data Structure or

2. Size of Data Set

5. Time and Space Constraints

What are the different types of data structures and algorithms?

What is the time complexity of a linear search?

What is the time complexity of a binary search?

What are Variables and Data Types?

In order to understand variables and data types in Python, it is necessary to

In Python, variables are used to store information in memory. Variables are

How do Variables and Data Types Work in

When a variable is declared in Python, it is given a name. This name is used

Using Variables and Data Types in Python

In the following example, we will declare a variable called “name” and

name = "John" # Declare variable and assign value

What are Control Flow Statements?

If statements: used to evaluate a condition and execute code

for number in range(10):

Break and Continue Statements

for number in range(10):

for number in range(10):

Functions are an essential part of Python programming and provide a

def sum(a, b):

Another advantage of using functions is that they can be tested and

Finally, functions make it easy to reuse code. Once a function is written, it

def sum(a, b):

def multiply(a, b):

def sum(a, b):

def sum(a, b):

def sum(a, b=0):

What is Input and Output?

name = input("Please enter your name: ")

File handling allows you to perform a variety of operations on files, such as

File Handling in Python

Creating Files in Python

file = open('test.txt', 'w')

Writing Files in Python

file = open('test.txt', 'w')

file = open('test.txt', 'w')

file = open('test.txt', 'r')

Creating and Initializing Arrays

Accessing Elements of Arrays

# Access the first element of int_array

Modifying Elements of Arrays