What is an Array in Python?

An array is a collection of items stored at contiguous memory locations. The idea is to

store multiple items of the same type together.
Element - Each item stored in an array is called an element.

Index - The location of an element in an array has a numerical index, which is used to identify the
element's position. The index value is very much important in an Array.

Create an Array in Python

Array in Python can be created by importing an array
module. array( data_type , value_list ) is used to create array in Python with data
type and value list specified in its arguments.

SYNTAX
from array import *
arrayName = array(typecode, [initializers])

EXAMPLE

import array as arr

a = arr.array('i', [1, 2, 3])

print("The new created array is : ", end=" ")

for i in range(0, 3):

print(a[i], end=" ")

print()

b = arr.array('d', [2.5, 3.2, 3.3])

print("\nThe new created array is : ", end=" ")

for i in range(0, 3):

print(b[i], end=" ")

Array operations
o Traverse - It prints all the elements one by one.
o Insertion - It adds an element at the given index.
o Deletion - It deletes an element at the given index.
o Search - It searches an element using the given index or by the value.
o Update - It updates an element at the given index.

1. Lists in Python

A list is the most common and versatile data structure in Python that behaves like an array but can store
elements of mixed data types. Lists are dynamic, meaning they can grow or shrink in size as needed.

Creating a List

# Creating a list with various elements

arr = [1, 2, 3, 4, 5]

print(arr) # Output: [1, 2, 3, 4, 5]

Accessing Elements

You can access elements in a list using an index:

print(arr[0]) # Output: 1

print(arr[-1]) # Output: 5 (Last element)

Slicing a List

Slicing allows you to create sublists:

print(arr[1:4]) # Output: [2, 3, 4] (Elements from index 1 to 3)

Adding/Removing Elements
Append: Adds an element at the end.

Insert: Adds an element at a specified position.

Pop: Removes and returns an element.

Remove: Removes the first occurrence of a value.

arr.append(6) # Adds 6 at the end

print(arr) # Output: [1, 2, 3, 4, 5, 6]

arr.insert(2, 7) # Adds 7 at index 2

print(arr) # Output: [1, 2, 7, 3, 4, 5, 6]

arr.pop() # Removes and returns the last element

print(arr) # Output: [1, 2, 7, 3, 4, 5]

arr.remove(7) # Removes the first occurrence of 7

print(arr) # Output: [1, 2, 3, 4, 5]

List Operations

Concatenate: Combine two lists.

Repeat: Repeat a list multiple times.

Length: Get the number of elements in the list.

In/Not In: Check if an element exists in the list.

arr2 = [6, 7, 8]

combined = arr + arr2 # Concatenation

print(combined) # Output: [1, 2, 3, 4, 5, 6, 7, 8]

repeated = arr * 2 # Repeat the list

print(repeated) # Output: [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

print(len(arr)) # Output: 5 (Length of the list)

print(3 in arr) # Output: True

print(10 not in arr) # Output: True

---

2. Arrays in Python (array Module)

If you need an array with a specific type of data, Python’s array module provides a more memory-efficient
array. These arrays are similar to lists, but they are more efficient when you need to store large quantities
of data of a fixed type (e.g., integers or floats).

Creating an Array

The array module is used to create arrays with a specific type code:

'i': Integer
'f': Float

'd': Double (float)

import array

# Creating an integer array

arr = array.array('i', [1, 2, 3, 4, 5])

print(arr) # Output: array('i', [1, 2, 3, 4, 5])

# Creating a float array

arr2 = array.array('f', [1.5, 2.5, 3.5])

print(arr2) # Output: array('f', [1.5, 2.5, 3.5])

Array Operations

Arrays support many of the same operations as lists, but they only work with elements of the same data
type.

# Appending elements to an array

arr.append(6)

print(arr) # Output: array('i', [1, 2, 3, 4, 5, 6])

# Inserting an element at a specific index

arr.insert(2, 7)

print(arr) # Output: array('i', [1, 2, 7, 3, 4, 5, 6])

# Removing an element

arr.remove(7)

print(arr) # Output: array('i', [1, 2, 3, 4, 5, 6])

# Pop an element (removes and returns it)

popped_element = arr.pop()

print(popped_element) # Output: 6

print(arr) # Output: array('i', [1, 2, 3, 4, 5])

# Length of array

print(len(arr)) # Output: 5

Array Conversion

You can convert between lists and arrays:

# Converting a list to an array

arr_from_list = array.array('i', [10, 20, 30, 40])

print(arr_from_list) # Output: array('i', [10, 20, 30, 40])

# Converting an array to a list

list_from_arr = arr_from_list.tolist()

print(list_from_arr) # Output: [10, 20, 30, 40]

---

3. Performance Comparison: List vs Array

Lists: More flexible (can hold different data types), but they can be slower and use more memory for large
datasets.

Arrays: More memory-efficient and faster for large datasets when elements are of the same type (especially
for numerical operations), but less flexible than lists.

4. Numpy Arrays (For Numeric Data)

For numerical computations and handling large arrays, the NumPy library is widely used. It provides
powerful array objects (ndarrays) and a wide range of functions for array manipulation.

Creating a NumPy Array

import numpy as np

# Creating a NumPy array

arr = np.array([1, 2, 3, 4, 5])

print(arr) # Output: [1 2 3 4 5]

Array Operations with NumPy

NumPy arrays support advanced mathematical operations, including element-wise operations, matrix
operations, and much more.

arr = np.array([1, 2, 3, 4])

# Element-wise operations

print(arr * 2) # Output: [2 4 6 8]

print(arr + 1) # Output: [2 3 4 5]
# Sum of array elements

print(np.sum(arr)) # Output: 10

# Mean and standard deviation

print(np.mean(arr)) # Output: 2.5

print(np.std(arr)) # Output: 1.118

Advantages of NumPy Arrays

Memory Efficient: NumPy arrays use less memory and provide better performance compared to regular
Python lists.

Vectorized Operations: NumPy supports operations on entire arrays, avoiding the need for loops in many
cases, which can lead to faster execution.

Multi-dimensional Arrays: NumPy can handle multi-dimensional arrays (matrices, tensors).

Conclusion

Lists are the most versatile and commonly used array-like structure in Python.

array module arrays are useful when you need a more memory-efficient, type-specific array.

For advanced numerical work, NumPy arrays provide a high-performance, efficient solution.
What is Stack in Python?
A stack is a data structure that follows the Last In, First Out (LIFO) principle, meaning the last element
added to the stack is the first one to be removed. It is widely used in programming and computer science
for managing data in a specific order.

Key Characteristics:

1. Push: Add an element to the top of the stack.

2. Pop: Remove the top element from the stack.
3. Peek/Top: Retrieve the top element without removing it.
4. Empty: Check if the stack is empty.

Common Use Cases:

Function calls: Used in managing recursive function calls (call stack).

Undo operations: Track changes for undo functionality in applications.

Expression evaluation: Converting and evaluating expressions (e.g., infix to postfix).

Backtracking: Solving problems like maze traversal or navigating through data structures.

Example:

Simple Stack Operations

stack = [] # Using a list as a stack

# Push elements

stack.append(1)

stack.append(2)

stack.append(3)

# Peek

print(stack[-1]) # Output: 3

# Pop

print(stack.pop()) # Output: 3

print(stack.pop()) # Output: 2

# Check if empty

print(len(stack) == 0) # Output: False

Stacks can be implemented using arrays, linked lists, or built-in data structures, depending on the
programming language.

What is Queue in Python?

A queue is a data structure that follows the First In, First Out (FIFO) principle, meaning the first
element added to the queue is the first one to be removed. It is commonly used to manage tasks
or resources in the order they arrive.

Key Characteristics:

1. Enqueue: Add an element to the end of the queue.

2. Dequeue: Remove an element from the front of the queue.

3. Front: Retrieve the front element without removing it.

4. Rear/Back: Retrieve the last element without removing it.

5. Empty: Check if the queue is empty.

Common Use Cases:

 Task scheduling: Managing processes in operating systems or printers.

 Data streaming: Handling data packets in networks.

 Breadth-first search (BFS): Traversing graphs or trees.

 Real-world scenarios: Lines in supermarkets or ticket counters.

---

Example:

Simple Queue Operations

from collections import deque

# Create a queue
queue = deque()

# Enqueue elements
queue.append(1)
queue.append(2)
queue.append(3)

# Peek at the front

print(queue[0]) # Output: 1
# Dequeue elements
print(queue.popleft()) # Output: 1
print(queue.popleft()) # Output: 2

# Check if empty
print(len(queue) == 0) # Output: False

Types of Queues:

1. Simple Queue: Basic FIFO implementation.

2. Circular Queue: The last position connects to the first, optimizing space usage.

3. Priority Queue: Elements are dequeued based on priority rather than arrival time.

4. Double-Ended Queue (Deque): Elements can be added or removed from both ends.

Implementation:

Queues can be implemented using arrays, linked lists, or built-in structures like deque in Python
or Queue in Java.
What is Priority Queue in Python?

A priority queue is an advanced data structure where elements are stored and accessed based on their priority
rather than their order of insertion. It operates like a regular queue but with a key difference: the element with the
highest (or lowest, depending on implementation) priority is dequeued first, regardless of when it was added.

Key Characteristics:

1. Prioritization: Elements are assigned a priority, and the element with the highest priority is dequeued first.

2. Dynamic Order: The order of elements is determined dynamically by their priority.

3. Comparison: Priorities can be numerical, alphabetical, or custom (using a comparator or key function).

---

Common Operations:

1. Insert: Add an element with a given priority.

2. Peek: Retrieve the highest-priority element without removing it.

3. Extract/Pop: Remove and return the highest-priority element.

Implementation in Python:

Python's heapq module is often used to implement priority queues, as it provides functions for maintaining a
min-heap. If a max-heap is needed, priorities can be negated.

Using heapq (Min-Heap Implementation)

import heapq

# Create a priority queue

pq = []

# Insert elements
heapq.heappush(pq, (2, "Task A")) # (priority, element)
heapq.heappush(pq, (1, "Task B"))
heapq.heappush(pq, (3, "Task C"))

# Peek at the highest-priority element

print(pq[0]) # Output: (1, 'Task B')

# Pop the highest-priority element

print(heapq.heappop(pq)) # Output: (1, 'Task B')
print(heapq.heappop(pq)) # Output: (2, 'Task A')

Using Negated Values for Max-Heap

import heapq

# Create a priority queue

pq = []

# Insert elements (negative priorities for max-heap)

heapq.heappush(pq, (-2, "Task A"))
heapq.heappush(pq, (-1, "Task B"))
heapq.heappush(pq, (-3, "Task C"))

# Pop elements based on max priority

print(heapq.heappop(pq)) # Output: (-3, 'Task C')
print(heapq.heappop(pq)) # Output: (-2, 'Task A')

---

Alternative: Using queue.PriorityQueue

Python also provides a PriorityQueue class in the queue module, which is thread-safe.

from queue import PriorityQueue

pq = PriorityQueue()

# Insert elements
pq.put((2, "Task A"))
pq.put((1, "Task B"))
pq.put((3, "Task C"))

# Pop elements
print(pq.get()) # Output: (1, 'Task B')
print(pq.get()) # Output: (2, 'Task A')

---

Applications:

1. Task Scheduling: Managing tasks based on priority (e.g., operating systems).

2. Dijkstra's Algorithm: Finding the shortest path in graphs.
3. Huffman Coding: Data compression algorithms.
4. Event Simulation: Handling events that occur at different priorities.

A priority queue ensures efficient insertion and extraction of elements based on their priority, making it an
essential tool in various algorithms and systems.
What is Sliding Window in Python?

The Sliding Window technique is an efficient way to solve problems involving subarrays or substrings in an
array or string. It optimizes the naive approach by maintaining a window (a subset of elements) that slides
over the array or string.

Key Concepts:

1. Window Size:

Fixed: The window size remains constant.

Variable: The window size can expand or shrink based on conditions.

2. Two Pointers:

Start and end pointers are used to define the boundaries of the window.

3. Time Complexity:

Typically O(n), as each element is processed at most twice (once when expanding and once when shrinking
the window).

---

Common Sliding Window Problems

1. Fixed Window Size Example

Problem: Find the maximum sum of any subarray of size k.

Code:
def max_sum_subarray(arr, k):
n = len(arr)
if n < k:
return None

# Compute the sum of the first window

window_sum = sum(arr[:k])
 max_sum = window_sum

# Slide the window

for i in range(k, n):
window_sum += arr[i] - arr[i - k]
max_sum = max(max_sum, window_sum)

return max_sum

# Example
arr = [1, 2, 3, 4, 5, 6]
k=3
print(max_sum_subarray(arr, k)) # Output: 15

---

2. Variable Window Size Example

Problem: Find the smallest subarray with a sum greater than or equal to target.

Code:

def min_subarray_with_sum(arr, target):

n = len(arr)
min_length = float('inf')
window_sum = 0
start = 0

for end in range(n):

window_sum += arr[end]

while window_sum >= target:

min_length = min(min_length, end - start + 1)
window_sum -= arr[start]
start += 1

return min_length if min_length != float('inf') else 0

# Example
arr = [2, 3, 1, 2, 4, 3]
target = 7
print(min_subarray_with_sum(arr, target)) # Output: 2

---

3. Longest Substring Without Repeating Characters

Problem: Find the length of the longest substring without repeating characters.

Code:
def longest_unique_substring(s):
char_set = set()
start = 0
max_length = 0

for end in range(len(s)):

while s[end] in char_set:
char_set.remove(s[start])
start += 1
char_set.add(s[end])
max_length = max(max_length, end - start + 1)

return max_length

# Example
s = "abcabcbb"
print(longest_unique_substring(s)) # Output: 3 ("abc")

---

4. Maximum Sum of K Elements in a Sliding Window

Problem: Find the maximum sum in a window of size k.

Code:

def max_sum_k_elements(arr, k):

n = len(arr)
if n < k:
return None

window_sum = sum(arr[:k])
max_sum = window_sum

for i in range(k, n):

window_sum += arr[i] - arr[i - k]
max_sum = max(max_sum, window_sum)

return max_sum

# Example
arr = [1, 2, 100, 4, 5]
k=2
print(max_sum_k_elements(arr, k)) # Output: 104

---

General Steps to Solve Sliding Window Problems:

1. Define the window:

Use two pointers (start and end) to represent the window.

2. Expand the window:

Add elements to the window.

3. Shrink the window:

Remove elements from the window when a condition is met.

4. Update results:
Keep track of the desired metric (e.g., sum, length, or unique elements).
This method is highly efficient for solving problems with sequential constraints.
What is linked list in Python?

A linked list is a linear data structure in which elements, called nodes, are linked together using pointers.
Each node contains two parts:

1. Data: The actual value stored in the node.

2. Pointer (next): A reference to the next node in the sequence.

Types of Linked Lists:

1. Singly Linked List:

Each node points to the next node.
Traversal is one-directional.

[data|next] -> [data|next] -> [data|next] -> None

2. Doubly Linked List:

Each node has two pointers: one pointing to the previous node and one to the next.
Traversal is bidirectional.
None <- [prev|data|next] <-> [prev|data|next] <-> [prev|data|next] -> None

3. Circular Linked List:

The last node points back to the first node, forming a circle.
Can be singly or doubly linked.
[data|next] -> [data|next] -> [data|next] --|
^-----------------------------|

---

Advantages:

Dynamic Size: Can grow or shrink at runtime.

Efficient Insertion/Deletion: Adding or removing elements doesn’t require shifting like arrays.
Memory Utilization: Nodes are allocated as needed.

---

Disadvantages:

Sequential Access: Cannot perform random access like arrays.

Extra Memory: Requires storage for pointers.
Complexity: Traversal and management are more complex than arrays.

---

Basic Operations:

1. Traversal: Visit each node in the list.

2. Insertion: Add a node at the beginning, end, or a specific position.
3. Deletion: Remove a node from the beginning, end, or a specific position.
4. Search: Find if a value exists in the linked list.

---

Singly Linked List Implementation in Python

class Node:
def _init_(self, data):
self.data = data
self.next = None

class LinkedList:
def _init_(self):
self.head = None

# Insert at the end

def append(self, data):
new_node = Node(data)
if not self.head:
self.head = new_node
return
current = self.head
while current.next:
current = current.next
current.next = new_node

# Print the list

def print_list(self):
current = self.head
while current:
print(current.data, end=" -> ")
current = current.next
print("None")

# Delete a node by value

def delete(self, value):
current = self.head
if current and current.data == value:
self.head = current.next
return
prev = None
while current and current.data != value:
 prev = current
current = current.next
if current:
prev.next = current.next

# Example usage
ll = LinkedList()
ll.append(1)
ll.append(2)
ll.append(3)
ll.print_list() # Output: 1 -> 2 -> 3 -> None
ll.delete(2)
ll.print_list() # Output: 1 -> 3 -> None

---

Applications:

1. Dynamic Memory Allocation: Used in stacks, queues, and other data structures.
2. Graph Representation: Adjacency lists in graph algorithms.
3. Operating Systems: Managing free memory blocks, file allocation tables, etc.

A linked list is a flexible structure that shines in scenarios where frequent insertions and deletions are
needed.
Recursion in Python refers to a function calling itself directly or indirectly to solve a smaller instance of a
problem. This process continues until it reaches a base case, which terminates the recursive calls.

Key Components of Recursion:

1. Base Case:

The condition under which recursion stops.

Prevents infinite recursion.

2. Recursive Case:

The part of the function where the recursion occurs.

---

How Recursion Works:

Each recursive call adds a new layer to the call stack, and the result is resolved when the base case is
reached. The stack unwinds as the calls return their results.

---

Example: Factorial Calculation

Problem: Compute .

def factorial(n):
# Base case
if n == 0 or n == 1:
return 1
# Recursive case
return n * factorial(n - 1)

# Example usage
print(factorial(5)) # Output: 120

---
Common Use Cases of Recursion:

1. Mathematical Problems:

Factorial, Fibonacci, Power of a number, etc.

2. Data Structure Operations:

Traversing trees or graphs (e.g., binary tree traversal).

3. Divide and Conquer Algorithms:

QuickSort, MergeSort, Binary Search.

4. Backtracking Problems:

Solving mazes, N-Queens problem, etc.

---

Examples of Recursion

1. Fibonacci Sequence

Compute the -th Fibonacci number:

def fibonacci(n):
# Base case
if n == 0:
return 0
if n == 1:
return 1
# Recursive case
return fibonacci(n - 1) + fibonacci(n - 2)

# Example usage
print(fibonacci(6)) # Output: 8

2. Sum of an Array

Find the sum of an array using recursion:

def sum_array(arr):
# Base case
if len(arr) == 0:
return 0
# Recursive case
return arr[0] + sum_array(arr[1:])

# Example usage
print(sum_array([1, 2, 3, 4, 5])) # Output: 15

3. Binary Search

Perform binary search on a sorted list:

def binary_search(arr, target, left, right):

# Base case: Element not found
if left > right:
return -1

mid = (left + right) // 2

if arr[mid] == target:
return mid
elif arr[mid] < target:
return binary_search(arr, target, mid + 1, right)
else:
return binary_search(arr, target, left, mid - 1)

# Example usage
arr = [1, 2, 3, 4, 5, 6]
print(binary_search(arr, 4, 0, len(arr) - 1)) # Output: 3

---

Advantages of Recursion:

1. Simplifies code for problems with repetitive substructures (e.g., traversals, divides).

2. Elegant and easier to understand for problems like tree traversals or backtracking.

---

Disadvantages of Recursion:

1. Performance: Recursive calls can be inefficient due to repeated calculations and high stack usage.

2. Stack Overflow: Too many recursive calls may exceed the maximum recursion depth.
---

Tips for Using Recursion:

1. Define a clear base case to prevent infinite recursion.

2. Use memoization or dynamic programming for overlapping subproblems (e.g., Fibonacci).

3. Ensure recursion depth doesn’t exceed Python’s default limit (you can adjust it if necessary using
sys.setrecursionlimit).

Recursion is a powerful tool when used appropriately, but for performance-critical tasks, iterative solutions
may be preferred.
Backtracking is a problem-solving technique that involves exploring all possible solutions to a problem by
incrementally building a solution and abandoning a path ("backtracking") as soon as it is determined that the
path will not lead to a valid or optimal solution.

---

Key Characteristics of Backtracking:

1. Recursive Approach:

Backtracking is often implemented using recursion.

2. Trial and Error:

It systematically tries all possible options, undoing decisions when a path fails.

3. Pruning:

Conditions or constraints are used to avoid exploring paths that are guaranteed to fail.

---

General Steps in Backtracking:

1. Define the Problem:

Clearly define the constraints and the goal.

2. Explore Possibilities:

Start with an initial state and try possible moves.

3. Check Constraints:

If a move violates constraints, backtrack to the previous state.

4. Repeat:

Continue until a solution is found or all possibilities are exhausted.

---

Example Problems Solved with Backtracking:

1. N-Queens Problem

Place queens on an chessboard such that no two queens attack each other.

def solve_n_queens(n):
def is_safe(board, row, col):
for i in range(row):
if board[i] == col or \
board[i] - i == col - row or \
board[i] + i == col + row:
return False
return True

def backtrack(row, board):

if row == n:
result.append(board[:])
return
for col in range(n):
if is_safe(board, row, col):
board[row] = col
backtrack(row + 1, board)
board[row] = -1

result = []
backtrack(0, [-1] * n)
return result

# Example usage
solutions = solve_n_queens(4)
print(len(solutions)) # Output: 2 (number of solutions)

---

2. Subset Sum Problem

Find all subsets of an array that sum up to a given target.

def subset_sum(nums, target):

 def backtrack(start, current, total):
if total == target:
result.append(current[:])
return
if total > target:
return
for i in range(start, len(nums)):
current.append(nums[i])
backtrack(i + 1, current, total + nums[i])
current.pop()

result = []
backtrack(0, [], 0)
return result

# Example usage
nums = [2, 3, 5, 7]
target = 7
print(subset_sum(nums, target)) # Output: [[2, 5], [7]]

---

3. Solving a Maze

Find a path from the start to the end of a maze.

def solve_maze(maze):
def is_safe(x, y):
return 0 <= x < len(maze) and 0 <= y < len(maze[0]) and maze[x][y] == 1

def backtrack(x, y, path):

if x == len(maze) - 1 and y == len(maze[0]) - 1:
path.append((x, y))
result.append(path[:])
path.pop()
return

if is_safe(x, y):
path.append((x, y))
maze[x][y] = -1 # Mark as visited
for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
backtrack(x + dx, y + dy, path)
path.pop()
maze[x][y] = 1 # Unmark

result = []
backtrack(0, 0, [])
return result

# Example usage
maze = [
[1, 0, 0, 0],
 [1, 1, 0, 1],
[0, 1, 0, 0],
[1, 1, 1, 1]
]
print(solve_maze(maze))

---

Advantages of Backtracking:

1. Systematic Exploration:

Explores all possible solutions methodically.

2. Flexibility:

Can solve a variety of problems with constraints.

3. Optimization:

With pruning, it avoids exploring unnecessary paths.

---

Disadvantages of Backtracking:

1. Inefficiency:

May explore many unnecessary paths in the worst case.

2. High Time Complexity:

Often exponential, depending on the problem.

3. Memory Usage:

Recursive implementations can lead to stack overflow for deep recursion.

---

Common Applications:

Puzzle solving (e.g., Sudoku, N-Queens).

Generating permutations and combinations.

Graph problems (e.g., Hamiltonian path, Knight's tour).

Constraint satisfaction problems (e.g., scheduling, map coloring).

Backtracking is a powerful algorithmic approach for solving problems with constraints, especially when the
solution space is large and complex.
A graph is a data structure that represents a collection of nodes (or vertices) and edges (connections
between the nodes). Graphs can be used to model relationships between entities, such as networks, routes,
and dependencies.

---

Types of Graphs:

1. Directed Graph:

Edges have a direction (e.g., A → B).

2. Undirected Graph:

Edges have no direction (e.g., A — B).

3. Weighted Graph:

Edges have weights or costs associated with them (e.g., distance between two points).

4. Unweighted Graph:

Edges have no weights.

5. Cyclic Graph:

Contains at least one cycle (path where a vertex can be revisited).

6. Acyclic Graph:

Contains no cycles.

---

Graph Representation in Python:

1. Adjacency Matrix:
A 2D array where matrix[i][j] indicates the presence (and optionally weight) of an edge between vertex and .

# Adjacency Matrix Example

graph = [
[0, 1, 0],
[1, 0, 1],
[0, 1, 0]
]

2. Adjacency List:

A dictionary or list where each vertex stores a list of its adjacent vertices.

# Adjacency List Example

graph = {
'A': ['B', 'C'],
'B': ['A', 'D'],
'C': ['A', 'D'],
'D': ['B', 'C']
}

3. Edge List:

A list of tuples representing edges (optionally with weights).

# Edge List Example

edges = [
('A', 'B', 1),
('A', 'C', 2),
('B', 'D', 3),
('C', 'D', 4)
]

---

Graph Implementation in Python

Using Adjacency List

class Graph:
def _init_(self):
self.graph = {}

def add_edge(self, u, v):

 if u not in self.graph:
self.graph[u] = []
if v not in self.graph:
self.graph[v] = []
self.graph[u].append(v)
self.graph[v].append(u) # Remove this line for a directed graph

def display(self):
for node in self.graph:
print(f"{node}: {self.graph[node]}")

# Example Usage
g = Graph()
g.add_edge('A', 'B')
g.add_edge('A', 'C')
g.add_edge('B', 'D')
g.display()
# Output:
# A: ['B', 'C']
# B: ['A', 'D']
# C: ['A']
# D: ['B']

---

Graph Traversal Algorithms

1. Breadth-First Search (BFS)

Explores nodes level by level.

from collections import deque

def bfs(graph, start):

visited = set()
queue = deque([start])
result = []

while queue:
node = queue.popleft()
if node not in visited:
visited.add(node)
result.append(node)
queue.extend(graph[node])
return result

# Example Usage
graph = {
'A': ['B', 'C'],
'B': ['A', 'D', 'E'],
'C': ['A', 'F'],
'D': ['B'],
 'E': ['B'],
'F': ['C']
}
print(bfs(graph, 'A')) # Output: ['A', 'B', 'C', 'D', 'E', 'F']

---

2. Depth-First Search (DFS)

Explores nodes as deep as possible before backtracking.

Recursive Implementation:

def dfs_recursive(graph, start, visited=None):

if visited is None:
visited = set()
visited.add(start)
for neighbor in graph[start]:
if neighbor not in visited:
dfs_recursive(graph, neighbor, visited)
return visited

# Example Usage
graph = {
'A': ['B', 'C'],
'B': ['A', 'D', 'E'],
'C': ['A', 'F'],
'D': ['B'],
'E': ['B'],
'F': ['C']
}
print(dfs_recursive(graph, 'A')) # Output: {'A', 'B', 'D', 'E', 'C', 'F'}

Iterative Implementation:

def dfs_iterative(graph, start):

visited = set()
stack = [start]
result = []

while stack:
node = stack.pop()
if node not in visited:
visited.add(node)
result.append(node)
stack.extend(graph[node])
return result

# Example Usage
print(dfs_iterative(graph, 'A')) # Output: ['A', 'C', 'F', 'B', 'E', 'D']
---

Weighted Graphs with Dijkstra's Algorithm

Find the shortest path from a source node to all other nodes.

import heapq

def dijkstra(graph, start):

pq = [(0, start)] # (distance, node)
distances = {node: float('inf') for node in graph}
distances[start] = 0

while pq:
current_distance, current_node = heapq.heappop(pq)

if current_distance > distances[current_node]:

continue

for neighbor, weight in graph[current_node]:

distance = current_distance + weight
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(pq, (distance, neighbor))

return distances

# Example Usage
graph = {
'A': [('B', 1), ('C', 4)],
'B': [('A', 1), ('C', 2), ('D', 5)],
'C': [('A', 4), ('B', 2), ('D', 1)],
'D': [('B', 5), ('C', 1)]
}
print(dijkstra(graph, 'A')) # Output: {'A': 0, 'B': 1, 'C': 3, 'D': 4}

---

Applications of Graphs:

1. Social Networks: Representing connections between users.

2. Maps and Navigation: Shortest path between locations.

3. Dependency Resolution: Task scheduling, build systems.

4. Network Routing: Optimizing data flow in networks.

Graphs are versatile and are widely used in solving real-world problems in computer science, engineering,
and data science.

Dynamic Programming (DP) is an optimization technique used to solve problems by breaking them into
overlapping subproblems. It stores the results of already-solved subproblems (using memoization or
tabulation) to avoid redundant computations.

---

Steps in Dynamic Programming:

1. Identify the problem as overlapping subproblems:

Check if the problem can be divided into smaller subproblems that are solved repeatedly.

2. Define the recurrence relation:

Determine how the solution to a larger problem depends on its subproblems.

3. Choose a method:

Top-Down (Memoization): Recursive approach with caching.

Bottom-Up (Tabulation): Iterative approach with a table.

---

1. Fibonacci Sequence

Compute the -th Fibonacci number.

Top-Down (Memoization)

def fibonacci_memo(n, memo={}):

if n in memo:
return memo[n]
if n <= 1:
return n
memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)
return memo[n]

# Example usage
print(fibonacci_memo(10)) # Output: 55

Bottom-Up (Tabulation)

def fibonacci_tab(n):
if n <= 1:
return n
dp = [0] * (n + 1)
dp[1] = 1
for i in range(2, n + 1):
dp[i] = dp[i - 1] + dp[i - 2]
return dp[n]

# Example usage
print(fibonacci_tab(10)) # Output: 55

---

2. Longest Common Subsequence (LCS)

Find the length of the longest common subsequence of two strings.

Recursive with Memoization

def lcs_memo(s1, s2, i, j, memo):

if i == 0 or j == 0:
return 0
if (i, j) in memo:
return memo[(i, j)]
if s1[i - 1] == s2[j - 1]:
memo[(i, j)] = 1 + lcs_memo(s1, s2, i - 1, j - 1, memo)
else:
memo[(i, j)] = max(lcs_memo(s1, s2, i - 1, j, memo), lcs_memo(s1, s2, i, j - 1, memo))
return memo[(i, j)]

# Example usage
s1, s2 = "abcde", "ace"
memo = {}
print(lcs_memo(s1, s2, len(s1), len(s2), memo)) # Output: 3

Bottom-Up

def lcs_tab(s1, s2):

m, n = len(s1), len(s2)
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if s1[i - 1] == s2[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]
# Example usage
print(lcs_tab("abcde", "ace")) # Output: 3

---

3. 0/1 Knapsack Problem

Given weights and values of items, find the maximum value achievable with a weight limit.

Recursive with Memoization

def knapsack_memo(wt, val, W, n, memo):

if n == 0 or W == 0:
return 0
if (n, W) in memo:
return memo[(n, W)]
if wt[n - 1] > W:
memo[(n, W)] = knapsack_memo(wt, val, W, n - 1, memo)
else:
memo[(n, W)] = max(
val[n - 1] + knapsack_memo(wt, val, W - wt[n - 1], n - 1, memo),
knapsack_memo(wt, val, W, n - 1, memo),
)
return memo[(n, W)]

# Example usage
weights = [1, 2, 3]
values = [10, 15, 40]
capacity = 6
print(knapsack_memo(weights, values, capacity, len(weights), {})) # Output: 55

Bottom-Up

def knapsack_tab(wt, val, W):

n = len(wt)
dp = [[0] * (W + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
for w in range(1, W + 1):
if wt[i - 1] <= w:
dp[i][w] = max(val[i - 1] + dp[i - 1][w - wt[i - 1]], dp[i - 1][w])
else:
dp[i][w] = dp[i - 1][w]
return dp[n][W]

# Example usage
print(knapsack_tab([1, 2, 3], [10, 15, 40], 6)) # Output: 55

---

4. Minimum Path Sum in a Grid

Find the minimum cost to travel from the top-left to the bottom-right of a grid.

Bottom-Up

def min_path_sum(grid):
m, n = len(grid), len(grid[0])
dp = [[0] * n for _ in range(m)]
dp[0][0] = grid[0][0]

for i in range(1, m):

dp[i][0] = dp[i - 1][0] + grid[i][0]
for j in range(1, n):
dp[0][j] = dp[0][j - 1] + grid[0][j]

for i in range(1, m):

for j in range(1, n):
dp[i][j] = grid[i][j] + min(dp[i - 1][j], dp[i][j - 1])

return dp[-1][-1]

# Example usage
grid = [[1, 3, 1], [1, 5, 1], [4, 2, 1]]
print(min_path_sum(grid)) # Output: 7

---

Key Concepts in DP:

1. Overlapping Subproblems: Break the problem into smaller, repeated subproblems.

2. Optimal Substructure: The solution to a larger problem can be derived from solutions to its subproblems.

3. Memoization vs Tabulation:

Memoization: Top-down recursive with caching.

Tabulation: Bottom-up iterative approach.

---

Common Applications of Dynamic Programming:

1. Optimization Problems: Knapsack, matrix chain multiplication, rod cutting.

2. Path Problems: Minimum/maximum path, grid traversal.

3. Subsequence Problems: LCS, LIS (Longest Increasing Subsequence).

4. Game Theory: Minimax strategies.

5. String Problems: Edit distance, palindrome partitioning.

Dynamic Programming is a versatile and efficient tool for solving problems with overlapping subproblems
and optimal substructure properties.
A tree is a hierarchical data structure consisting of nodes connected by edges. It consists of a root node,
internal nodes, and leaf nodes. Each node has a value and may have children, except the leaf nodes.

Basic Terminology:

1. Root: The topmost node in the tree.

2. Node: A data element in the tree.

3. Edge: A connection between two nodes.

4. Parent: A node that has children.

5. Child: A node that is a descendant of a parent node.

6. Leaf: A node with no children.

7. Subtree: A tree formed by a node and all its descendants.

8. Depth of Node: The level of the node in the tree (root has depth 0).

9. Height of Tree: The length of the longest path from the root to a leaf node.

Types of Trees:

1. Binary Tree: Each node has at most two children (left and right).

2. Binary Search Tree (BST): A binary tree where the left child is smaller and the right child is greater than the
parent.

3. AVL Tree: A self-balancing binary search tree.

4. Heap: A binary tree used for implementing priority queues (min-heap or max-heap).

5. Trie: A tree used for efficient string storage and searching.

---

Binary Tree Implementation in Python

A simple binary tree implementation in Python involves creating a Node class and a BinaryTree class.

1. Node Class

Each node has:

A value.

A left child.

A right child.

class Node:
def _init_(self, value):
self.value = value
self.left = None
self.right = None

2. Binary Tree Class

This class provides operations like inserting nodes and traversing the tree.

class BinaryTree:
def _init_(self, root_value):
self.root = Node(root_value)

# Insertion (can be done in many ways, for simplicity, we do level-order)

def insert(self, value):
new_node = Node(value)
queue = [self.root]
while queue:
current = queue.pop(0)
if not current.left:
current.left = new_node
return
elif not current.right:
current.right = new_node
return
queue.append(current.left)
queue.append(current.right)

# In-order Traversal (left, root, right)

def inorder_traversal(self, node):
if node:
self.inorder_traversal(node.left)
 print(node.value, end=" ")
self.inorder_traversal(node.right)

# Pre-order Traversal (root, left, right)

def preorder_traversal(self, node):
if node:
print(node.value, end=" ")
self.preorder_traversal(node.left)
self.preorder_traversal(node.right)

# Post-order Traversal (left, right, root)

def postorder_traversal(self, node):
if node:
self.postorder_traversal(node.left)
self.postorder_traversal(node.right)
print(node.value, end=" ")

# Level-order Traversal (Breadth First Search)

def levelorder_traversal(self):
queue = [self.root]
while queue:
current = queue.pop(0)
print(current.value, end=" ")
if current.left:
queue.append(current.left)
if current.right:
queue.append(current.right)

# Example usage:
tree = BinaryTree(1) # Create tree with root 1
tree.insert(2)
tree.insert(3)
tree.insert(4)
tree.insert(5)

print("In-order Traversal:")
tree.inorder_traversal(tree.root) # Output: 4 2 5 1 3

print("\nPre-order Traversal:")
tree.preorder_traversal(tree.root) # Output: 1 2 4 5 3

print("\nPost-order Traversal:")
tree.postorder_traversal(tree.root) # Output: 4 5 2 3 1

print("\nLevel-order Traversal:")
tree.levelorder_traversal() # Output: 1 2 3 4 5

---

Binary Search Tree (BST)

In a Binary Search Tree (BST):

The left child is less than the parent.

The right child is greater than the parent.

Node Class (for BST):

class BSTNode:
def _init_(self, value):
self.value = value
self.left = None
self.right = None

Binary Search Tree Class:

class BinarySearchTree:
def _init_(self):
self.root = None

# Insert a node
def insert(self, value):
if not self.root:
self.root = BSTNode(value)
else:
self._insert_recursive(self.root, value)

def _insert_recursive(self, node, value):

if value < node.value:
if node.left:
self._insert_recursive(node.left, value)
else:
node.left = BSTNode(value)
else:
if node.right:
self._insert_recursive(node.right, value)
else:
node.right = BSTNode(value)

# Search for a value

def search(self, value):
return self._search_recursive(self.root, value)

def _search_recursive(self, node, value):

if node is None or node.value == value:
return node
if value < node.value:
return self._search_recursive(node.left, value)
return self._search_recursive(node.right, value)

# In-order Traversal (left, root, right)

def inorder_traversal(self, node):
if node:
 self.inorder_traversal(node.left)
print(node.value, end=" ")
self.inorder_traversal(node.right)

# Example usage:
bst = BinarySearchTree()
bst.insert(10)
bst.insert(5)
bst.insert(15)
bst.insert(3)

print("In-order Traversal of BST:")

bst.inorder_traversal(bst.root) # Output: 3 5 10 15

node = bst.search(5)
print("\nSearch for 5:", node.value if node else "Not Found") # Output: 5

---

Other Tree Types

1. AVL Tree:

A self-balancing Binary Search Tree (BST) where the height difference between left and right subtrees of any
node is at most 1.

Insertions and deletions are followed by rotations to maintain balance.

2. Heap (Binary Heap):

A binary tree used for implementing a priority queue.

In a Min-Heap, the root node contains the minimum value, and each parent node is smaller than its children.

In a Max-Heap, the root node contains the maximum value, and each parent node is greater than its
children.

3. Trie (Prefix Tree):

A specialized tree used to store a dynamic set or associative array where the keys are usually strings. It
allows for fast retrieval of keys.

4. Red-Black Tree:

A balanced binary search tree with additional properties that ensure the tree remains balanced, providing
O(log n) time complexity for insertion, deletion, and search operations.
---

Conclusion:

Trees are fundamental data structures used in many applications, such as file systems, databases, and
network routing.

Binary trees are often used for searching and sorting.

Binary Search Trees (BST) ensure that insertion, deletion, and search operations can be done efficiently
(O(log n) on average).

More complex trees like AVL and Red-Black Trees are used when balancing is necessary to maintain efficient
operations.
Sorting algorithms are used to arrange elements in a specific order (typically ascending or descending).
Below are some of the most common sorting algorithms in Python, along with their implementations.

---

1. Bubble Sort

Bubble Sort repeatedly compares adjacent elements and swaps them if they are in the wrong order. This
process is repeated until the list is sorted.

Time Complexity: O(n²) in the worst case.

def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]

# Example usage
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("Bubble Sorted Array:", arr)

---

2. Selection Sort

Selection Sort divides the array into two parts: a sorted part and an unsorted part. It repeatedly selects the
minimum element from the unsorted part and swaps it with the first unsorted element.

Time Complexity: O(n²).

def selection_sort(arr):
for i in range(len(arr)):
min_idx = i
for j in range(i+1, len(arr)):
if arr[j] < arr[min_idx]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]

# Example usage
arr = [64, 25, 12, 22, 11]
selection_sort(arr)
print("Selection Sorted Array:", arr)
---

3. Insertion Sort

Insertion Sort builds the sorted array one element at a time by repeatedly picking the next element from the
unsorted part and inserting it into its correct position in the sorted part.

Time Complexity: O(n²).

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

# Example usage
arr = [12, 11, 13, 5, 6]
insertion_sort(arr)
print("Insertion Sorted Array:", arr)

---

4. Merge Sort

Merge Sort is a divide-and-conquer algorithm that splits the array into halves, sorts each half recursively, and
merges the two sorted halves.

Time Complexity: O(n log n).

def merge_sort(arr):
if len(arr) > 1:
mid = len(arr) // 2
left_half = arr[:mid]
right_half = arr[mid:]

merge_sort(left_half)
merge_sort(right_half)

i=j=k=0
while i < len(left_half) and j < len(right_half):
if left_half[i] < right_half[j]:
arr[k] = left_half[i]
i += 1
else:
arr[k] = right_half[j]
j += 1
k += 1
 while i < len(left_half):
arr[k] = left_half[i]
i += 1
k += 1

while j < len(right_half):

arr[k] = right_half[j]
j += 1
k += 1

# Example usage
arr = [38, 27, 43, 3, 9, 82, 10]
merge_sort(arr)
print("Merge Sorted Array:", arr)

---

5. Quick Sort

Quick Sort is another divide-and-conquer algorithm that picks an element as a pivot and partitions the array
around the pivot, recursively sorting the subarrays.

Time Complexity: O(n log n) on average, O(n²) in the worst case.

def quick_sort(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 quick_sort(left) + middle + quick_sort(right)

# Example usage
arr = [3, 6, 8, 10, 1, 2, 1]
print("Quick Sorted Array:", quick_sort(arr))

---

6. Heap Sort

Heap Sort works by building a max-heap (or min-heap) and repeatedly extracting the maximum (or
minimum) element, placing it in the sorted order.

Time Complexity: O(n log n).

import heapq

def heap_sort(arr):
heapq.heapify(arr) # Turns the list into a heap
return [heapq.heappop(arr) for _ in range(len(arr))]
# Example usage
arr = [12, 11, 13, 5, 6, 7]
print("Heap Sorted Array:", heap_sort(arr))

---

7. Tim Sort

Tim Sort is a hybrid sorting algorithm (used internally in Python’s sorted() function) that combines merge
sort and insertion sort. It is efficient on real-world data.

Time Complexity: O(n log n) in the worst case.

arr = [5, 2, 9, 1, 5, 6]
arr.sort() # Python's built-in sort uses TimSort
print("Tim Sort Sorted Array:", arr)

---

8. Counting Sort

Counting Sort is an integer sorting algorithm that counts the frequency of each element and uses this
information to place each element in the sorted array.

Time Complexity: O(n + k), where is the range of the input elements.

def counting_sort(arr):
max_val = max(arr)
count = [0] * (max_val + 1)
output = [0] * len(arr)

for num in arr:

count[num] += 1

for i in range(1, len(count)):

count[i] += count[i - 1]

for num in reversed(arr):

output[count[num] - 1] = num
count[num] -= 1

return output

# Example usage
arr = [4, 2, 2, 8, 3, 3, 1]
print("Counting Sorted Array:", counting_sort(arr))

---
Comparison of Sorting Algorithms:

---

Python Built-in Sorting Functions:

1. sorted(): Returns a new sorted list from the elements of any iterable.

arr = [5, 2, 9, 1, 5, 6]
sorted_arr = sorted(arr)
print(sorted_arr) # Output: [1, 2, 5, 5, 6, 9]

2. .sort(): Sorts a list in place and modifies the original list.

arr = [5, 2, 9, 1, 5, 6]
arr.sort()
print(arr) # Output: [1, 2, 5, 5, 6, 9]

---

Conclusion:

Simple Algorithms: Bubble, Selection, and Insertion Sort are easy to implement but not very efficient for
large datasets (O(n²)).

Efficient Algorithms: Merge Sort, Quick Sort, and Heap Sort offer better performance (O(n log n)).

Python's Built-in Sorting: Tim Sort is used by Python’s sorted() and .sort() for efficient sorting in real-world
scenarios.

For most use cases, Python’s built-in sorted() is the best choice due to its hybrid nature and optimization for
real-world data