How to implement a simple stack using Golang

In computer science, the stack is an important data structure. The stack can well implement the "Last In First Out" (Last In First Out) data access method, so it is widely used in code.

Go language (Golang) has become the choice of many developers because of its efficient memory allocation and garbage collection mechanism. In this article, we will introduce how to implement a simple stack using Golang.

In Golang, we can use slices to implement stacks. A slice is a dynamic array whose length can be adjusted automatically, making it very suitable for stack data structures.

The following is a simple stack structure:

type Stack struct {
    data []int
}

data is a slice that holds an integer type.

Next, we can add three methods to this structure: Push, Pop, and Peek. The Push method is used to add elements to the stack, the Pop method is used to remove elements from the stack, and the Peek method is used to get the element at the top of the stack without Delete it.

The code for adding elements is as follows:

func (s *Stack) Push(n int) {
    s.data = append(s.data, n)
}

The code for deleting elements is as follows:

func (s *Stack) Pop() (int, bool) {
    if len(s.data) == 0 {
        return 0, false
    }
    lastIdx := len(s.data) - 1
    last := s.data[lastIdx]
    s.data = s.data[:lastIdx]
    return last, true
}

The code for getting the top element is as follows:

func (s *Stack) Peek() (int, bool) {
    if len(s.data) == 0 {
        return 0, false
    }
    lastIdx := len(s.data) - 1
    last := s.data[lastIdx]
    return last, true
}

Here we used The function return multiple value syntax returns the desired result and an identifier of whether the operation was successful.

Now, we can create a stack and add, delete and view its elements in the following ways:

stack := Stack{}
stack.Push(1)
stack.Push(2)
stack.Push(3)

val, ok := stack.Peek()
if ok {
    fmt.Println(val) // 3
}

val, ok = stack.Pop()
if ok {
    fmt.Println(val) // 3
}

val, ok = stack.Pop()
if ok {
    fmt.Println(val) // 2
}

The above code will create a stack and add 1, 2, and 3 in sequence into it. We will then look at the top element of the stack (3), remove the last element (3) and remove the last element again (2).

Through this article, we introduced the simple stack structure and its implementation in Golang. Stack is an important data structure that is widely used in algorithm and software development. Mastering the basic knowledge of the stack and its implementation in Golang will help you better understand and use the stack.

The above is the detailed content of How to implement a simple stack using Golang. For more information, please follow other related articles on the PHP Chinese website!