Data-Structures on maladroit.dev

Array

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

Array

An array is a collection of items that are held in order at a specific index. They are useful for storing objects of the same type in a single variable and it is very quick to access elements if you have the index. It should also be said that adding or removing objects to the middle of an array can be a slow process.

Operation	Big-O	Note
Access	O(1)
Search	O(n)
Search (sorted)	O(log(n))
Insert/Remove	O(n)	requires shifting elements by 1
Insert/Remove (at end)	O(1)	special case where no shifting is required

Common edge cases

Empty sequence
Sequence with 1 or 2 elements
Sequence with repeated elements
Duplicate values in sequence

Techniques

Binary search tree

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

Binary-search-tree

A binary-search tree (BST) is a Binary-tree that gives all the elements in order when it is traversed in order. In-order traversal being:

Left -> Root -> Right

BSTs are useful because of their time complexity.

Operation	Big-O
Access	O(log(n))
Search	O(log(n))
Insert	O(log(n))
Remove	O(log(n))

The space complexity of traversing balanced trees is O(h) where h is the height of the tree.

References

Tech-Interview-Handbook

Binary Tree

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

Binary tree

A binary tree is a tree where each node has a max of two children. A complete binary tree is a binary tree where every level is completely filled. A balance binary tree is a binary tree where the right and left sub-trees of every node differ by no more than 1 level.

Traversals

Given the following binary tree:

flowchart TD
	1([1])
	2([2])
	7([7])
	6([6])
	5([5])
	11([11])
	9([9])
	9a([9])
	5a([5])
	1 --> 7
	7 --> 2
	7 --> 6
	6 --> 5
	6 --> 11
	1 --> 9
	9 --> 9a
	9a --> 5a

In-order traversal: Left -> Root -> Right
- 2, 7, 5, 6, 11, 1, 9, 5, 9
Pre-order traversal: Root -> Left -> Right
- 1, 7, 2, 6, 5, 11, 9, 9, 5
Post-order traversal: Left -> Right -> Root
- 2, 5, 11, 6, 7, 5, 9, 9, 1

References

Tech-Interview-Handbook

Data Structures

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

Data Structures

Graph

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

Graph

A graph is a collection of nodes that are connected to each other by edges. Edges can be either directed (one-way) or undirected and they can also have weights (values). A tree can be considered an undirected graph with no cycles.

Operation	Big-O
Depth-first search	O(N + E)
Breadth-first search	O(N + E)
Topological sort	O(N + E)

N being number of nodes and E being number of edges

Hash table

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

Hash table

A hash table is a data structure that can map keys to values using a hash function. It does this by computing an index using the hash function and stores the value in an array.

Operation	Big-O
Access	N/A
Search	O(1)
Insert	O(1)
Remove	O(1)

To be clear, the O(1) is average case as it depends on the underlying hash function, but in most instances it is safe to assume average case.

Heap

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

Heap

A heap is a Tree data structure that is complete, or every level is full.

Max heap: A heap where the value of the node is the greatest value in that node’s sub-tree. This must be true for all nodes in the heap
Min heap: A heap where the value of the node in the smallest value in that node’s sub-tree. This must be true for all nodes in the heap

Heaps can be valuable when it is necessary to remove nodes with either the highest or lowest priority or when inserts are mixed with removals of the root node.

Interval

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

Interval

An interval is a subset of an array where the array consists of two element arrays. The two elements represent a start and end value.

interval := [][2]int{}

It is important when considering intervals to figure out if they should be inclusive or exclusive when it comes to overlapping and if the starting value will always be smaller than the ending value.

Corner cases

No intervals
Single interval
Two intervals
Non-overlapping intervals
Interval that completely overlaps another interval
Duplicates
Intervals that start where other intervals end

Techniques

Sort the array by starting point

This is a crucial strategy when handling interval merging

Linked list

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

Linked list

Similar to an Array, the linked list is a sequential data structure that stores elements linearly. Unlike arrays, the order is not determined by it’s position in memory, but instead it keeps an address of the next element.

This has the advantage of it being an O(1) operation to insert and delete elements in the linked list. The draw back, however, is that accessing is an O(n) operation as the linked list needs to be traveled to find the element.

Matrix

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

Matrix

A matrix is a 2-d array data structure that could be considered a type of graph.

Edge cases

Empty matrices
1 x 1 matrix
Matrix with only 1 row or column

Techniques

Creating an empty N x M matrix

For graph traversal it can be incredibly helpful to start with an empty matrix.

n := 9
m := 9
emptyMatrix := make([][]int, n)
for i := range emptyMatrix {
	emptyMatrix[i] = make([]int, m)
}

Copy a matrix

duplicate := make([][]int, len(matrix))
for i := range duplicate {
	duplicate[i] = make([]int, len(matrix[i]))
	copy(duplicate[i], matrix[i])
}

Transposing a matrix

Transposing a matrix is change the columns into rows and the rows into columns.

Prefix Tree

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

Prefix tree

An implementation of a Trie but instead of holding characters on the edges, we instead hold sub-strings of the inserted string going from left to right.

Examples

go

type TrieNode struct {
	children map[rune]*TrieNode
	isLeaf bool
}

func NewTrieNode() *TrieNode {
	tn := &TrieNode{
		children: make(map[rune]*TrieNode),
		isLeaf: false,
	}
	return tn
}

type Trie struct {
	root *TrieNode
}

func NewTrie() *Trie {
	t := &Trie{
		root: NewTrieNode(),
	}
	return t
}

func (t *Trie) Insert(key string) {
	current := t.root
	for _, index := range key {
		_, ok := current.children[index]
		if !ok {
			current.children[index] = NewTrieNode()
		}
		current = current.children[index]
	}
	current.isLeaf = true
}

func (t *Trie) Search(key string) bool {
	current := t.root
	for _, index := range key {
		_, ok := current.children[index]
		if !ok {
			return false
		}
		current = current.children[index]
	}
	return current.isLeaf
}

func (t *Trie) Prefix(key string) bool {
	current := t.root
	for _, index := range key {
		_, ok := current.children[index]
		if !ok {
			return false
		}
		current = current.children[index]
	}
	return true
}

Queue

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

Queue

A linear data structure that is modified by adding elements to one end and removing them from the other.

Operation	Big-O
Enqueue	O(1)
Dequeue	O(1)
Front	O(1)
Back	O(1)
isEmpty	O(1)

Examples

go

For short lived queues, the following approach can be taken. Since the memory for the slice is never returned, memory leaks may occur in long living queues.

var queue []string
// Enqueue
queue = append(queue, "Hello")
// Dequeue
queue = queue[1:]
// Front
fmt.Print(queue[0])
// Back
fmt.Print(queue[len(queue)-1])

For long lived queues, a linked list is more appropriate. The container/list package provides a doubly linked list.

Slice

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

Slice

A slice is an array that can grow or shrink in size. In Go, a slice is backed by an array, and handles the logic of adding new elements if the backing array is full or shrinking it if it is almost empty.

Internally, a slice holds a pointer to the backing array and keeps track of a length and capacity. The length is the number of elements the slice contains, while the capacity is the number of elements in the backing array.

Stack

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

Stack

A stack is a linear data structure that supports adding elements to one end and removing elements from that same end.

Operation	Big-O
Top/Peek	O(1)
Push	O(1)
Pop	O(1)
Search	O(n)
isEmpty	O(1)

Examples

go

For short lived stacks

var stack []string
// Push
stack = append(stack, "Hello")
// Peek
fmt.Print(stack[len(stack)-1])
// Pop
stack = stack[:len(stack)-1]

For long lived stacks

stack := list.New()
// Push
stack.PushBack("Hello")
// Peek
stack.Back()
// Pop
stack.Remove(stack.Back())

References

Tech-Interview-Handbook

String

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

String

Strings are character arrays and share a lot of similarities with arrays as shown in their relative time complexity.

Operation	Big-O
Access	O(1)
Search	O(n)
Insert	O(n)
Remove	O(n)

Common data-structures for looking up strings

Common string algorithms

Rabin Karp for sub-string searching
KMP for sub-string searching

Multi-string operations

Operation	Big-O	Note
Find sub-string	O(n * m)	Most naive case. KMP and Rabin Karp are more efficient
Concatenate	O(n + m)
Slice	O(m)
Split	O(n + m)	Split by using some character token
Strip	O(n)	Remove leading and trailing whitespace

Common edge cases

Empty string
String with 1 or 2 characters
String with repeated characters or sub-strings
Strings with only distinct or no repeating characters

Techniques

Counting Characters

When counting the frequency of characters or a pattern in a string, use a hash map.

Suffix tree

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

Suffix tree

An implementation of a Trie but instead of holding characters on the edges, we instead hold sub-strings of the inserted string going from right to left.

Construction

A naive approach to construction a suffix tree has a complexity of O(m^2) where m is the length of the input string. This can be improved to O(m) using Ukkonen’s Suffix Tree Construction Algorithm.

Tree

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

Tree

Trees are hierarchical data structures that are made up of a series of nodes. Each node can have many children but needs to have one parent. If a node does not have a parent, it is considered to be a root node.

Trees can also be considered as a undirected, connect, acyclic Graph.

Common terms

Neighbor: The parent or child nodes of the current node
Ancestor: Any node from the current node to the root node
Descendant: Any node in the current node’s subtree
Degree: Number of children at current node
Degree of a tree: Max degree of nodes in the tree
Distance: Number of edges between two nodes
Level/Depth: Number of edges between root and node
Width: Number of nodes in a level
Skewed: Nodes have very few children, like a linked list

Types of trees

Common routines

Insert
Delete
Count number of nodes
Search
Height

References

Tech-Interview-Handbook

Trie

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

Trie

A trie is a Tree structure where each edge represents one character and the root is null. Each path from the root represents a string, described by the characters labeling the traversed edges.

Time complexity

Operation	Big-O
Insert	O(n)
Search	O(n)

Auxiliary space

Operation	Big-O	Notes
Insert	O(m * n)	m is the Alphabet size * key length
Search	O(1)

This is a trie of “there”, “their”, “when” and “was”