Pointer behavior in functions in Go - Time & Space Complexity

Time Complexity: Pointer behavior in functions

O(n)

Understanding Time Complexity

When we use pointers in functions, it changes how data is accessed and changed.

We want to see how this affects the time it takes for the program to run as input grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

package main

func incrementAll(nums *[]int) {
  for i := range *nums {
    (*nums)[i]++
  }
}

func main() {
  numbers := []int{1, 2, 3, 4, 5}
  incrementAll(&numbers)
}

This code increases each number in a list by 1 using a pointer to modify the original list.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each element in the list.
• How many times: Once for every item in the list.

How Execution Grows With Input

As the list gets bigger, the loop runs more times, directly matching the list size.

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

Pattern observation: The work grows evenly as the list grows; doubling the list doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to finish grows in a straight line with the size of the list.

Common Mistake

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

[OK] Correct: While pointers avoid copying, the loop still visits every item, so time depends on list size, not pointer use.

Interview Connect

Understanding how pointers affect function behavior and time helps you explain your code clearly and shows you know how data flows in programs.

Self-Check

"What if the function used a copy of the list instead of a pointer? How would the time complexity change?"

Practice

1. What does passing a pointer to a function in Go allow you to do?

easy

A. Automatically convert the variable to a string

B. Create a copy of the variable that cannot be changed

C. Modify the original variable's value inside the function

D. Prevent the function from accessing the variable

Solution

1. Step 1: Understand pointer passing

   Passing a pointer sends the address of the variable, not a copy.

2. Step 2: Effect on original variable

   Inside the function, using the pointer lets you change the original variable's value.

3. Final Answer:

   Modify the original variable's value inside the function -> Option C

4. Quick Check:

   Pointer lets function change original variable [OK]

Hint: Pointers let functions change original variables directly [OK]

Common Mistakes:

• Thinking pointers create copies instead of referencing original
• Confusing pointer with value passing
• Assuming pointers prevent modification

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

easy

A. func updateValue(val *int) {}

B. func updateValue(val int) {}

C. func updateValue(*val int) {}

D. func updateValue(&val int) {}

Solution

1. Step 1: Recall pointer syntax in function parameters

   In Go, a pointer parameter is declared with * before the type, like *int.

2. Step 2: Check each option

   func updateValue(val *int) {} correctly uses *int as the parameter type.

3. Final Answer:

   func updateValue(val *int) {} -> Option A

4. Quick Check:

   Pointer parameter syntax = *type [OK]

Hint: Pointer parameters use * before type, not variable name [OK]

Common Mistakes:

• Placing * before variable name instead of type
• Using & in parameter declaration
• Omitting * for pointer type

3. What will be the output of this Go program?

package main
import "fmt"
func change(val *int) {
    *val = 10
}
func main() {
    x := 5
    change(&x)
    fmt.Println(x)
}

medium

A. 5

B. 10

C. 0

D. Compilation error

Solution

1. Step 1: Understand pointer usage in change function

   The function receives a pointer to x and sets the value at that address to 10.

2. Step 2: Trace main function execution

   x starts as 5, change(&x) updates x to 10, then fmt.Println prints x.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Pointer lets function update x to 10 [OK]

Hint: Pointer lets function change original variable value [OK]

Common Mistakes:

• Expecting original value 5 to print
• Confusing pointer dereference syntax
• Thinking function works without & operator

4. Identify the error in this Go code snippet:

func update(val *int) {
    val = 20
}

func main() {
    x := 5
    update(&x)
    fmt.Println(x)
}

medium

A. Cannot assign int to pointer variable directly

B. Missing & operator when calling update

C. Function update should return int

D. x is not initialized

Solution

1. Step 1: Analyze assignment inside update function

   val is a pointer to int, but val = 20 tries to assign int to pointer variable, which is invalid.

2. Step 2: Correct way to change value via pointer

   Use *val = 20 to assign 20 to the value pointed by val.

3. Final Answer:

   Cannot assign int to pointer variable directly -> Option A

4. Quick Check:

   Assign to *val, not val [OK]

Hint: Assign to *pointer, not pointer variable itself [OK]

Common Mistakes:

• Assigning value directly to pointer variable
• Forgetting to dereference pointer
• Confusing pointer and value types

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

package main
import "fmt"
func swap(a, b *int) {
    *a, *b = *b, *a
}
func main() {
    x, y := 1, 2
    swap(&x, &y)
    fmt.Println(x, y)
}

hard

A. Compilation error

B. 1 2

C. 0 0

D. 2 1

Solution

1. Step 1: Understand swap function behavior

   swap takes pointers to two ints and swaps their values using pointer dereferencing.

2. Step 2: Trace main function execution

   x=1, y=2 initially; swap(&x, &y) swaps values, so x becomes 2 and y becomes 1.

3. Final Answer:

   2 1 -> Option D

4. Quick Check:

   Pointer swap exchanges values correctly [OK]

Hint: Swap values by dereferencing pointers [OK]

Common Mistakes:

• Expecting original order after swap
• Confusing pointer addresses with values
• Not using * to dereference pointers