Common pointer use cases in Go - Time & Space Complexity

Time Complexity: Common pointer use cases

O(n)

Understanding Time Complexity

When using pointers in Go, it's important to understand how they affect the speed of your program.

We want to see how the program's running time changes when pointers are used in common ways.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

package main

func incrementAll(nums []*int) {
    for _, p := range nums {
        *p = *p + 1
    }
}

This code takes a slice of pointers to integers and adds 1 to each integer by using the pointers.

Identify Repeating Operations

• Primary operation: Looping through the slice of pointers and dereferencing each pointer to update the value.
• How many times: Once for each element in the slice (n times if the slice has n elements).

How Execution Grows With Input

As the number of pointers in the slice grows, the time to update all values grows in a straight line.

Input Size (n)	Approx. Operations
10	10 updates
100	100 updates
1000	1000 updates

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

Final Time Complexity

Time Complexity: O(n)

This means the time to complete the task grows in direct proportion to the number of pointers you have.

Common Mistake

[X] Wrong: "Using pointers makes the loop run faster because it avoids copying values."

[OK] Correct: While pointers avoid copying data, the loop still visits every element, so the total time still grows with the number of elements.

Interview Connect

Understanding how pointers affect time helps you explain your code choices clearly and shows you know how your program scales with data size.

Self-Check

"What if we changed the slice of pointers to a slice of values? How would the time complexity change?"

Practice

1. What does a pointer in Go store?

easy

A. The memory address of a variable

B. The value of a variable

C. The type of a variable

D. The size of a variable

Solution

1. Step 1: Understand what a pointer represents

   A pointer holds the location in memory where a variable is stored, not the value itself.

2. Step 2: Differentiate pointer from value

   The value is stored at the address the pointer points to, not inside the pointer variable.

3. Final Answer:

   The memory address of a variable -> Option A

4. Quick Check:

   Pointers store addresses = B [OK]

Hint: Pointers hold addresses, not values directly [OK]

Common Mistakes:

• Confusing pointer with the actual value
• Thinking pointer stores variable type
• Assuming pointer stores variable size

2. Which of the following is the correct way to declare a pointer to an int in Go?

easy

A. var p int*

B. var p &int

C. var p *int

D. var *p int

Solution

1. Step 1: Recall Go pointer syntax

   In Go, a pointer type is written as *Type, so a pointer to int is *int.

2. Step 2: Check variable declaration format

   The variable name comes after var, then the type. So correct is var p *int.

3. Final Answer:

   var p *int -> Option C

4. Quick Check:

   Pointer syntax is var name *Type = D [OK]

Hint: Pointer type uses * before type, not after variable [OK]

Common Mistakes:

• Placing * after variable name
• Using & instead of * for pointer type
• Incorrect order of * and variable name

3. What is the output of this Go code?

func main() {
    x := 10
    p := &x
    *p = 20
    fmt.Println(x)
}

medium

A. 10

B. Memory address of x

C. Compilation error

D. 20

Solution

1. Step 1: Understand pointer assignment

   p points to x's address. Changing *p changes the value at x's address.

2. Step 2: Trace value change

   *p = 20 sets x to 20. So printing x outputs 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   Pointer changes original value = 20 [OK]

Hint: Changing *p changes original variable value [OK]

Common Mistakes:

• Thinking x remains 10 after *p = 20
• Printing pointer address instead of value
• Assuming compilation error due to pointer

4. Identify the error in this Go code snippet:

func updateValue(p *int) {
    *p = 100
}

func main() {
    var p *int
    updateValue(p)
}

medium

A. Syntax error in function declaration

B. p is nil and dereferenced causing runtime panic

C. updateValue should return an int

D. No error, code runs fine

Solution

1. Step 1: Check pointer initialization

   p is declared but not assigned an address, so it is nil.

2. Step 2: Analyze dereferencing nil pointer

   updateValue dereferences *p, causing a runtime panic because p is nil.

3. Final Answer:

   p is nil and dereferenced causing runtime panic -> Option B

4. Quick Check:

   Dereferencing nil pointer causes panic = A [OK]

Hint: Never dereference nil pointers without initialization [OK]

Common Mistakes:

• Assuming nil pointer is safe to dereference
• Thinking function must return a value
• Ignoring runtime panic possibility

5. Given this Go code, what will be the output?

func swap(a, b *int) {
    *a, *b = *b, *a
}

func main() {
    x, y := 5, 10
    swap(&x, &y)
    fmt.Println(x, y)
}

hard

A. 10 5

B. 5 10

C. Memory addresses of x and y

D. Compilation error due to swap syntax

Solution

1. Step 1: Understand swap function with pointers

   swap receives pointers to x and y, then swaps the values they point to.

2. Step 2: Trace swap effect on variables

   After swap, x becomes 10 and y becomes 5.

3. Final Answer:

   10 5 -> Option A

4. Quick Check:

   Pointer swap changes original values = 10 5 [OK]

Hint: Swap values by swapping *a and *b via pointers [OK]

Common Mistakes:

• Expecting original values unchanged
• Printing pointer addresses instead of values
• Thinking swap function syntax is invalid