golang实现数组反转

在 Go 语言中实现数组（或切片）反转可以通过以下方法完成。以下是两种常用方式：原地反转（直接修改原切片）和返回新切片（保留原切片不变）。根据需求选择实现方式。

---

方法一：原地反转（直接修改原切片）

针对特定类型的实现（如 int）

package main

import "fmt"

// 反转 int 类型的切片（原地修改）
func reverseIntSlice(s []int) {
	for i := 0; i < len(s)/2; i++ {
		j := len(s) - 1 - i
		s[i], s[j] = s[j], s[i]
	}
}

func main() {
	arr := []int{1, 2, 3, 4, 5}
	reverseIntSlice(arr)
	fmt.Println(arr) // 输出: [5 4 3 2 1]

	arr2 := []int{1, 2, 3, 4, 5, 6}
	reverseIntSlice(arr2)
	fmt.Println(arr2) // 输出: [6 5 4 3 2 1]
}

使用泛型（Go 1.18+）支持任意类型

package main

import "fmt"

// 反转任意类型的切片（原地修改）
func reverseSlice[T any](s []T) {
    for i := 0; i < len(s)/2; i++ {
        j := len(s) - 1 - i
        s[i], s[j] = s[j], s[i]
    }
}

func main() {
    // 示例 1: int 类型
    arr1 := []int{1, 2, 3, 4, 5}
    reverseSlice(arr1)
    fmt.Println(arr1) // 输出: [5 4 3 2 1]

    // 示例 2: string 类型
    arr2 := []string{"a", "b", "c", "d"}
    reverseSlice(arr2)
    fmt.Println(arr2) // 输出: [d c b a]
}

---

方法二：返回新切片（保留原切片不变）

针对特定类型的实现

package main

import "fmt"

// 返回反转后的新 int 切片（原切片不变）
func reverseIntSliceCopy(s []int) []int {
    reversed := make([]int, len(s))
    copy(reversed, s)
    for i := 0; i < len(reversed)/2; i++ {
        j := len(reversed) - 1 - i
        reversed[i], reversed[j] = reversed[j], reversed[i]
    }
    return reversed
}

func main() {
    arr := []int{1, 2, 3, 4, 5}
    newArr := reverseIntSliceCopy(arr)
    fmt.Println(arr)    // 输出: [1 2 3 4 5]（原切片未修改）
    fmt.Println(newArr) // 输出: [5 4 3 2 1]
}

使用泛型实现

package main

import "fmt"

// 返回反转后的新切片（原切片不变）
func reverseSliceCopy[T any](s []T) []T {
    reversed := make([]T, len(s))
    copy(reversed, s)
    for i := 0; i < len(reversed)/2; i++ {
        j := len(reversed) - 1 - i
        reversed[i], reversed[j] = reversed[j], reversed[i]
    }
    return reversed
}

func main() {
    arr := []string{"a", "b", "c", "d"}
    newArr := reverseSliceCopy(arr)
    fmt.Println(arr)    // 输出: [a b c d]（原切片未修改）
    fmt.Println(newArr) // 输出: [d c b a]
}

---

关键点说明

1. 时间复杂度：两种方法的时间复杂度均为 O(n)，遍历一半元素完成交换。
2. 空间复杂度：
   • 原地反转：O(1)（不占用额外空间）。
   • 返回新切片：O(n)（需要复制原切片）。
3. 适用场景：
   • 原地反转适合直接修改数据的场景。
   • 返回新切片适合需要保留原数据的场景。

---

扩展：反转数组（非切片）

Go 中的数组是固定长度的，需明确指定长度和类型：

package main

import "fmt"

// 反转数组（需指定长度）
func reverseArray(arr *[5]int) {
    for i := 0; i < len(arr)/2; i++ {
        j := len(arr) - 1 - i
        arr[i], arr[j] = arr[j], arr[i]
    }
}

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    reverseArray(&arr) // 传递数组指针
    fmt.Println(arr)  // 输出: [5 4 3 2 1]
}

---

通过上述方法，可以灵活实现 Go 语言中数组或切片的反转操作。