Algorithms and Data Structures in Go: A Practical Guide

Introduction: Why Algorithms and Data Structures Matter in Go

Go (Golang) is a modern compiled language created at Google for high-performance systems. Its simplicity and built-in concurrency support make it ideal for backend development, microservices, and cloud applications. However, as with any other language, the efficiency of Go code directly depends on understanding algorithms and data structures. Without them, even the fastest language can become a bottleneck.

In this article, we will cover the key data structures and algorithms that every Go developer should know: from arrays to binary search. You will see code examples, learn how they work "under the hood," and get practical optimization tips.

1. Basic Data Structures in Go

Go provides built-in data structures, but using them correctly is key to performance. Let's look at three main ones: arrays, slices, and hash tables.

1.1 Arrays and Slices

An array in Go is a fixed-length sequence of elements of the same type. A slice is a dynamic wrapper over an array that allows you to change its size.

package main

import "fmt"

func main() {    // Fixed-length array    var arr [5]int = [5]int{1, 2, 3, 4, 5}    fmt.Println("Array:", arr)

    // Slice — dynamic structure    slice := []int{10, 20, 30}    slice = append(slice, 40) // Adding an element    fmt.Println("Slice:", slice)

    // Slice from an array    subSlice := arr[1:4] // [2, 3, 4]    fmt.Println("Sub-slice:", subSlice)}

Tip: Always use slices instead of arrays for flexibility, but remember that append can cause memory reallocation. Pre-allocate capacity using make([]int, 0, capacity).

1.2 Hash Tables (Map)

A map is an unordered collection of key-value pairs. In Go, a map is implemented as a hash table, providing an average access time of O(1).

package main

import "fmt"

func main() {    // Creating a map    scores := make(map[string]int)    scores["Alice"] = 95    scores["Bob"] = 87

    // Reading with check    if val, ok := scores["Alice"]; ok {        fmt.Println("Alice's score:", val)    }

    // Deletion    delete(scores, "Bob")    fmt.Println("After deletion:", scores)}

Important: Maps do not support concurrent access without synchronization. For multi-threaded scenarios, use sync.Map or mutexes.

2. Implementing a Linked List in Go

Linked lists are rarely used in Go due to the availability of slices, but they are useful for understanding pointers and dynamic structures. Let's look at a singly linked list.

2.1 Node Structure and Basic Operations

package main

import "fmt"

// List nodetype Node struct {    Value int    Next  *Node}

// Listtype LinkedList struct {    Head *Node}

// Prepend to the beginningfunc (ll *LinkedList) Prepend(value int) {    newNode := &Node{Value: value, Next: ll.Head}    ll.Head = newNode}

// Search for an elementfunc (ll *LinkedList) Search(value int) bool {    current := ll.Head    for current != nil {        if current.Value == value {            return true        }        current = current.Next    }    return false}

// Print the listfunc (ll *LinkedList) Print() {    current := ll.Head    for current != nil {        fmt.Printf("%d -> ", current.Value)        current = current.Next    }    fmt.Println("nil")}

func main() {    list := LinkedList{}    list.Prepend(10)    list.Prepend(20)    list.Prepend(30)    list.Print() // 30 -> 20 -> 10 -> nil    fmt.Println("Found 20:", list.Search(20)) // true}

Performance: Insertion at the beginning is O(1), search is O(n). For frequent index-based access, use slices.