Go 컬렉션 완전 정리

Go code

package main

import "fmt"

func main() {
	// 슬라이스 생성
	s1 := []int{1, 2, 3, 4, 5}
	s2 := make([]int, 5)       // len=5, cap=5, 제로값
	s3 := make([]int, 3, 10)   // len=3, cap=10

	// append — 용량 초과 시 새 배열 할당 (약 2배)
	s := []int{1, 2, 3}
	s = append(s, 4)
	s = append(s, 5, 6, 7)       // 여러 값
	s = append(s, s1...)          // 슬라이스 전개

	// 슬라이싱 [low:high:max]
	fmt.Println(s[1:4])   // [2 3 4]
	fmt.Println(s[:3])    // [1 2 3]
	fmt.Println(s[3:])    // [4 5 6 7 1 2 3 4 5]

	// copy — 독립적인 복사
	dst := make([]int, 3)
	n := copy(dst, s1)
	fmt.Println(dst, n)   // [1 2 3] 3

	// 2D 슬라이스
	matrix := make([][]int, 3)
	for i := range matrix {
		matrix[i] = make([]int, 3)
		for j := range matrix[i] { matrix[i][j] = i*3 + j }
	}

	// 슬라이스 함수들 (Go 1.21+)
	// slices.Sort, slices.Contains, slices.Index
	// import "slices"

	// 삭제 — 순서 유지
	i := 2
	s1 = append(s1[:i], s1[i+1:]...)
	fmt.Println(s1) // [1 2 4 5]

	// 삭제 — 순서 무관 (빠름)
	s2[i] = s2[len(s2)-1]
	s2 = s2[:len(s2)-1]

	fmt.Println(len(s3), cap(s3)) // 3 10
	_ = s2
}

Go code

package main

import (
	"fmt"
	"sort"
)

func main() {
	// 맵 생성
	m1 := map[string]int{
		"apple":  5,
		"banana": 3,
		"cherry": 8,
	}
	m2 := make(map[string]int)       // 빈 맵
	m2["key"] = 100

	// 읽기 & 존재 확인 (comma-ok 패턴)
	val, ok := m1["apple"]
	if ok {
		fmt.Println("apple:", val)
	}

	val2 := m1["durian"] // 없으면 zero value (0)
	fmt.Println("durian:", val2)

	// 삭제
	delete(m1, "banana")

	// 순회 (순서 보장 안 됨)
	keys := make([]string, 0, len(m1))
	for k := range m1 { keys = append(keys, k) }
	sort.Strings(keys) // 정렬
	for _, k := range keys {
		fmt.Printf("%s: %d
", k, m1[k])
	}

	// 중첩 맵
	graph := map[string][]string{
		"A": {"B", "C"},
		"B": {"D"},
		"C": {"D", "E"},
	}
	fmt.Println(graph["A"])

	// 빈도 카운팅 패턴
	words := []string{"go", "is", "great", "go", "is"}
	freq := make(map[string]int)
	for _, w := range words { freq[w]++ }
	fmt.Println(freq)

	// 구조체를 값으로
	type Point struct{ X, Y int }
	points := map[string]Point{
		"origin": {0, 0},
		"unit":   {1, 1},
	}
	fmt.Println(points["unit"])
}

Go code

<span class="cm">// iter 패키지 (Go 1.23+) 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("iter 패키지 (Go 1.23+)") }

Go code

package main

import "fmt"

func main() {
	// 슬라이스 헤더: (ptr, len, cap)
	s := make([]int, 3, 5)
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)

	// append: 용량 초과 시 새 배열 할당
	s = append(s, 1, 2)    // cap 5 이내
	fmt.Printf("len=%d cap=%d\n", len(s), cap(s))

	s = append(s, 3)       // cap 초과 → 새 배열
	fmt.Printf("len=%d cap=%d\n", len(s), cap(s))

	// 서브슬라이스는 원본과 배열 공유!
	a := []int{1, 2, 3, 4, 5}
	b := a[1:3]             // [2, 3]
	b[0] = 99
	fmt.Println(a) // [1 99 3 4 5] — 원본도 변경됨!

	// 독립 복사
	c := make([]int, len(a))
	copy(c, a)
	c[0] = 0
	fmt.Println(a[0], c[0]) // 1 0
}

Go code

package main

import (
	"fmt"
	"sync"
)

// RWMutex로 보호된 맵
type SafeCounter struct {
	mu sync.RWMutex
	m  map[string]int
}

func (c *SafeCounter) Inc(key string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.m[key]++
}

func (c *SafeCounter) Get(key string) int {
	c.mu.RLock()         // 읽기 전용 잠금
	defer c.mu.RUnlock()
	return c.m[key]
}

func main() {
	counter := SafeCounter{m: make(map[string]int)}

	var wg sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			counter.Inc("visits")
		}()
	}
	wg.Wait()
	fmt.Println("visits:", counter.Get("visits")) // 1000
}

Go code

package main

import (
	"fmt"
	"sync"
)

func main() {
	var m sync.Map

	// 저장
	m.Store("lang", "Go")
	m.Store("version", "1.22")

	// 로드
	v, ok := m.Load("lang")
	fmt.Println(v, ok) // Go true

	// 없으면 저장, 있으면 기존 값 반환
	actual, loaded := m.LoadOrStore("lang", "Rust")
	fmt.Println(actual, loaded) // Go true (이미 있음)

	// 삭제
	m.Delete("version")

	// 순회
	m.Store("os", "linux")
	m.Range(func(key, value any) bool {
		fmt.Printf("%s = %s\n", key, value)
		return true // false면 순회 중단
	})

	// LoadAndDelete (Go 1.15+)
	v, loaded = m.LoadAndDelete("os")
	fmt.Println("삭제:", v, loaded)
}

Go code

package main

import (
	"cmp"
	"fmt"
	"slices"
)

type Student struct {
	Name  string
	Score int
}

func main() {
	// 기본 정렬
	nums := []int{5, 2, 8, 1, 9}
	slices.Sort(nums)
	fmt.Println(nums) // [1 2 5 8 9]

	// 커스텀 정렬
	students := []Student{
		{"Alice", 90}, {"Bob", 85}, {"Charlie", 95},
	}
	slices.SortFunc(students, func(a, b Student) int {
		return cmp.Compare(b.Score, a.Score) // 내림차순
	})
	for _, s := range students {
		fmt.Printf("%s: %d\n", s.Name, s.Score)
	}

	// 안정 정렬
	slices.SortStableFunc(students, func(a, b Student) int {
		return cmp.Compare(a.Name, b.Name)
	})

	// 이진 검색
	idx, found := slices.BinarySearch(nums, 5)
	fmt.Printf("5 at index %d, found=%t\n", idx, found)
}

Go code

package main

import (
	"container/heap"
	"fmt"
)

type Item struct {
	Value    string
	Priority int
}

type PriorityQueue []*Item

func (pq PriorityQueue) Len() int            { return len(pq) }
func (pq PriorityQueue) Less(i, j int) bool   { return pq[i].Priority > pq[j].Priority }
func (pq PriorityQueue) Swap(i, j int)        { pq[i], pq[j] = pq[j], pq[i] }

func (pq *PriorityQueue) Push(x any) {
	*pq = append(*pq, x.(*Item))
}

func (pq *PriorityQueue) Pop() any {
	old := *pq
	n := len(old)
	item := old[n-1]
	*pq = old[:n-1]
	return item
}

func main() {
	pq := &PriorityQueue{}
	heap.Init(pq)

	heap.Push(pq, &Item{"낮음", 1})
	heap.Push(pq, &Item{"높음", 10})
	heap.Push(pq, &Item{"중간", 5})

	for pq.Len() > 0 {
		item := heap.Pop(pq).(*Item)
		fmt.Printf("[%d] %s\n", item.Priority, item.Value)
	}
}

Go code

package main

import (
	"container/ring"
	"fmt"
)

func main() {
	// 크기 5인 링 버퍼
	r := ring.New(5)

	// 값 채우기
	for i := 1; i <= 5; i++ {
		r.Value = fmt.Sprintf("이벤트-%d", i)
		r = r.Next()
	}

	// 순회
	r.Do(func(v any) {
		if v != nil {
			fmt.Println(v)
		}
	})

	// 새 이벤트 추가 (가장 오래된 것 덮어쓰기)
	r.Value = "이벤트-6"
	r = r.Next()

	fmt.Println("--- 업데이트 후 ---")
	r.Do(func(v any) {
		if v != nil {
			fmt.Println(v)
		}
	})

	fmt.Println("링 크기:", r.Len())
}

Go code

package main

import (
	"container/list"
	"fmt"
)

func main() {
	l := list.New()

	// 삽입
	l.PushBack("두 번째")
	front := l.PushFront("첫 번째")
	l.PushBack("세 번째")
	l.InsertAfter("사이에", front)

	// 순회
	for e := l.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)
	}

	// 역순 순회
	fmt.Println("--- 역순 ---")
	for e := l.Back(); e != nil; e = e.Prev() {
		fmt.Println(e.Value)
	}

	// 삭제
	l.Remove(front)
	fmt.Println("길이:", l.Len())
}

Go code

package main

import "fmt"

// 제네릭 스택
type Stack[T any] struct{ items []T }

func (s *Stack[T]) Push(v T)       { s.items = append(s.items, v) }
func (s *Stack[T]) Pop() (T, bool) {
	if len(s.items) == 0 { var z T; return z, false }
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, true
}
func (s *Stack[T]) Len() int { return len(s.items) }

// 제네릭 큐
type Queue[T any] struct{ items []T }

func (q *Queue[T]) Enqueue(v T)       { q.items = append(q.items, v) }
func (q *Queue[T]) Dequeue() (T, bool) {
	if len(q.items) == 0 { var z T; return z, false }
	v := q.items[0]
	q.items = q.items[1:]
	return v, true
}
func (q *Queue[T]) Len() int { return len(q.items) }

func main() {
	stack := &Stack[int]{}
	stack.Push(1); stack.Push(2); stack.Push(3)
	v, _ := stack.Pop()
	fmt.Println("스택 Pop:", v) // 3

	queue := &Queue[string]{}
	queue.Enqueue("첫째"); queue.Enqueue("둘째")
	s, _ := queue.Dequeue()
	fmt.Println("큐 Dequeue:", s) // 첫째
}

Go code

package main

import "fmt"

type Set[T comparable] map[T]struct{}

func NewSet[T comparable](items ...T) Set[T] {
	s := make(Set[T], len(items))
	for _, item := range items { s[item] = struct{}{} }
	return s
}

func (s Set[T]) Add(item T)    { s[item] = struct{}{} }
func (s Set[T]) Remove(item T) { delete(s, item) }
func (s Set[T]) Has(item T) bool { _, ok := s[item]; return ok }

func (s Set[T]) Union(other Set[T]) Set[T] {
	result := NewSet[T]()
	for k := range s { result.Add(k) }
	for k := range other { result.Add(k) }
	return result
}

func (s Set[T]) Intersect(other Set[T]) Set[T] {
	result := NewSet[T]()
	for k := range s {
		if other.Has(k) { result.Add(k) }
	}
	return result
}

func main() {
	a := NewSet(1, 2, 3, 4)
	b := NewSet(3, 4, 5, 6)

	fmt.Println("합집합:", a.Union(b))       // 1~6
	fmt.Println("교집합:", a.Intersect(b))   // 3, 4
	fmt.Println("Has 2:", a.Has(2))         // true
}

Go code

package main

import (
	"cmp"
	"fmt"
)

type Node[T cmp.Ordered] struct {
	Value T
	Left  *Node[T]
	Right *Node[T]
}

type BST[T cmp.Ordered] struct {
	Root *Node[T]
}

func (t *BST[T]) Insert(val T) {
	t.Root = insert(t.Root, val)
}

func insert[T cmp.Ordered](n *Node[T], val T) *Node[T] {
	if n == nil { return &Node[T]{Value: val} }
	if val < n.Value {
		n.Left = insert(n.Left, val)
	} else if val > n.Value {
		n.Right = insert(n.Right, val)
	}
	return n
}

func (t *BST[T]) InOrder() []T {
	var result []T
	inOrder(t.Root, &result)
	return result
}

func inOrder[T cmp.Ordered](n *Node[T], result *[]T) {
	if n == nil { return }
	inOrder(n.Left, result)
	*result = append(*result, n.Value)
	inOrder(n.Right, result)
}

func main() {
	tree := &BST[int]{}
	for _, v := range []int{5, 3, 7, 1, 4, 6, 8} {
		tree.Insert(v)
	}
	fmt.Println(tree.InOrder()) // [1 3 4 5 6 7 8]
}