淘宝客可道cms网站建设郑州一建招聘

以下是Go语言中常用的算法实现，涵盖排序、搜索、数据结构操作等核心算法。

一、排序算法

1. 快速排序

func QuickSort(arr []int) []int {if len(arr) <= 1 {return arr}pivot := arr[0]var left, right []intfor i := 1; i < len(arr); i++ {if arr[i] < pivot {left = append(left, arr[i])} else {right = append(right, arr[i])}}left = QuickSort(left)right = QuickSort(right)return append(append(left, pivot), right...)
}

2. 归并排序

func MergeSort(arr []int) []int {if len(arr) <= 1 {return arr}mid := len(arr) / 2left := MergeSort(arr[:mid])right := MergeSort(arr[mid:])return merge(left, right)
}func merge(left, right []int) []int {result := make([]int, 0)for len(left) > 0 || len(right) > 0 {if len(left) == 0 {return append(result, right...)}if len(right) == 0 {return append(result, left...)}if left[0] <= right[0] {result = append(result, left[0])left = left[1:]} else {result = append(result, right[0])right = right[1:]}}return result
}

二、搜索算法

1. 二分查找

func BinarySearch(nums []int, target int) int {low, high := 0, len(nums)-1for low <= high {mid := low + (high-low)/2if nums[mid] == target {return mid} else if nums[mid] < target {low = mid + 1} else {high = mid - 1}}return -1
}

2. 广度优先搜索(BFS)

func BFS(graph map[int][]int, start int) []int {visited := make(map[int]bool)queue := []int{start}result := []int{}for len(queue) > 0 {node := queue[0]queue = queue[1:]if !visited[node] {visited[node] = trueresult = append(result, node)queue = append(queue, graph[node]...)}}return result
}

三、数据结构算法

1. 链表反转

type ListNode struct {Val  intNext *ListNode
}func ReverseList(head *ListNode) *ListNode {var prev *ListNodecurrent := headfor current != nil {next := current.Nextcurrent.Next = prevprev = currentcurrent = next}return prev
}

2. 二叉树遍历

type TreeNode struct {Val   intLeft  *TreeNodeRight *TreeNode
}// 前序遍历
func PreorderTraversal(root *TreeNode) []int {if root == nil {return nil}result := []int{root.Val}result = append(result, PreorderTraversal(root.Left)...)result = append(result, PreorderTraversal(root.Right)...)return result
}

四、动态规划

1. 斐波那契数列

func Fibonacci(n int) int {if n <= 1 {return n}dp := make([]int, n+1)dp[0], dp[1] = 0, 1for i := 2; i <= n; i++ {dp[i] = dp[i-1] + dp[i-2]}return dp[n]
}// 空间优化版
func FibonacciOptimized(n int) int {if n <= 1 {return n}a, b := 0, 1for i := 2; i <= n; i++ {a, b = b, a+b}return b
}

2. 最长公共子序列

func LongestCommonSubsequence(text1 string, text2 string) int {m, n := len(text1), len(text2)dp := make([][]int, m+1)for i := range dp {dp[i] = make([]int, n+1)}for i := 1; i <= m; i++ {for j := 1; j <= n; j++ {if text1[i-1] == text2[j-1] {dp[i][j] = dp[i-1][j-1] + 1} else {dp[i][j] = max(dp[i-1][j], dp[i][j-1])}}}return dp[m][n]
}func max(a, b int) int {if a > b {return a}return b
}

五、图算法

1. Dijkstra最短路径

func Dijkstra(graph map[int]map[int]int, start int) map[int]int {dist := make(map[int]int)for node := range graph {dist[node] = math.MaxInt32}dist[start] = 0pq := &PriorityQueue{}heap.Init(pq)heap.Push(pq, &Item{node: start, priority: 0})for pq.Len() > 0 {item := heap.Pop(pq).(*Item)u := item.nodefor v, weight := range graph[u] {if dist[v] > dist[u]+weight {dist[v] = dist[u] + weightheap.Push(pq, &Item{node: v, priority: dist[v]})}}}return dist
}// 优先队列实现省略...

2. 拓扑排序

func TopologicalSort(graph map[int][]int) []int {inDegree := make(map[int]int)for u := range graph {inDegree[u] = 0}// 计算入度for _, neighbors := range graph {for _, v := range neighbors {inDegree[v]++}}queue := []int{}for u, degree := range inDegree {if degree == 0 {queue = append(queue, u)}}result := []int{}for len(queue) > 0 {u := queue[0]queue = queue[1:]result = append(result, u)for _, v := range graph[u] {inDegree[v]--if inDegree[v] == 0 {queue = append(queue, v)}}}if len(result) != len(graph) {return nil // 有环}return result
}

六、字符串算法

1. KMP字符串匹配

func KMP(text, pattern string) int {lps := computeLPS(pattern)i, j := 0, 0for i < len(text) {if pattern[j] == text[i] {i++j++if j == len(pattern) {return i - j}} else {if j != 0 {j = lps[j-1]} else {i++}}}return -1
}func computeLPS(pattern string) []int {lps := make([]int, len(pattern))length := 0i := 1for i < len(pattern) {if pattern[i] == pattern[length] {length++lps[i] = lengthi++} else {if length != 0 {length = lps[length-1]} else {lps[i] = 0i++}}}return lps
}

2. Rabin-Karp字符串匹配

const primeRK = 16777619func RabinKarp(text, pattern string) int {n := len(text)m := len(pattern)if n < m {return -1}hashPattern := hashStr(pattern)hashText := hashStr(text[:m])if hashText == hashPattern && text[:m] == pattern {return 0}pow := 1for i := 0; i < m-1; i++ {pow *= primeRK}for i := m; i < n; i++ {hashText = (hashText-int(text[i-m])*pow)*primeRK + int(text[i])if hashText == hashPattern && text[i-m+1:i+1] == pattern {return i - m + 1}}return -1
}func hashStr(s string) int {h := 0for _, ch := range s {h = h*primeRK + int(ch)}return h
}

这些算法涵盖了Go语言开发中最常用的算法场景，建议结合实际需求进行优化和调整。