Checking Balanced Parentheses (an Application of Stacks)

In this lesson you will learn how to check that brackets are balanced using a stack in Go, a practical application of the stack data structure. This is for anyone searching for "Go balanced parentheses stack".

With a stack (last in, first out) you can push opening brackets such as ( and [, then check each closing bracket against whatever is on top. That is how bracket matching works.

The sample code keeps the opening bracket for each closing bracket in the pairs map, pushes onto the stack with append on an opening bracket, and checks the top of the stack on a closing one. If the stack is empty once everything has been processed, the brackets are balanced.

A common stumbling block for beginners is handling several kinds of bracket at once (round, square, and curly mixed together). Counting openings and closings is not enough - you also have to confirm they nest in the right order.

A similar mechanism is used when a compiler parses syntax, making this a broadly applicable idea. Plenty of similar tools check that HTML opening and closing tags line up correctly.

📖 Reference code

package main

import "fmt"

func isBalanced(s string) bool {
	stack := []rune{}
	pairs := map[rune]rune{')': '(', ']': '[', '}': '{'}
	for _, ch := range s {
		if ch == '(' || ch == '[' || ch == '{' {
			stack = append(stack, ch)
		} else if ch == ')' || ch == ']' || ch == '}' {
			if len(stack) == 0 || stack[len(stack)-1] != pairs[ch] {
				return false
			}
			stack = stack[:len(stack)-1]
		}
	}
	return len(stack) == 0
}

func main() {
	fmt.Println(isBalanced("(a[b]{c})"))
	fmt.Println(isBalanced("(a[b)]"))
}

✍️ Your code

Type your code, then press "Run"

🧪 This site can't compile or run Go directly, so it checks on the spot whether what you typed matches the reference code (scoring happens entirely in your browser — nothing is sent anywhere).