链表、数组

283 移动0

func moveZeroes(nums []int)  {
    left := 0
    for i, num := range nums {
        if num != 0 {
            nums[left] = num
            if left != i {
                nums[i] = 0
            }
            left++
        }
    }
}

11 盛最多的水

func maxArea(height []int) int {
    left, right := 0, len(height) - 1
    maxArea := 0
    for left < right {
        area := min(height[left], height[right]) * (right - left)
        maxArea = max(maxArea, area)
        if height[left] < height[right] {
            left++
        } else {
            right--
        }
    }
    return maxArea
}

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

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

70 爬楼梯

func climbStairs(n int) int {
	if n < 4 {
		return n
	}
	a, b, c := 1, 2, 3
	for i := 3; i < n; i++ {
		a, b, c = b, a+b, b+c
	}
	return c
}

15 三数之和

func threeSum(nums []int) [][]int {
	sort.Ints(nums)
	var res [][]int
	for i := 0; i < len(nums)-2; i++ {
		if nums[i] > 0 {
			break
		}
		if i > 0 && nums[i] == nums[i-1] {
			continue
		}
		left, right := i+1, len(nums)-1
		for left < right {
			sum := nums[i] + nums[left] + nums[right]
			if sum == 0 {
				res = append(res, []int{nums[i], nums[left], nums[right]})
				for left < right && nums[left] == nums[left+1] {
					left++
				}
				for left < right && nums[right] == nums[right-1] {
					right--
				}
				left++
				right--
			} else if sum > 0 {
				left++
			} else {
				right--
			}
		}
	}
	return res
}

链表

206 反转链表

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
    var prev *ListNode
    for head != nil {
        next := head.Next
        head.Next = prev
        prev = head
        head = next
    }
    return prev
}

25 K个一组翻转链表

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseKGroup(head *ListNode, k int) *ListNode {
	cur := head
	// 校验是否够K个数、不够则返回
	for i := 0; i < k; i++ {
		if cur == nil {
			return head
		}
		cur = cur.Next
	}

	var prev, next *ListNode
	cur = head
	for i := 0; i < k; i++ {
		next = cur.Next
		cur.Next = prev
		prev = cur
		cur = next
	}

	head.Next = reverseKGroup(cur, k)
	return prev
}

24 两两交换链表中的节点

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func swapPairs(head *ListNode) *ListNode {
    if head == nil || head.Next == nil {
        return head
    }
    next := head.Next
    head.Next = swapPairs(head.Next.Next)
    next.Next = head
    return next
}

// 迭代 哨兵节点的优势是边界点明确、减少逻辑判断
// 循环时有三个点需要交换
func swapPairs(head *ListNode) *ListNode {
    dummy := &ListNode{0, head}
    curr := dummy
    for curr.Next != nil && curr.Next.Next != nil {
        prev := curr.Next
        next := curr.Next.Next
        curr.Next = next
        prev.Next = next.Next
        next.Next = prev
        curr = prev
    }
    return dummy.Next
}

141 环形链表

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func hasCycle(head *ListNode) bool {
	if head == nil || head.Next == nil {
		return false
	}
	left, right := head, head.Next
	for right != nil {
		if right.Next == nil {
			return false
		}
		if left == right {
			return true
		}
		left = left.Next
		right = right.Next.Next
	}
	return false
}