Struct usage patterns in Go - Time & Space Complexity

Time Complexity: Struct usage patterns

O(n)

Understanding Time Complexity

When using structs in Go, it is important to understand how operations on them grow as data size increases.

We want to know how the time to access or modify struct data changes when we have many structs or nested structs.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func printNames(people []Person) {
    for _, p := range people {
        fmt.Println(p.Name)
    }
}

func main() {
    people := []Person{{"Alice", 30}, {"Bob", 25}, {"Carol", 27}}
    printNames(people)
}
    

This code defines a struct Person and prints the Name field for each person in a slice.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the slice of Person structs.
• How many times: Once for each element in the slice (n times).

How Execution Grows With Input

As the number of Person structs increases, the time to print all names grows proportionally.

Input Size (n)	Approx. Operations
10	10 print operations
100	100 print operations
1000	1000 print operations

Pattern observation: The time grows directly with the number of structs; doubling the structs doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to process all structs grows linearly with how many structs there are.

Common Mistake

[X] Wrong: "Accessing a field inside a struct takes extra time for each field."

[OK] Correct: Accessing a field in a struct is a direct operation and does not add extra loops or repeated work; the main time cost comes from how many structs you process.

Interview Connect

Understanding how operations on structs scale helps you write efficient code and explain your reasoning clearly in interviews.

Self-Check

"What if we changed the slice of structs to a nested struct with slices inside? How would the time complexity change?"

Practice

1. What is the primary purpose of using a struct in Go?

easy

A. To group related data with named fields

B. To perform arithmetic operations

C. To create loops

D. To handle errors

Solution

1. Step 1: Understand the role of structs

   Structs are used to group related data together in one unit with named fields.

2. Step 2: Compare with other options

   Arithmetic, loops, and error handling are not the main purposes of structs.

3. Final Answer:

   To group related data with named fields -> Option A

4. Quick Check:

   Structs = Group related data [OK]

Hint: Structs group data fields logically [OK]

Common Mistakes:

• Thinking structs are for control flow
• Confusing structs with functions
• Assuming structs handle errors

2. Which of the following is the correct way to declare a struct type named Person with fields Name (string) and Age (int)?

easy

A. Person := struct { Name string; Age int }

B. struct Person { Name string; Age int }

C. var Person struct Name string; Age int

D. type Person struct { Name string; Age int }

Solution

1. Step 1: Recall Go struct declaration syntax

   In Go, a struct type is declared with the keyword type, followed by the name, then struct and fields inside braces.

2. Step 2: Check each option

   type Person struct { Name string; Age int } matches the correct syntax. struct Person { Name string; Age int } misses type. Person := struct { Name string; Age int } uses := which is for variables, not type declaration. var Person struct Name string; Age int is invalid syntax.

3. Final Answer:

   type Person struct { Name string; Age int } -> Option D

4. Quick Check:

   Struct declaration uses 'type Name struct { fields }' [OK]

Hint: Use 'type Name struct { fields }' to declare structs [OK]

Common Mistakes:

• Omitting 'type' keyword
• Using := for type declaration
• Incorrect field syntax

3. What will be the output of the following Go code?

type Point struct {
  X int
  Y int
}

func main() {
  p := Point{X: 3, Y: 4}
  p.X = 10
  fmt.Println(p.X, p.Y)
}

medium

A. 10 4

B. 3 4

C. 10 0

D. 0 4

Solution

1. Step 1: Understand struct initialization and modification

   The struct Point is initialized with X=3 and Y=4. Then p.X is changed to 10.

2. Step 2: Determine printed values

   After modification, p.X is 10 and p.Y remains 4. So printing p.X and p.Y outputs '10 4'.

3. Final Answer:

   10 4 -> Option A

4. Quick Check:

   Modified field prints updated value [OK]

Hint: Changing struct fields updates their values [OK]

Common Mistakes:

• Assuming original values stay after assignment
• Confusing field names
• Forgetting to import fmt (not shown here)

4. Identify the error in the following Go code snippet:

type Car struct {
  Brand string
  Year  int
}

func main() {
  c := Car{Brand: "Toyota", Year: "2020"}
  fmt.Println(c)
}

medium

A. Missing semicolon after struct declaration

B. Year field assigned a string instead of int

C. Incorrect struct name capitalization

D. fmt.Println cannot print structs

Solution

1. Step 1: Check field types in struct literal

   The struct Car has Year as int, but the code assigns "2020" (a string) to Year.

2. Step 2: Verify other options

   Semicolons are optional in Go. Struct name capitalization is fine. fmt.Println can print structs.

3. Final Answer:

   Year field assigned a string instead of int -> Option B

4. Quick Check:

   Field types must match assigned values [OK]

Hint: Match struct field types exactly when assigning [OK]

Common Mistakes:

• Assigning wrong data types to fields
• Thinking semicolons are mandatory
• Assuming fmt.Println can't print structs

5. Given a struct type Employee with fields Name (string), Salary (int), and Active (bool), which code snippet correctly creates a slice of active employees with salary over 50000 from a given slice emps?

hard

A. filtered := make([]Employee, 0)
for _, e := range emps {
if e.Active || e.Salary > 50000 {
filtered = append(filtered, e)
}
}

B. filtered := []Employee{}
for i := 0; i < len(emps); i++ {
if emps[i].Salary > 50000 {
filtered = append(filtered, emps[i])
}
}

C. var filtered []Employee
for _, e := range emps {
if e.Active && e.Salary > 50000 {
filtered = append(filtered, e)
}
}

D. filtered := []Employee{}
for _, e := range emps {
if e.Active && e.Salary < 50000 {
filtered = append(filtered, e)
}
}

Solution

1. Step 1: Understand filtering conditions

   We want employees who are active AND have salary greater than 50000.

2. Step 2: Analyze each option's condition

   var filtered []Employee for _, e := range emps { if e.Active && e.Salary > 50000 { filtered = append(filtered, e) } } uses correct AND condition. filtered := []Employee{} for i := 0; i < len(emps); i++ { if emps[i].Salary > 50000 { filtered = append(filtered, emps[i]) } } misses Active check. filtered := make([]Employee, 0) for _, e := range emps { if e.Active || e.Salary > 50000 { filtered = append(filtered, e) } } uses OR instead of AND. filtered := []Employee{} for _, e := range emps { if e.Active && e.Salary < 50000 { filtered = append(filtered, e) } } uses salary less than 50000, which is wrong.

3. Final Answer:

   var filtered []Employee for _, e := range emps { if e.Active && e.Salary > 50000 { filtered = append(filtered, e) } } -> Option C

4. Quick Check:

   Use AND (&&) for combined conditions [OK]

Hint: Use && to combine multiple filter conditions [OK]

Common Mistakes:

• Using || instead of && for filtering
• Ignoring one of the filter conditions
• Filtering with wrong comparison operators