It can be applied to both. Here is why:
An undirected graph is basically the same as a directed graph with bidirectional connections (= two connections in opposite directions) between the connected nodes.
So you don’t really have to do anything to make it work for an undirected graph. You only need to know all of the nodes that can be reached from every given node through e.g. an adjacency list.
Related Posts:
- Understanding Time complexity calculation for Dijkstra Algorithm
- Breadth First Search time complexity analysis
- Counting the sum of every nodes’ neighbors’ degrees?
- Difference and advantages between dijkstra & A star
- Bellman-Ford vs Dijkstra: Under what circumstances is Bellman-Ford better?
- In a triangulated isometric grid, what triangle is a given point in?
- What is a loop invariant?
- What is a loop invariant?
- What does O(log n) mean exactly?
- Dijkstra’s algorithm in python
- how to calculate binary search complexity
- Dijkstra’s algorithm in python
- When is it practical to use Depth-First Search (DFS) vs Breadth-First Search (BFS)? [closed]
- What does O(log n) mean exactly?
- What is Sliding Window Algorithm? Examples?
- Quicksort with Python
- What is the difference between tree depth and height?
- how to implement quick sort algorithm in C++
- Python: maximum recursion depth exceeded while calling a Python object
- Why is the time complexity of both DFS and BFS O( V + E )
- Time complexity of a Priority Queue in C++
- What is stability in sorting algorithms and why is it important?
- Time Complexity of the Kruskal Algorithm?
- Quick Sort Vs Merge Sort
- Polynomial time and exponential time
- Insertion Sort vs. Selection Sort
- Best Case for Bubble Sort
- How to find the kth smallest element in the union of two sorted arrays?
- Big O, how do you calculate/approximate it?
- Performing Breadth First Search recursively
- Is Quicksort in-place or not?
- longest increasing subsequence(O(nlogn))
- Why doesn’t Dijkstra’s algorithm work for negative weight edges?
- O(n log n) vs O(n) — practical differences in time complexity
- When should I use Kruskal as opposed to Prim (and vice versa)?
- Trying to understand max heapify
- Shortest possible depth of a leaf in decision tree (comparison sorting algorithm)
- Python Weighted Random [duplicate]
- What is the meaning of “exclusive” and “inclusive” when describing number ranges?
- What’s a good algorithm to generate a maze?
- Intuition for perceptron weight update rule
- Easy: Solve T(n)=T(n-1)+n by Iteration Method
- Good Java graph algorithm library?
- What is tail call optimization?
- PacMan: what kinds of heuristics are mainly used?
- Quicksort vs heapsort
- Big-oh vs big-theta
- Best case time complexity for selection sort
- Looking for algorithm finding euler path
- Trie complexity and searching
- What does this definition of contiguous subsequences mean?
- Is log(n!) = Θ(n·log(n))?
- Is complexity O(log(n)) equivalent to O(sqrt(n))?
- How to find maximum spanning tree?
- Exactly how many comparisons does merge sort make?
- Algorithm to return all combinations of k elements from n
- How to calculate big-theta
- What is the time complexity of while loops?
- Merge sort time and space complexity
- Intuitive explanation for why QuickSort is n log n?
- Calculate distance between two latitude-longitude points? (Haversine formula)
- Shuffle a deck of cards in Java
- How to calculate time complexity of backtracking algorithm?
- Median of Medians in Java
- What is a loop invariant?
- Hash table runtime complexity (insert, search and delete)
- Which is better: O(n log n) or O(n^2)
- What is O(log* N)?
- Quickselect time complexity explained
- What is the proper equivalent of “while(true)” in plain C?
- Asymptotic Notation – does n (log n) (log n) simplify?
- Difference between Big-O and Little-O Notation
- What is the big-O of the function (log n)^k
- How to calculate an angle from three points?
- Why is O(n) better than O( nlog(n) )?
- How to solve: T(n) = T(n/2) + T(n/4) + T(n/8) + (n)
- Is there an O(n) integer sorting algorithm?
- An example of Best Case Scenario for Quick Sort (Need someone to check if my answer is correct)
- how to write a recurrence relation for a given piece of code
- Why is merge sort worst case run time O (n log n)?
- Why is merge sort worst case run time O (n log n)?
- What is the time and space complexity of a breadth first and depth first tree traversal?
- Create your own MD5 collisions
- Image Segmentation using Mean Shift explained
- Finding the median of an unsorted array
- Difference between Big-Theta and Big O notation in simple language
- What is the difference between bucket sort and radix sort?
- How are the following functions O(N^3)?
- Difference between O(n) and O(log(n)) – which is better and what exactly is O(log(n))?
- Finding all possible combinations of numbers to reach a given sum
- Are there any real O(n^n) algorithms?
- Sorting an array in C?
- How to determine if a point is in a 2D triangle?
- Modular multiplicative inverse function in Python
- Minesweeper solving algorithm
- About bubble sort vs merge sort
- How do I check if an array includes a value in JavaScript?
- Finding the max/min value in an array of primitives using Java
- Rolling or sliding window iterator?
- How to create Gephi network graphs from Python?