Pointer declaration in Go - Time & Space Complexity

Time Complexity: Pointer declaration

O(1)

Understanding Time Complexity

When we declare pointers in Go, it's important to see how this affects the program's speed.

We want to know how the time to run changes as we use pointers.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

package main

func increment(val *int) {
    *val = *val + 1
}

func main() {
    x := 5
    increment(&x)
}

This code declares a pointer to an integer and uses it to increase the value by one.

Identify Repeating Operations

Look for any repeated actions that take time.

• Primary operation: Single pointer dereference and increment.
• How many times: Happens once in this example.

How Execution Grows With Input

Since the code runs a single operation, the time does not grow with input size.

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

Pattern observation: The time stays the same no matter the input size.

Final Time Complexity

Time Complexity: O(1)

This means the operation takes the same amount of time no matter what.

Common Mistake

[X] Wrong: "Using pointers makes the program slower because it adds extra steps."

[OK] Correct: Accessing a pointer is just one quick step and does not slow down the program noticeably for simple operations.

Interview Connect

Understanding how pointers work and their time cost helps you write clear and efficient code, a skill valued in many programming tasks.

Self-Check

"What if the increment function was called inside a loop running n times? How would the time complexity change?"

Practice

1. What does a pointer in Go store?

easy

A. The actual value of a variable

B. The memory address 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 does not hold the value itself but the location where the value is stored in memory.

2. Step 2: Recall pointer definition in Go

   In Go, a pointer stores the address of a variable, not the variable's value directly.

3. Final Answer:

   The memory address of a variable -> Option B

4. Quick Check:

   Pointer = memory address [OK]

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

Common Mistakes:

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

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

easy

A. var p int = &num

B. var p *int = num

C. var p *int = &num

D. var p int = *num

Solution

1. Step 1: Understand pointer declaration syntax

   In Go, to declare a pointer to an int, use *int as the type.

2. Step 2: Assign the address of num to the pointer

   The address operator & gets the memory address of num, which can be assigned to the pointer.

3. Final Answer:

   var p *int = &num -> Option C

4. Quick Check:

   Pointer declaration uses *type and &variable [OK]

Hint: Pointer type uses * before type, assign with &variable [OK]

Common Mistakes:

• Forgetting the * in pointer type
• Assigning variable value instead of address
• Using *num instead of &num for assignment

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

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

medium

A. 20

B. 10

C. Memory address of x

D. Compilation error

Solution

1. Step 1: Understand pointer assignment and dereferencing

   Variable p stores the address of x. Using *p = 20 changes the value at that address.

2. Step 2: Check the effect on x

   Since p points to x, changing *p changes x to 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   Dereferencing pointer changes original variable [OK]

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

Common Mistakes:

• Thinking *p creates a new variable
• Expecting output to be address instead of value
• Confusing pointer declaration with dereferencing

4. Identify the error in this Go code snippet:

var a int = 5
var p *int = a
fmt.Println(*p)

medium

A. Cannot assign int to *int without & operator

B. Cannot print pointer value with * operator

C. Variable a must be a pointer

D. Missing import fmt

Solution

1. Step 1: Check pointer assignment rules

   Pointer variables must be assigned the address of a variable, not the variable's value.

2. Step 2: Identify missing & operator

   Assigning a directly to p is invalid; it should be p = &a.

3. Final Answer:

   Cannot assign int to *int without & operator -> Option A

4. Quick Check:

   Pointer assignment needs &variable [OK]

Hint: Use & to assign address to pointer variables [OK]

Common Mistakes:

• Assigning value instead of address to pointer
• Forgetting to import fmt for Println
• Thinking *p prints address instead of value

5. Given the code below, what will be the output?

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

hard

A. 10

B. Compilation error

C. Memory address of val

D. 15

Solution

1. Step 1: Understand function parameter as pointer

   The function updateValue takes a pointer to an int and modifies the value at that address.

2. Step 2: Trace the function call and modification

   Passing &val sends the address of val. Inside the function, *p = *p + 5 increases val by 5.

3. Step 3: Check final print output

   After the function call, val is updated to 15, so fmt.Println(val) prints 15.

4. Final Answer:

   15 -> Option D

5. Quick Check:

   Pointer parameter modifies original variable [OK]

Hint: Passing &variable lets function change original value [OK]

Common Mistakes:

• Passing value instead of address to function
• Expecting original variable unchanged
• Confusing pointer dereference syntax