Group by Key - Go DSA

Build buckets keyed by a shared field, preserving the first-seen key order.

Algorithm

Canonical pairs (a,1), (b,2), (a,3), (c,4), (b,5) print {a: [1, 3], b: [2, 5], c: [4]}. The replay uses the same input in every language, so this Go DSA implementation can be compared directly with the rest of the DSA track.

Basic Implementation

basic.go

package main

import (
    "fmt"
    "strings"
)

type pair struct {
    key string
    value int
}

func main() {
    pairs := []pair{{"a", 1}, {"b", 2}, {"a", 3}, {"c", 4}, {"b", 5}}
    groups := map[string][]int{}
    order := []string{}
    for _, item := range pairs {
        if _, ok := groups[item.key]; !ok {
            order = append(order, item.key)
        }
        groups[item.key] = append(groups[item.key], item.value)
    }
    parts := []string{}
    for _, key := range order {
        values := groups[key]
        renderedValues := []string{}
        for _, value := range values {
            renderedValues = append(renderedValues, fmt.Sprintf("%d", value))
        }
        parts = append(parts, fmt.Sprintf("%s: [%s]", key, strings.Join(renderedValues, ", ")))
    }
    fmt.Println("{" + strings.Join(parts, ", ") + "}")
}

Complexity

Time: O(n) average
Space: O(k + n) for buckets and values

Implementation notes

Keep output formatting deterministic. Do not rely on unordered hash-map printing when the lesson needs cross-language comparison.
The trace highlights the hash table state after each write and includes a collision contrast where one bucket chain grows, showing why long chains can degrade lookup and why real tables resize or rehash.

bucket map Each key owns a list. A new key creates a bucket; a repeated key appends to the existing bucket.