Algorithms on When Moore's Law Ends

Boyer-Moore Voting Algorithm

Mon, 01 Jan 0001 00:00:00 +0000

#note #learn-with-chatgpt #algorithm

NOTE: this is a note from ChatGPT

The Boyer-Moore Voting Algorithm, also known simply as the Voting Algorithm, is a method for finding a majority element in a sequence of elements. This means it’s useful for determining if there’s an element in the sequence that appears more than n/2 times, where n is the number of elements in the sequence.

Here’s the basic idea:

Initialization: Start with an initial candidate and a count of 0.
Iteration: Go through the sequence element by element.

If the count is 0, set the current element as the candidate.
If the current element is the same as the current candidate, increment the count.
Otherwise, decrement the count.

Validation: The candidate at the end of the iteration is the potential majority element. However, one additional pass through the sequence is required to confirm if it is indeed the majority element.

The intuition behind this algorithm is that if there’s a majority element, it will outvote every other element combined.

Python `heapq` Priority queue (heap queue)

Mon, 01 Jan 0001 00:00:00 +0000

Attributes#

“Min heap”, where index 0 is the smallest item

APIs#

heapq.heapify(iterable) -> None: Create a heap queue in-place
heapq.heappush(heap, item) -> None: Add a new item
heapq.heappop(heap) -> T: Pop the smallest item
heapq.heappushpop(heap, item) -> T: Push then pop the smallest
heapq.heapreplace(heap, item) -> T: Pop then push

Traverse a graph

Mon, 01 Jan 0001 00:00:00 +0000

Mark all nodes as not visited.
Create an empty ready bucket to hold nodes that has been visited itself but not its neighbors yet.
Find a starting node, mark it as visited and put into the ready bucket.
Get an node from the ready bucket and look at its directly connected neighbors. Skip those that are visited already, mark the rest as visited and put them into the ready bucket.
Repeat 4 until ready is empty.

Depends on how you operate ready bucket, you can achieve BFS (breadth first search) or DFS (depth first search).

Traverse a tree

Mon, 01 Jan 0001 00:00:00 +0000

DFS (depth first search)

DFS can be done easily with recursive method, because you can treat the subtrees as new trees and use the same function to traverse them.

BFS (breadth first search)

BFS will need extra space of a queue. When visiting a node, add all its children to this queue, before visiting its siblings by dequeue from the queue.