leetcode-labuladong-go语言实现

**LeetCode Labuladong Go语言实现**

Labuladong 是一个非常有名的算法学习网站，提供了大量的算法题目和解决方案。以下是对 LeetCode 上的一些常见问题的 Go语言实现。

### 一、链表相关问题####1.2.1. 删除链表的倒数第 N 个节点**删除链表的倒数第 N 个节点**

给定一个链表和一个整数 `n`，从链表中删除倒数第 `n` 个节点。

示例：

输入：`head = [1,2,3,4,5]`, `n =2`
输出：`[1,2,3,5]`

go// Definition for singly-linked list.
type ListNode struct {
Val intNext *ListNode}

func removeNthFromEnd(head *ListNode, n int) *ListNode {
	dummy := &ListNode{0, head}
	prev := dummy	for i :=0; i < n+1; i++ {
	prev = prev.Next}
	for prev != nil && prev.Next != nil {
	prev = prev.Next}
	prev.Next = prev.Next.Next	return dummy.Next}

####1.2.2. 检测链表是否有环**检测链表是否有环**

给定一个链表，判断链表是否有环。

示例：

输入：`head = [3,2,0,-4]`
输出：`true`

gofunc hasCycle(head *ListNode) bool {
	if head == nil || head.Next == nil {
	return false}
	slow := head	fast := head.Next	for slow != fast {
	if fast == nil || fast.Next == nil {
	return false}
	slow = slow.Next	fast = fast.Next.Next}
	return true}

### 二、树相关问题####2.1. 验证二叉树是对称的**验证二叉树是对称的**

给定一个二叉树，判断该树是否是对称的。

示例：

输入：`root = [1,2,2,3,4,null,null]`
输出：`true`

gofunc isSymmetric(root *TreeNode) bool {
	if root == nil {
	return true}
	return isMirror(root.Left, root.Right)
}

func isMirror(left, right *TreeNode) bool {
	if left == nil && right == nil {
	return true}
	if left == nil || right == nil {
	return false}
	return (left.Val == right.Val) && isMirror(left.Left, right.Right) && isMirror(left.Right, right.Left)
}

####2.2. 二叉树的最大深度**二叉树的最大深度**

给定一个二叉树，求该树的最大深度。

示例：

输入：`root = [3,9,20,null,null,15,7]`
输出：`3`

gofunc maxDepth(root *TreeNode) int {
	if root == nil {
	return0}
	return1 + max(maxDepth(root.Left), maxDepth(root.Right))
}

func max(a, b int) int {
	if a > b {
	return a}
	return b}

### 三、数组相关问题####3.1. 最长连续子序列**最长连续子序列**

给定一个整数数组，求该数组的最长连续子序列。

示例：

输入：`nums = [1,9,3,10,4,20,2]`
输出：`6`

gofunc longestConsecutive(nums []int) int {
	if len(nums) ==0 {
	return0}
	numsMap := make(map[int]bool)
	for _, num := range nums {
	numsMap[num] = true}

	maxLength :=1	for num, _ := range numsMap {
	if !numsMap[num-1] {
	currentNum := num	currentLength :=1	for numsMap[currentNum+1] {
	currentNum +=1	currentLength +=1}
	maxLength = max(maxLength, currentLength)
}
}

	return maxLength}

####3.2. 最小的 K 个数**最小的 K 个数**

给定一个整数数组和一个整数 `k`，从该数组中找出最小的 `k` 个数字。

示例：

输入：`nums = [4,5,8,9,10], k =3`
输出：`[4,5,8]`

gofunc topKFrequent(nums []int, k int) []int {
	if len(nums) ==0 || k ==0 {
	return nil}
	numsMap := make(map[int]int)
	for _, num := range nums {
	numsMap[num] +=1}

	var buckets [][]int	for _, count := range numsMap {
	buckets = append(buckets, []int{count, ...})
}

	sort.Slice(buckets, func(i, j int) bool {
	return buckets[i][0] < buckets[j][0]
})

	result := make([]int,0)
	for i :=0; i < k && i < len(buckets); i++ {
	result = append(result, buckets[i][1:])
}

	return result}

以上是对 LeetCode 上的一些常见问题的 Go语言实现。这些代码示例和注释可以帮助你更好地理解算法和数据结构的概念。