Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
3 views

Computer Science 301 - Data Structures and Algorithms - Lecture Notes

Uploaded by

nihed13535
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
3 views

Computer Science 301 - Data Structures and Algorithms - Lecture Notes

Uploaded by

nihed13535
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

CS301: Data Structures and Algorithms

Lecture Week 7: Graph Algorithms and Their Applications Professor Martinez - Fall 2024

I. Review of Graph Fundamentals


Today we continued our exploration of graph theory and its practical applications. Remember
that a graph G is defined by G = (V,E) where:

- V represents the set of vertices (nodes)


- E represents the set of edges (connections between nodes)

Types of Graphs Covered:


1. Undirected Graphs

- Edges have no direction


- If v1 is connected to v2, then v2 is connected to v1
- Example: Facebook's friendship network

2. Directed Graphs (Digraphs)

- Edges have direction


- If v1 points to v2, v2 may not point to v1
- Example: Twitter's follower network

II. Graph Representations


We discussed two primary ways to represent graphs in code:

1. Adjacency Matrix
# Example of an adjacency matrix

graph = [

[0, 1, 0, 1],

[1, 0, 1, 0],

[0, 1, 0, 1],
[1, 0, 1, 0]

Space Complexity: O(V²) Time Complexity for checking edge existence: O(1)

2. Adjacency List
# Example of an adjacency list

graph = {

'A': ['B', 'D'],

'B': ['A', 'C'],

'C': ['B', 'D'],

'D': ['A', 'C']

Space Complexity: O(V + E) Time Complexity for checking edge existence: O(V)

III. Graph Traversal Algorithms

Breadth-First Search (BFS)


Key Points:

- Uses a queue data structure


- Explores all neighbors at current depth before moving deeper
- Optimal for finding shortest paths in unweighted graphs

def bfs(graph, start):

visited = set()

queue = [start]

visited.add(start)
while queue:

vertex = queue.pop(0)

print(vertex, end=' ')

for neighbor in graph[vertex]:

if neighbor not in visited:

visited.add(neighbor)

queue.append(neighbor)

Depth-First Search (DFS)


Key Points:

- Uses a stack (or recursion)


- Explores as far as possible along each branch before backtracking
- Useful for topological sorting and cycle detection

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

if visited is None:

visited = set()

visited.add(start)

print(start, end=' ')

for neighbor in graph[start]:

if neighbor not in visited:


dfs(graph, neighbor, visited)

IV. Time Complexity Analysis


Important complexities to remember:

- BFS: O(V + E)
- DFS: O(V + E)
- Dijkstra's Algorithm: O((V + E) log V) with priority queue
- Floyd-Warshall: O(V³)

V. Practice Problems
1. Implement a function to detect cycles in a directed graph
2. Find the shortest path between two vertices using BFS
3. Determine if a graph is bipartite

VI. Homework Assignment


Due next week:

1. Implement both BFS and DFS for a graph represented as an adjacency matrix
2. Write a function to convert between adjacency matrix and adjacency list representations
3. Solve the "Number of Islands" problem on LeetCode (#200)

Important Dates
- Midterm Exam: October 15th
- Project Proposal Due: October 20th
- Final Project Presentations: December 5th

Remember: The key to understanding graph algorithms is practicing their implementation and
analyzing their behavior on different types of graphs.

Additional Resources
- Introduction to Algorithms (CLRS) - Chapter 22: Graph Algorithms
- Stanford's CS161 Course Notes
- Visualgo.net for algorithm visualization
- LeetCode's Graph Theory Problem Set
These notes were taken during lecture. Please refer to the course syllabus for official
assignment details and deadlines.

You might also like