Algorithms on maladroit.dev

Binary search

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

Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.

You must write an algorithm with O(log n) runtime complexity.

Method

Iterate over array and change the start/end to be the mid point

Solution

go

func search(nums []int, target int) int {
	start, end := 0, len(nums) - 1
	var mid int
	for start <= end {
		mid = (end + start) / 2
		if nums[mid] < target {
			start = mid + 1
		} else if nums[mid] > target {
			end = mid - 1
		} else {
			return mid
		}
	}
	return -1
}

References

Breadth first search

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

Breadth-first search is a graph traversal algorithm that starts at a node and travels to all other nodes at the current depth before moving further into the graph. queue are a good data structure for tracking of the nodes that have been encountered, but not traversed.

ℹ️ Note

It is important to use a double-ended queue (not an array) due to the time complexity of dequeuing.

Implementations

go

var (
	directions = [][]int{
 {0, 1}, {0, -1}, {1, 0}, {-1, 0}
 }
)

type graph struct {
	nodes [][]int
	rows int
	cols int
}

func NewGraph(x, y int) *graph {
	g := &graph{
		nodes: make([][]int, x),
		rows: x,
		cols: y,
	}
	for i := range g.nodes {
		g.nodes[i] = make([]int, y)
	}
	return g
}

func (g *graph) bfs(startX, startY int) {
	if len(g.nodes) <= 0 {
		return
	}
	visited := make([][]bool, g.rows)
	for i := range visited {
		visited[i] = make([]bool, g.cols)
	}

	queue := [][2]int{}
	g.bfsTraverse(startX, startY, visited, queue)
}

func (g *graph) bfsTraverse(
	x, y int,
	visited [][]bool,
	queue [][2]int,
) {
	queue = append(queue, [2]int{x, y})
	for len(queue) > 0 {
		i, j := queue[0][0], queue[0][1]
		queue = queue[1:]
		if visited[i][j] == true {
			continue
		}
		visited[i][j] = true
		fmt.Printf("visited: %v, %v\n", i, j)
		for _, direction := range directions {
			nextI, nextJ := i+direction[0], j+direction[1]
			if nextI < 0 || nextI >= g.rows {
				continue
			}
			if nextJ < 0 || nextJ >= g.cols {
				continue
			}
			queue = append(queue, [2]int{nextI, nextJ})
		}
	}
}

References

Constant time functions

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

$$f(n)=1$$

Constant functions are the fastest function classes when describing an algorithm

References

The Algorithm Design Manual

Cubic Time Functions

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

f(n)=n^3

Cubic functions describe algorithms that examine all triples

References

The-Algorithm-Design-Manual

Depth first search

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

Depth first search is a graph traversal algorithm that travels as far as possible along edges before it backtracks. This is typically accomplished using a Stack to keep track of the nodes on the current path. This could be an implicit stack through using recursion or a literal stack data structure.

Example

go

var (
	directions = [][]int{
 {0, 1}, {0, -1}, {1, 0}, {-1, 0}
 }
)

type graph struct {
	nodes [][]int
	rows int
	cols int
}

func NewGraph(x, y int) *graph {
	g := &graph{
		nodes: make([][]int, x),
		rows: x,
		cols: y,
	}
	for i := range g.nodes {
		g.nodes[i] = make([]int, y)
	}
	return g
}

func (g *graph) dfs(startX, startY int) {
	if len(g.nodes) <= 0 {
		return
	}
	visited := make([][]bool, g.rows)
	for i := range visited {
		visited[i] = make([]bool, g.cols)
	}
	g.dfsTraverse(startX, startY, visited)
}

func (g *graph) dfsTraverse(i, j int, visited [][]bool) {
	if visited[i][j] == true {
		return
	}
	visited[i][j] = true
	fmt.Printf("visited: %v, %v\n", i, j)
	for _, direction := range directions {
		nextI, nextJ := i+direction[0], j+direction[1]
		if nextI < 0 || nextI >= g.rows {
			continue
		}
		if nextJ < 0 || nextJ >= g.cols {
			continue
		}
		g.dfsTraverse(nextI, nextJ, visited)
	}
}

References

Dynamic programming

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

Dynamic programming is a technique for efficiently implementing a recursive algorithm by storing partial results. This is helpful because it allows for an exhaustive search without processing the same partial result over and over. It is important to know that this is a trade off of time complexity for space.

Examples

go

Before

func fib(n int) int{
	if n == 0 {
		return 0
	}
	if n == 1 {
		return 1
	}
	return fib(n-2) + fib(n-1)
}

After

const (
	miss = -1
	maxN = 92
)

var(
	cache = make([]int, maxN)
)

func fibDriver(n int) int{
	for i := range cache {
		cache[i] = miss
	}
	cache[0] = 0
	cache[1] = 1
	return fib(n)
}

func fib(n int){
	if cache[n] == miss {
		cache[n] = fib(n-2) + fib(n-1)
	}
	return cache[n]
}

References

Exponential time functions

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

f(n)=c^n

Exponential functions describe algorithms when iterating over all subsets of n items

References

The-Algorithm-Design-Manual

Factorial time functions

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

f(n)=n!

Factorial functions exist when generating all permutations or orderings of n items

References

The-Algorithm-Design-Manual

KMP

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

Knuth-Morris-Pratt (KMP) is an algorithm for pattern matching in a string similar to the Sliding-window technique. The primary difference in KMP is that the algorithm does not backtrack on the text string and instead creates a lookup up index in the pattern string.

To accomplish this, a prefix look up table is generated where all the sub-strings in the pattern string that match the largest repeating prefix are given index values. This index value is used as a point of reference for where to backtrack in the pattern string when a match is not found. This allows pattern matching without the need to back track in the text string.

Linear time functions

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

f(n)=n

Linear functions describe algorithms that need look at everything once such as a for loop.

References

The-Algorithm-Design-Manual

Logarithmic time functions

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

f(n)=log(n)

Logarithmic functions grow very slowly as n gets large, but not as slow as Constant-functions

References

The-Algorithm-Design-Manual

Quadratic time functions

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

f(n)=n^2

Quadratic functions describe algorithms that require examining all pairs of elements.

References

The-Algorithm-Design-Manual

Rabin-Karp

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

The Rabin-Karp algorithm is a method of finding all occurrences of a sub-string in a given string. The naive approach to this solution would be to use the Sliding-window technique. Rabin-Karp has a similar approach, but instead of comparing the window to the sub-string, it instead compares hash values using a rolling hash function.

Complexity

It has an average/best case time complexity of O(n+m) and a worse case time complexity of O(n * m). The worst case would occur if all the calculated hash values of the text were the same as the calculated hash of the pattern. It has auxiliary complexity of O(1).

Recursion

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

Recursion is a problem solving strategy that involves breaking a problem down into smaller and smaller pieces and using those solutions collectively to find the original solution. All recursive functions have at least these two parts:

A base case where the recursion stops
Breaking the problem down and calling the function recursively

Techniques

Memoization

Some recursive functions may end up calling the same function multiple times. When possible, store the results of previously calculated functions and re-use the to improve efficiency.

Sliding window

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

Sliding window is a technique that accomplishes what would normally taking multiple iterations in a single iteration. The technique can be applied when given a window of a known size, finding the result for the first window, and then shifting the window to the next position in the array or string.

Common use cases

largest sum
min/max sum
sub array/string

Examples

python

def slidingWindow(arr, windowSize):
	arrLen = len(arr)
	# outer loop needs to account for to avoid out of bounds
	for i in range(arrLen - windowSize + 1):
		# inner loop only needs to iterate over the window
		for j in range(windowSize)
			# operation inside the window
	return result

go

func slidingWindow(arr []int, windowSize int) int {
	arrLen := len(arr)
	// outer loop needs to account for to avoid out of bounds
	for i := 0; i < (arrLen - windowSize + 1); i++{
		// inner loop only needs to iterate over the window
		for j := 0; j < windowSize; j++ {
			// operation inside the window
		}
	}
	return result
}

Sorting and searching

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

Sorting is the act of rearranging a sequence in some known order such as numerical or lexicographical that is either ascending or descending. Sorting arrays are valuable as they enable binary searching which is faster than linear time.

Complexity

Sorting

Algorithm	Time	Space
Bubble sort	O(n^2)	O(1)
Insertion sort	O(n^2)	O(1)
Selection sort	O(n^2)	O(1)
Quicksort	O(n log(n))	O(log(n))
Mergesort	O(n log(n))	O(n)
Heapsort	O(n log(n))	O(1)
Counting sort	O(n + k)	O(k)
Radix sort	O(nk)	O(n + k)

Searching

Algorithm	Time
Binary search	O(log(n))

Edge cases

Empty sequence
Sequence with one element
Sequence with two elements
Sequence with duplicate elements

References

Tech-Interview-Handbook

Super-linear time functions

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

f(n)=n*log(n)

Functions that are super-linear grow slightly faster than linear, but not by much.

References

The-Algorithm-Design-Manual

Topological sort

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

A topological sort is a linear ordering of a directed graph. The ordering works similarly to Depth-first-search, but the nodes are considered “visited” when all of it’s dependencies are visited. This is an algorithm that is commonly used for discovering dependencies or prerequisites between nodes.

Examples

go

type graph struct {
	nodes []*node
}

type node struct {
	name string
	edges []*node
}

func NewGraph() *graph {
	return &graph{nodes: []*node{}}
}

func NewNode(name string) *node {
	return &node{name: name, edges: []*node{}}
}

func (g *graph) AddNode(n *node) {
	g.nodes = append(g.nodes, n)
}

func (n *node) AddEdge(e *node) {
	n.edges = append(n.edges, e)
}

func (g *graph) TopologicalSort() {
	if len(g.nodes) <= 0 {
		return
	}
	visited := map[*node]bool{}
	stack := []*node{}
	for _, node := range g.nodes {
		if visited[node] == false {
			stack = g.tsTraverse(node, visited, stack)
		}
	}
	for _, n := range stack {
		fmt.Println(n.name)
	}
}

func (g *graph) tsTraverse(
	node *node,
	visited map[*node]bool,
	stack []*node,
) []*node {
	visited[node] = true
	for _, edge := range node.edges {
		if visited[edge] == false {
			stack = g.tsTraverse(edge, visited, stack)
		}
	}
	return append(stack, node)
}

References

Traverse from right

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

Occasionally it can be effect to traverse an array from right to left instead of left to right.

Two pointers

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

The two pointers technique is a generalization of the Sliding-window technique. The primary difference is that the two pointers can cross over one another and could reference different arrays.

Common use cases

Palindromic sub-strings
Sorting colors
Merging sorted arrays