Channi Studies

Ordinary Least Squares (OLS)

Chan Lee — Sat, 18 Oct 2025 06:18:18 +0900

Since I've started to use Obsidian for summarizing my leranings, I will upload the PDF of the note in this blog from now on.

Open in new tab

[Java] Stack with IntNode, two-stack reverse trick

Chan Lee — Mon, 8 Sep 2025 06:18:07 +0900

Let's try implementing a Stack in Java using IntNode.

The structure of IntNode looks like this:

private static class IntNode() {
    int val;
    IntNode next;
    
    IntNode(int val, IntNode next) {
    	this.val = val;
        this.next = next;
    }
}

We're going to put this private static IntNode class into the Stack class.

We call it nested classes, and there are times when we should declare it as a static or non-static.

Static vs. Non-Static

Static variables in Java is a variable that is shared across all objects of a same class.

Similarly, static method is a method shared among all objects, and are expected to approach via the Class name. (e.g. Car.getFaster(car1, car2) rather than Ford.getFaster(Tesla, Toyota))

However, static class is a little different.

We declare an inner class static when the inner class has an independent meaning, and non-static otherwise.

If the nexted inner class NEVER uses any instance variables or methods of the outer class, declare it static.

One analogy is a Car class.

There are distinct car parts for each car objects, such as wheel, window, engine, etc.

Those are parts of a car, unliked IntNodes in a Stack.

IntNode, which carry its integer value and pointer to next IntNode, has an independent meaning regardless of Stack.

IntNode is just a data container, it has no reason to be a part of a specific Stack instance (it's just one element.)

In contrast, whell, window, etc are a PART of a car.

Understanding this, we can continue implementing Stack class with static inner IntNode class.

public class Stack {
    // Stack is Last In First Out
    private static class IntNode {
        int val;
        IntNode next;

        IntNode(int val, IntNode next) {
            this.val = val;
            this.next = next;
        }
    }

    private int size;
    // sentinel.next will work as the 'real' head node
    private IntNode sentinel;

    // Constructor with no value
    public Stack() {
        sentinel = new IntNode(0, null);
        size = 0;
    }

    // Constructor with 1 value
    public Stack(int val) {
        sentinel = new IntNode(0, null);
        sentinel.next = new IntNode(val, null);
        size = 1;
    }

    /**
     * Puts x on top of the stack.
     * Constant runtime.
     */
    public void push(int x) {
        sentinel.next = new IntNode(x, sentinel.next);
        size += 1;
    }

    /**
     * Removes and returns the top item of the stack.
     * Constant runtime.
     */
    public int pop() {
        int returnVal = sentinel.next.val;
        sentinel.next = sentinel.next.next;
        size -= 1;

        return returnVal;
    }

    /**
     * Returns the number of items on the stack.
     * Constant runtime.
     */
    public int size() {
        return size;
    }

    /**
     * Compute the sum of the numbers of the stack.
     * No runtime restrictions.
     */
    public int sum() {
        IntNode currentNode = sentinel.next;
        int result = 0;

        while (currentNode != null) {
            result += currentNode.val;
            currentNode = currentNode.next;
        }

        return result;
    }
}

We're using sentinel private class variable as the head node.

So the 'real' head node is at sentinel.next.

Now, say we want to implement a function that takes a single Stack, returning a reversed Stack, but in a different package. Since we declared all of the instance variables as private, we must use public methods to implement it.

public class StackClient {
    /**
     * Approach:
     * Repeatedly .pop values from s, put into new Stack and return it until size is 0.
     */
    public static Stack flipped(Stack s) {
        Stack newStack = new Stack();

        while (s.size() != 0) {
            int val = s.pop();
            newStack.push(val);
        }

        return newStack;
    }
}

It works as intended, but it destroys the original stack by repeatedly calling s.pop().

If we could approach IntNode.next, we could make it non-destructive..

But we could fix the code slightly in order to keep the original Stack AND return the new one.

public class StackClient {
    /**
     * Approach:
     * Repeatedly pop values from s, put into new Stack and return it until size is 0.
     */
    public static Stack flipped(Stack s) {
        Stack newStack = new Stack();
        Stack temp = new Stack();

        // 1. Make two reversed Stack, newStack and temp
        // s becomes empty stack after this
        while (s.size() != 0) {
            int val = s.pop();
            newStack.push(val);
            temp.push(val);
        }

        // 2. Reverse the temp Stack, and save to s
        while (temp.size() != 0) {
            int val = temp.pop();
            s.push(val);
        }
        
        return newStack;
    }
}

With this implementation, we could maintain the structure of the original Stack AND return the new reversed Stack.

[Numpy] Numpy Basics (.ipynb)

Chan Lee — Mon, 1 Sep 2025 04:49:54 +0900

numpy.ipynb

0.06MB

This Jupyter Notebook file tells you about the numpy array (numpy.ndarray) basics.

Creating different shaped array, reshaping, random array, array indexing, etc.

[Java] Generic Types of List

Chan Lee — Sun, 31 Aug 2025 04:46:09 +0900

To create an ArrayList (or LinkedList) in Java, you can do as following:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List myList = new ArrayList();

        myList.add(10);
        myList.add("Go");
        myList.add(false);

        System.out.println(myList); // [10, Go, false]
    }
}

If we do not specify the type of the elements in the List, we can put different types in the List like we did in Python.

Since we can put whatever we want, possible runtime errors can occur dealing with types.

However, there are multiple reasons why we use generics specified within angle brackets (or diamond operator, <>)

One problem that might arise in such situation is incompatible type error when assigning an element to

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List myList = new ArrayList();

        myList.add(10);
        myList.add("Go");
        myList.add(false);

        int firstNum = myList.get(0); // Compile Error
        // java: incompatible types: java.lang.Object cannot be converted to int
    }
}

This error occurs same for "Go" and false. Why does this happen?

It happens because we didn't specified generic type of the List, resulting EVERY elements getting returned to have Object (java.util.Object) type, which is the superclass of every class in Java.

In other words, ANY classes that you define automatically inherits from java.util.Object class.

Since the generic type hasn't provided, Java returns every object in Object type.

Although specifying type is safer, we can still use the code if we add type casting.

Object type will be converted to our desired types with appropriate type casting.

For example:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List myList = new ArrayList();

        myList.add(10);
        myList.add("Go");
        myList.add(false);

        int firstNum = (Integer) myList.get(0);
        String secondStr = (String) myList.get(1);
        boolean thirdBool = (boolean) myList.get(2);

        System.out.println(firstNum + ", " + secondStr + ", " + thirdBool);
    }
}

Now, there is another weird problem when you try to make a List of integers. (with generics)

My compiler shows "Type argument cannot be of a primitive type" on integer.

Like other programming languages, Java have some primitive types–byte, short, int, long, float, double, boolean, and char.

Those primitive types are NOT objects, while generic system requires objects. So you must only put objects inside the diamond operator (<>).

Then, what should we do in such situation? There are something called wrapper class corresponding to each data type.

Ex) int → Integer, double → Double, boolean → Boolean, etc

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> myList = new ArrayList<>();
        List<Double> secondList = new LinkedList<>();

        myList.add(1);
        myList.add(2);
        myList.add(3);
        System.out.println(myList);

        secondList.add(2.0);
        secondList.add(2.5);
        secondList.add(-3.141592);
        System.out.println(secondList);
    }
}

Result

Data Science case study - Systematic Racial Discrimination in Tax Audit

Chan Lee — Sat, 30 Aug 2025 07:52:47 +0900

Let's go through a case study of data science to understand what is it about.

Black Americans Are Much More Likely to Face Tax Audits, Study Finds (Published 2023)

A new report documents systemic discrimination in how the I.R.S. selects taxpayers to be audited, with implications for a debate on the agency’s funding.

www.nytimes.com

New York times reported said that the IRS seems to be exhibiting systemic discrimination regarding tax audit (세무 조사) somehow. (Jan, 2023)

However, the mystery is that tax payers never report their race to IRS in any way. Race is not reported anywhere in tax return.

Then how can this happen?

Initial Research Question

What are audit rates of Black and non-Black taxpayers?

X% of tax returns of Black taxpayers were audited.

Y% of tax returns of non-Black taxpayers were audited.

Q. Human Context: What does this comparison matter? What is implied by X ≠ Y?

Q. Core Component of DS: Calculations across groups. (simple for this example, but require multiple analyses for larger data)

Q. How do we know who was audited?

A. Data obtained from IRS. Obtained from partnership between researchers and the IRS.

How do we determine the race of each taxpayer? We can't.

Could we make an informed prediction of taxpayer's race?

There is a difference in preference in their baby names in each race. Also, there is a difference in demographics for differenct cities. (more than 30% in SF, less than 20% in NY)

Drawing on external datasets, researchers estimated the probability that a taxpayer with a particular location + name identifies as Black.

Then the result graph showing the audit rate against estimated probability of identifying as Black shows a strong pattern.

Taxpayers with a higher estimated probability of identifying as Black were more likely to be audited.

Now, plotting it against reported income and divide into two groups–identifying as Black and Non-Black–shows stark difference.

Remembering IRS doesn't collect racial data, what are some possible reasons for this disparity?

Neighborhood? Address? Geography?

Identifying a Potential Root Cause

Taxpayers goes through a "black-box" algorithm that predicts the likelyhood that somebody has an error in their tax returns.

This algorithm seems to have prioritized catching errors in claimed tax credits over catching errors that, if addressed, would recover the most money.

Black taxpayers were more likely to file the kinds of returns targeted by the algorithm. Thus, audit rates of Black taxpayers were higher.

9 months after the original report was released, I.R.S. started to work on this to minimize the racial discrimination in tax audits.

이러한 시스템적 인종 차별은 회계 감사의 대상 중 많은 양을 차지하는 것이 Earned Income Tax Credit (EITC) 신청이고, EITC는 중저소득층 계열에서 가장 큰 혜택을 볼 수 있기 때문이다. 중저소득층 (~$20,000)에 타 구간과 비교하여 확연히 많은 EITC 신청이 존재하며, 심지어 최대 혜택을 받을 수 있는 구간이기에 더욱 감사 비율이 높은 것으로 추정된다.

이것이 흑인 대상 감사 비율이 높은 이유를 설명하는 이유는, 미국 사회의 인종별 소득 수준에는 인종간 차이가 존재하기 때문이다. 흑인의 평균 소득 수준이 전체 인종 그룹 중에서도 가장 낮기 때문에, EITC 신청의 비율 또한 가장 많고, 이것이 시스템적 인종 차별로 이어졌다는 추정이다.

nonlocal 변수

Chan Lee — Thu, 3 Jul 2025 12:22:47 +0900

Python 함수를 다룰 때에, nested function definition에서 inner function의 함수 프레임에서, 상위 프레임의 변수를 수정하려고 하면 오류가 발생합니다.

n을 함수 인자로 받아, n번 특정 문자를 출력해주는 또 다른 함수를 반환하는 print_n_times 함수에 대해서 알아보겠습니다.

def print_n_times(n):
    def a(word):
        times = n
        while times:
            print(word)
            times -= 1

    return a
    
print_n_times(2)("hey")

최초 인자로 전달된 n (2)를 times 라는 a 함수 내의 로컬 변수로 복사한 뒤, 해당 변수를 통해 while loop을 컨트롤 했습니다.

이와 같은 경우 의도된 대로 함수가 작동합니다.

하지만 만약 a 함수 내에서 times 로 복사하지 않고 n 을 직접 변경하고자 하면 어떤 일이 발생할까요?

def print_n_times(n):
    def a(word):
        while n:	# n 직접 접근
            print(word)
            n -= 1	# n 변경

    return a
    
print_n_times(2)("hey")

인자 n에 대한 접근 권한은 최소 print_n_times 함수 또는 그 이상, 우리의 경우 글로벌 프레임에서만 가능합니다.

이 점은 파이썬이 그렇게 디자인 되었기 때문이고 다른 언어에서는 또 다르게 작동할 수 있습니다.

그렇다면 만약 의도적으로 상위 프레임의 인자를 변경하고자 한다면 어떻게 해야 할까요?

def print_n_times(n):
    def a(word):
        nonlocal n	# 추가
        while n:
            print(word)
            n -= 1

    return a


print_n_times(2)("hey")

사용하고자 하는 하위 프레임 내에서 상위 프레임의 변수를 nonlocal로 지정하면 기존처럼 활용할 수 있습니다.

하지만, 안전하고 유지보수가 쉬운 코드를 디자인하기 위해서는 되도록이면 전달된 인자를 직접 사용하는 것 보다는 추가적 변수로 복사를 하고 해당 변수를 활용하는 것이 권장됩니다.

특정 경우에서는 직접적으로 변경하는 것이 요구될 수 있기 때문에, 숙지해 두면 좋겠습니다.

[Data Structure] Graph: Topological Sort

Chan Lee — Wed, 28 May 2025 05:02:20 +0900

A topological sort of a directed, acyclic graph produces a list of graph's vertices such that for every edge from a vertex X to a vertex Y, X comes before Y in the list.

There can be more than one valid topoligcal sort. Again, the graph must be acyclic and riected in order to apply topological sorting.

The time complexity and space complexity of topological sorting is O(|V| + |E|).

[Python] Bellman-Ford's Shortest Path

Chan Lee — Wed, 28 May 2025 03:45:33 +0900

The Bellman-Ford shortest path algorithm, created by Richard Bellman and Lester Ford, Jr,. determines the shortest path from a start vertex to each vertex in a graph.

For each vertex, the Bellman-Ford algorithm determines the vertex's distance and predecessor pointer. A vertex's distance is the shortest path distance from the start vertex. A vertex's predecessor pointer points to the previous vertex along the shortest path from the start vertex.

The Bellman-Ford algorithm initializes all vertices' current distances to infinity (∞) and predecessors to null, and assigns the start vertex with a distance of 0. The algorithm performs V-1 main iterations, visiting all vertices in the graph during each iteration. Each time a vertex is visited, the algorithm follows all edges to adjacent vertices. For each adjacent vertex, the algorithm computes the distance of the path from the start vertex to the current vertex and continuing on to the adjacent vertex. If that path's distance is shorter than the adjacent vertex's current distance, a shorter path has been found. The adjacent vertex's current distance is updated to the newly found shorter path's distance, and the vertex's predecessor pointer is pointed to the current vertex.

The Bellman-Ford algorithm does not require a specific order for visiting vertices during each main iteration. So after each iteration, a vertex's current distance and predecessor may not yet be the shortest path from the start vertex. The shortest path may propagate to only one vertex each iteration, requiring V-1 iterations to propagate from the start vertex to all other vertices

// Pseudocode
BellmanFord(startV) {
   for each vertex currentV in graph {
      currentV⇢distance = Infinity
      currentV⇢predV = null
   }

   // startV has a distance of 0 from itself
   startV⇢distance = 0                

   for i = 1 to number of vertices - 1 { // Main iterations
      for each vertex currentV in graph {
         for each vertex adjV adjacent to currentV {
            edgeWeight = weight of edge from currentV to adjV
            alternativePathDistance = currentV⇢distance + edgeWeight
                  
            // If shorter path from startV to adjV is found,
            // update adjV's distance and predecessor
            if (alternativePathDistance < adjV⇢distance) {
               adjV⇢distance = alternativePathDistance
               adjV⇢predV = currentV
            }
         }
      }
   }

   // Check for a negative edge weight cycle
   for each vertex currentV in graph {
      for each vertex adjV adjacent to currentV {
         edgeWeight = weight of edge from currentV to adjV
         alternativePathDistance = currentV⇢distance + edgeWeight

         // If shorter path from startV to adjV is still found,
         // a negative edge weight cycle exists
         if (alternativePathDistance < adjV⇢distance) {
            return false
         }
      }
   }

   return true
}

The Bellman-Ford algorithm supports graphs with negative edge weights. However, if a negative edge weight exists, there is no shortest path.

한글로 정리하자면

1. 모든 Vertex (Node) 들의 distance를 ∞, predecessor node를 null로 초기화한다.

2. 시작 vertex (startV)의 distance를 0으로 설정한다.

3. V 개의 Vertex를 가진 Graph는 (V - 1) 번의 Main iteration (foor loop)이 존재한다.

4. 각 Main iteration에서 모든 vertex를 방문하고 (현재 방문한 vertex를 currentV 라고 할때) 다음과 같은 절차를 따른다:

distance 계산
distance = (현재 방문한 currentV의 distance) + (계산하고자 하는 adjacnet vertex 까지의 path weight)
Ex. A (distance 10) →(weight 3)→ B 이면, B의 distance는 10 + 3 = 13
계산된 distance가 adjacent vertex의 distance 값보다 높다면 이를 업데이트한다.

5. 위 알고리즘을 V - 1회 반복 시 각 node의 distance가 starting vertex 부터의 거리, predecessor pointer가 최단거리 path를 나타낸다.

## Python Implementation

def bellman_ford(graph, start_vertex):
    # Initialize all vertex distances to infinity and
    # and predecessor vertices to None.
    for current_vertex in graph.adjacency_list:
      current_vertex.distance = float('inf') # Infinity
      current_vertex.pred_vertex = None

    # start_vertex has a distance of 0 from itself
    start_vertex.distance = 0                

    # Main loop is executed |V|-1 times to guarantee minimum distances.
    for i in range(len(graph.adjacency_list)-1):
        # The main loop.
        for current_vertex in graph.adjacency_list:
            for adj_vertex in graph.adjacency_list[current_vertex]:
                edge_weight = graph.edge_weights[(current_vertex, adj_vertex)]
                alternative_path_distance = current_vertex.distance + edge_weight
                      
                # If shorter path from start_vertex to adj_vertex is found,
                # update adj_vertex's distance and predecessor
                if alternative_path_distance < adj_vertex.distance:
                   adj_vertex.distance = alternative_path_distance
                   adj_vertex.pred_vertex = current_vertex

    # Check for a negative edge weight cycle
    for current_vertex in graph.adjacency_list:
        for adj_vertex in graph.adjacency_list[current_vertex]:
             edge_weight = graph.edge_weights[(current_vertex, adj_vertex)]
             alternative_path_distance = current_vertex.distance + edge_weight

             # If shorter path from start_vertex to adj_vertex is still found,
             # a negative edge weight cycle exists
             if alternative_path_distance < adj_vertex.distance:
                return False

    return True

[Python] Dijkstra's Shortest Path | 다익스트라 최단거리

Chan Lee — Tue, 27 May 2025 08:33:15 +0900

Finding the shortest path between vertices in a graph has many applications.

Dijkstra's shortest path algorithm, created by Edsger Dijkstra, determines the shortest path from a start vertex to each vertex in a graph. For each vertex, Dijkstra's algorithm determines the vertex's distance and predecessor pointer.

A vertex's distance is the shortest path distance from the start vertex. A vertex's predecessor pointer points to the previous vertex along the shortest path from the start vertex.

Dijkstra's algorithm initializes all vertices' distances to infinity (∞), initializes all vertices' predecessors to null, and enqueues all vertices into a queue of unvisited vertices. The algorithm then assigns the start vertex's distance with 0. While the queue is not empty, the algorithm dequeues the vertex with the shortest distance. For each adjacent vertex, the algorithm computes the distance of the path from the start vertex to the current vertex and continuing on to the adjacent vertex. If that path's distance is shorter than the adjacent vertex's current distance, a shorter path has been found. The adjacent vertex's current distance is updated to the distance of the newly found shorter path's distance, and vertex's predecessor pointer is pointed to the current vertex.

To perfrom Dijkstra's algorithm, the Graph and Vertex classes are used. The Vertex class is extended to include two additional data members:

- distance: The total sum of the edge weights on a path from some start vertex to the vertex.

- pred_vertex: A reference to the vertex that occurs immediately before the vertex, on a path from some start vertex to the vertex.

def dijkstra_shortest_path(g, start_vertex):
    # Put all vertices in an unvisited queue.
    unvisited_queue = []
    for current_vertex in g.adjacency_list:
        unvisited_queue.append(current_vertex)

    # start_vertex has a distance of 0 from itself
    start_vertex.distance = 0

    # One vertex is removed with each iteration; repeat until the list is
    # empty.
    while len(unvisited_queue) > 0:
        
        # Visit vertex with minimum distance from start_vertex
        smallest_index = 0
        for i in range(1, len(unvisited_queue)):
            if unvisited_queue[i].distance < unvisited_queue[smallest_index].distance:
                smallest_index = i
        current_vertex = unvisited_queue.pop(smallest_index)

        # Check potential path lengths from the current vertex to all neighbors.
        for adj_vertex in g.adjacency_list[current_vertex]:
            edge_weight = g.edge_weights[(current_vertex, adj_vertex)]
            alternative_path_distance = current_vertex.distance + edge_weight
                  
            # If shorter path from start_vertex to adj_vertex is found,
            # update adj_vertex's distance and predecessor
            if alternative_path_distance < adj_vertex.distance:
                adj_vertex.distance = alternative_path_distance
                adj_vertex.pred_vertex = current_vertex


def get_shortest_path(start_vertex, end_vertex):
    # Start from end_vertex and build the path backwards.
    path = ''
    current_vertex = end_vertex
    while current_vertex is not start_vertex:
        path = ' -> ' + str(current_vertex.label) + path
        current_vertex = current_vertex.pred_vertex
    path = start_vertex.label + path
    return path

[Data Structure] Python: Graphs

Chan Lee — Tue, 27 May 2025 08:13:47 +0900

Vertex and Graph Class

The Graph class holds a vertex adjacency list using a dictionary that maps a Vertex object to a list of aadjacent Vertex objects.

The Vertex class contains a label, but can be augmented by graph algorithms to contain additional data if required.

A Graph object is initialized with an empty adjacency list. Vertex objects are created and added to the Graph using the add_vertex() method.

class Vertex:
    def __init__(self, label):
        self.label = label
        
class Graph:
    def __init__(self):
        self.adjacency_list = {}
  
    def add_vertex(self, new_vertex):
        self.adjacency_list[new_vertex] = []
        
# Program to create and populate a Graph object.
g = Graph()
vertex_a = Vertex("New York")
vertex_b = Vertex("Tokyo")
vertex_c = Vertex("London")

g.add_vertex(vertex_a)
g.add_vertex(vertex_b)
g.add_vertex(vertex_c)

Graph Edges and Edge Weights

Edges are represented as vertex pairs, using a 2-item tuple.
Ex: (vertex_a, vertex_b) is an edge that goes from vertex_a to vertex_b.

Undirected edges are two symmetric vertex pairs: (vertex_a, vertex_b) and (vertex_b, vertex_a).

Edges also have numeric weights.

By default, an edge is assigned with weight 1.0. Edge weights are stored in the dictionary edge_weights where the vertex pair is the key and the edge weight is the value.

class Graph:
    def __init__(self):
        self.adjacency_list = {}
        self.edge_weights = {}
        
    def add_vertex(self, new_vertex):
        self.adjacency_list[new_vertex] = []
        
    def add_directed_edge(self, from_vertex, to_vertex, weight = 1.0):
        self.edge_weights[(from_vertex, to_vertex)] = weight
        self.adjacency_list[from_vertex].append(to_vertex)
        
    def add_undirected_edge(self, vertex_a, vertex_b, weight = 1.0):
        self.add_directed_edge(vertex_a, vertex_b, weight)
        self.add_directed_edge(vertex_b, vertex_a, weight)

Python: Breadth-First Search

Breadth-first search traverses a graph by starting at a specific vertex and visiting the vertex's adjacent vertices before visiting the next closest vertices. No vertex is re-visited.

# Breadth-first search function
def breadth_first_search(graph, start_vertex, distances=dict()):
    discovered_set = set()
    frontier_queue = Queue()
    visited_list = []
    
    # start_vertex has a distance of 0 from itself
    distances[start_vertex] = 0

    frontier_queue.enqueue(start_vertex) # Enqueue start_vertex in frontier_queue
    discovered_set.add(start_vertex)     # Add start_vertex to discovered_set

    while (frontier_queue.list.head != None):
        current_vertex = frontier_queue.dequeue()
        visited_list.append(current_vertex)
        for adjacent_vertex in graph.adjacency_list[current_vertex]:
            if adjacent_vertex not in discovered_set:
                frontier_queue.enqueue(adjacent_vertex)
                discovered_set.add(adjacent_vertex)
                
                # Distance of adjacent_vertex is 1 more than current_vertex
                distances[adjacent_vertex] = distances[current_vertex] + 1
    return visited_list

Python: Depth-First Search

Depth-first search traverses a graph by first visiting a specific starting vertex, and then visiting every vertex along each path originating from the starting vertex. Each path is traversed to the path's end before backtracking.

# Depth-first search function
def depth_first_search(graph, start_vertex, visit_function):
    vertex_stack = [start_vertex]
    visited_set = set()

    while len(vertex_stack) > 0:
        current_vertex = vertex_stack.pop()
        if current_vertex not in visited_set:
            visit_function(current_vertex)
            visited_set.add(current_vertex)
            for adjacent_vertex in graph.adjacency_list[current_vertex]:
                vertex_stack.append(adjacent_vertex)