编程练习题（答案版）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func main() {
	test(4)
}

func test(n int) {
    if n > 2 {
       n--
       test(n)
    }
    fmt.Println("n=", n)
}

1
2
3

n= 2
n= 2
n= 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func main() {
    mySuffix := makeSuffix(".jpg") // 先获得一个闭包

    fmt.Println(mySuffix("hello.jpg")) // hello.jpg
    fmt.Println(mySuffix("winter"))    // winter.jpg
    fmt.Println(mySuffix("pic.png"))   // pic.png.jpg

}
func makeSuffix(suffix string) func(string) string {
    return func(name string) string {
       if strings.HasSuffix(name, suffix) {
          return name
       } else {
          return name + suffix
       }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 冒泡排序：每轮使1个数在正确的位置上，需要双层循环
// 外层循环：控制循环的轮数，每轮排好1个数
// 内层循环：从外层循环的i值开始，表示第i个元素是即将需要参与排序的数
func bubbleSort(arr *[10]int) {
	for i := 0; i < len(arr)-1; i++ { // 控制循环的轮数
		for j := i; j > 0; j-- { // // 控制实际参与排序的数字
			if arr[j] < arr[j-1] {
				temp := arr[j]
				arr[j] = arr[j-1]
				arr[j-1] = temp
			}
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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

    pivot := arr[0] // 选择第一个元素作为基准
    var left, right []int

    for 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...)
}

func main() {
    // 待排序的切片
    arr := []int{64, 34, 25, 12, 22, 11, 90}

    fmt.Println("未排序的数组：", arr)
    arr = quickSort(arr)
    fmt.Println("排序后的数组：", arr)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

func main() {
  arr := []int{3, 8, 1, 5, 4, 7, 6, 9, 2}
  QuickSort2(0, len(arr)-1, arr)
  fmt.Println(arr)
}

func QuickSort2(low, high int, arr []int) {
    if low < high {
       pivotIndex := partition(low, high, arr) // 选择分区点并获取分区点的索引
       QuickSort2(low, pivotIndex, arr)        // 递归排序分区点左侧的子数组
       QuickSort2(pivotIndex+1, high, arr)     // 递归排序分区点右侧的子数组
    }
}

// partition 将数组分成两部分，左侧的元素都小于或等于基准元素，右侧的元素都大于基准元素。
// 这是快速排序算法中的关键步骤，它在原地（in-place）完成，不需要额外的内存空间。
func partition(low, high int, arr []int) int {
    pivot := arr[(low+high)/2] // 选择最中间的元素作为基准
    i, j := low, high

    for {
       for arr[i] < pivot {
          i++
       }
       for arr[j] > pivot {
          j--
       }
       if i >= j {
          return j
       }
       arr[i], arr[j] = arr[j], arr[i]
       i++
       j--
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main

import "fmt"

func main() {
 arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8}
 binarySearch(&arr, 0, len(arr)-1, 8)
}
func binarySearch(arr *[8]int, leftIndex int, rightIndex int, findElem int) {

 // 当leftIndex大于rightIndex时，表示未找到指定元素
 if leftIndex > rightIndex {
    fmt.Println("找不到")
    return
 }
 middleIndex := (leftIndex + rightIndex) / 2
 middleElem := arr[middleIndex]

 if findElem < middleElem {
    binarySearch(arr, leftIndex, middleIndex-1, findElem)
 } else if findElem > middleElem {
    binarySearch(arr, middleIndex+1, rightIndex, findElem)
 } else {
    fmt.Println("找到了，下标为：", middleIndex)
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 二分查找，一定要注意区间的定义，是左闭右闭还是左闭右开。
// 这里我们采用左闭右闭。
func search(nums []int, target int) int {
    left := 0
    right := len(nums) - 1
    for left <= right {
       middle := (left + right) / 2
       if target < nums[middle] {
          right = middle - 1
       } else if target > nums[middle] {
          left = middle + 1
       } else {
          return middle
       }
    }
    return -1
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

package main

import (
    "fmt"
    "math/rand"
    "sort"
    "strconv"
)

type Student struct {
    name  string
    age   int
    score int
}

// StuSlice 定义一个切片类型，存放多个学生
type StuSlice []Student

// 实现Interface接口中的三个方法：Len、Less、Swap
func (s StuSlice) Len() int {
    return len(s)
}

func (s StuSlice) Less(i, j int) bool {
    return s[i].age < s[j].age
}

// Swap 将切片中的元素进行交换
func (s StuSlice) Swap(i, j int) {
    s[i], s[j] = s[j], s[i]
}
func main() {
    s1 := StuSlice{}

    for i := 0; i < 10; i++ {
       s1 = append(s1, Student{"stu" + strconv.Itoa(i),
          int(float32(rand.Intn(101))*0.1 + 15), // 生成15-25之间的随机数
          rand.Intn(101)})                       // 生成0-100之间的随机数
    }

    for i := 0; i < 10; i++ {
       fmt.Printf("%v\n", s1[i])
    }
    fmt.Println("-----排序后-----")
    sort.Sort(s1)
    for i := 0; i < 10; i++ {
       fmt.Printf("%v\n", s1[i])
    }
}

1

630

1
2

3
5*6*7

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

func main() {
	var num int
	fmt.Scanln(&num)
	count, factorSlice := test(num)
	fmt.Println(count)
	var resultStr string
	for i := 0; i < len(factorSlice); i++ {
		if i < len(factorSlice)-1 {
			resultStr += strconv.Itoa(factorSlice[i]) + "*"
		} else {
			resultStr += strconv.Itoa(factorSlice[i])
		}
	}
	fmt.Println(resultStr)
}
func test(num int) (int, []int) {
    
    // 先遍历出所有小于根号num的因子
	var factor []int
	for i := 2; i*i < num; i++ {
		if num%i == 0 {
			factor = append(factor, i)
			// fmt.Printf("%d ", i)
		}
	}
    
    // 然后遍历因子列表，统计最大的连续因子的数量
	count := 1
	maxLength := 1
	for i := 0; i < len(factor)-1; i++ {
		if factor[i+1] == factor[i]+1 {
			count++
		} else {
			if count > maxLength {
				maxLength = count
			}
			count = 1
		}
	}
    
    // 然后再次遍历因子列表，求得连续的因子序列
	var resultSlice []int
	for i := 0; i < len(factor); i++ {
		if factor[i]+maxLength-1 == factor[i+maxLength-1] {
			resultSlice = factor[i : i+maxLength]
			break
		}
	}
	return maxLength, resultSlice
}

1
2

Z：0 1 2 3 4 5 6 7 8 9 10
M：1 0 X 9 8 7 6 5 4 3 2

1
2
3
4
5

4
320124198808240056
12010X198901011234
110108196711301866
37070419881216001X

1
2
3

12010X198901011234
110108196711301866
37070419881216001X

1
2
3

2
320124198808240056
110108196711301862

1

All passed

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	var numCount int
	allPass := true
	fmt.Scanln(&numCount)

	var idCardList = make([]string, numCount)
	for i := 0; i < numCount; i++ {
		var idCard string
		fmt.Scanln(&idCard)
		idCardList[i] = idCard
	}
	for _, idCard := range idCardList {
		if !identity(idCard) {
			fmt.Println(idCard)
			allPass = false
		}
	}
	if allPass {
		fmt.Println("All passed")
	}
}

func identity(str string) bool {
	lenStr := len(str)
	lastStr := string(str[lenStr-1]) // 最后一个字符
	sum := 0
	weightArray := []int{7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2}
	mArray := []string{"1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"}
	for i := 0; i < lenStr-1; i++ { // 注意，这里不包括最后一位
		indexNum, err := strconv.Atoi(string(str[i])) // 注意：这里的str[i]为byte(uint8)，直接转为int得到的是其ascii码的值，如数字1得到的是49。所以要先转换成string，然后再将string转换成int。
		if err != nil {
			return false
		}
		sum += indexNum * weightArray[i] // 每位的值分别与权重相乘
	}
	z := sum % 11
	return mArray[z] == lastStr // 最后一位与加权运算得到的结果是否一致
}

1
2
3
4
5
6
7
8

val, err := Atoi("123")
// val 应该为 123，err 应该为 nil

val, err := Atoi("-456")
// val 应该为 -456，err 应该为 nil

val, err := Atoi("12a34")
// val 应该为 0，err 应该包含合适的错误信息

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

func Atoi(s string) (int64, error) {
    s0 := s
    if s[0] == '-' || s[0] == '+' {
       s = s[1:]
    }
    var n int64
    for _, ch := range []byte(s) { // 将s转为byte的切片，并遍历
       ch -= '0' // 将一个ch（Unicode码点）转换为相应的整数值。如果ch包含字符'3'，执行ch-='0'之后，ch将变成整数3。
       if ch > 9 {  // 若ch大于9，则表示该字符非法
          return 0, errors.New("`" + string(ch+'0') + "`为非法字符，类型转换出错！")
       }
       n = n*10 + int64(ch)
    }
    if s0[0] == '-' {
       n = -n
    }
    return n, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

type Singleton struct {}

var singleInstance *Singleton
var once sync.Once

func GetSingletonObj() *Singleton {
    once.Do(func() { // 只执行一次
       fmt.Println("Create Obj")
       singleInstance = new(Singleton)
    })
    return singleInstance
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
       wg.Add(1)
       go func() {
          obj := GetSingletonObj()
          fmt.Printf("%x\n", unsafe.Pointer(obj)) // 可以看到，这里打印的地址值是相同的，说明只创建了一个实例对象。
          wg.Done()
       }()
    }
    wg.Wait()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

var mu sync.Mutex
var instance *Singleton

type Singleton struct {
    // 在这里定义单例的属性
    Value int
}

// GetInstance 返回单例实例
func GetInstance() *Singleton {
    if instance == nil {
        mu.Lock()
        defer mu.Unlock()
        if instance == nil {
            instance = &Singleton{
                Value: 42, // 这里可以初始化单例的属性
            }
        }
    }
    return instance
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

var (
    wg      sync.WaitGroup
    taskNum = 5
)

func main() {
    ticker := time.NewTicker(time.Second) // 使用time.NewTicker()的方式，每隔1s执行一次定时任务
    count := 0
    wg.Add(1)
    go func() {
       defer wg.Done()
       defer ticker.Stop()
       for {
          count++
          t := <-ticker.C
          fmt.Println(t)
          if count >= taskNum { // 控制定时任务执行的次数
             return
          }
       }
    }()
    wg.Wait()
    fmt.Println("程序结束！")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

type ReusableObj struct {}

type ObjPool struct {
    bufChan chan *ReusableObj
}

func NewObjPool(numOfObj int) *ObjPool {
    objPool := ObjPool{}
    objPool.bufChan = make(chan *ReusableObj, numOfObj)
    for i := 0; i < numOfObj; i++ {
       objPool.bufChan <- &ReusableObj{}
    }
    return &objPool
}

func (p *ObjPool) GetObj(timeout time.Duration) (*ReusableObj, error) {
    select {
    case ret := <-p.bufChan:
       return ret, nil
    case <-time.After(timeout): // 超时控制
       return nil, errors.New("time out")
    }
}

func (p *ObjPool) ReleaseObj(obj *ReusableObj) error {
    select {
    case p.bufChan <- obj:
       return nil
    default:
       return errors.New("overflow")
    }
}

func main() {
    pools := NewObjPool(10)

    for i := 0; i < 10; i++ { // 在不放回的情况下，如果取的数量超过了连接池中连接的数量，会报超时的错误。
       if v, err := pools.GetObj(time.Second); err != nil {
          panic(err)
       } else {
          fmt.Println("v:", unsafe.Pointer(v))

          // 对连接进行的操作....

          if err := pools.ReleaseObj(v); err != nil { // 操作完成后，将连接放回连接池
             panic(err)
          }
       }
    }
    fmt.Println("Done")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func main() {
    result := GetRandomString(4) // 生成长度为4的随机字符串
    fmt.Println("result:", result)
}

func GetRandomString(n int) string { // 这里的n代表生成的字符串长度
    str := "0123456789abcdefghijklmnopqrstuvwxyz" // 可选的字符集
    var result []byte
    r := rand.New(rand.NewSource(time.Now().UnixNano())) // 指定随机种子
    for i := 0; i < n; i++ {
       result = append(result, str[r.Intn(len(str)-1)])
    }
    return string(result)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

func main() {
    array := []int{1, 6, 6, 8, 6, 1, 2, 2, 2}
    res := removeDuplicates(array)
    fmt.Println(res) // [1 6 8 2]
}

// 删除重复元素
func removeDuplicates(array []int) []int {
    mapData := make(map[int]bool)
    var result []int
    for _, value := range array {
       _, exist := mapData[value] // 使用map探测重复元素
       if !exist {
          mapData[value] = true
          result = append(result, value)
       }
    }
    return result
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

type Mankind struct {
    Name   string `json:"name"`
    Age    int    `json:"age"`
    Gender string `json:"gender"`
}

func (m *Mankind) Introduce() {
    fmt.Printf("My name is %v, %v years old!\n", m.Name, m.Age)
}

func main() {
	m1 := Mankind{"Jerry", 25, "male"}
    // 定义名为callStructure的函数，完成题目要求的功能。
}
func callStructure() {

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

type Mankind struct {
    Name   string `json:"name"`
    Age    int    `json:"age"`
    Gender string `json:"gender"`
}

func (m *Mankind) Introduce() { // 使用指针接收者的方法，在反射调用时和普通的方法略有不同
    fmt.Printf("My name is %v, %v years old!\n", m.Name, m.Age)
}

func main() {
    m1 := Mankind{"Jerry", 25, "male"}
    callStructure(&m1) // 要修改属性值，这里必须传入地址
}
func callStructure(m *Mankind) { // 指针方式接收形参
    structValue := reflect.ValueOf(m).Elem() // “解引用”

    // 遍历属性和标签
    for i := 0; i < structValue.NumField(); i++ {
       field := structValue.Field(i)
       fieldName := structValue.Type().Field(i).Name
       tag := structValue.Type().Field(i).Tag.Get("json")

       fmt.Printf("field[%v] is %v, value is %v, tag is %v\n", i, fieldName, field, tag)

       // 设置属性值
       if field.CanSet() {
          if fieldName == "Name" { // 根据字段名修改字段值
             field.SetString("Alice")
          }
          if fieldName == "Age" {
             field.SetInt(28)
          }
          if fieldName == "Gender" {
             field.SetString("female")
          }
       }
    }
    fmt.Println("属性值修改成功！")

    // 调用结构体方法
    // method := structValue.MethodByName("Introduce")  // 这样写无法调用指针接收者方法Introduce
    method := reflect.ValueOf(m).MethodByName("Introduce") // 由于Introduce是指针接收者方法，所以这里应该用指针（解引用之前）来调用该方法。
    if method.IsValid() {
       method.Call(nil)
    } else {
       fmt.Println("方法调用失败！")
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

type CircleQueue struct {
    maxSize int
    array   [5]int
    head    int // head指向下一个弹出元素的位置
    tail    int // tail指向下一个添加元素的位置
}

// Push 向队列中添加元素
func (queue *CircleQueue) Push(data int) (err error) {
    if (queue.tail+1)%queue.maxSize == queue.head { // 队列已满
       return errors.New("queue full")
    }
    queue.array[queue.tail] = data
    queue.tail = (queue.tail + 1) % queue.maxSize
    return
}

// Pop 从队列中弹出元素
func (queue *CircleQueue) Pop() (data int, err error) {
    if queue.head == queue.tail { // 队列为空
       return -1, errors.New("queue empty")
    }
    data = queue.array[queue.head]
    queue.head = (queue.head + 1) % queue.maxSize
    return data, nil
}

func (queue *CircleQueue) ShowCircleQueue() {
    queueLen := (queue.tail - queue.head + queue.maxSize) % queue.maxSize // 队列中元素个数
    if queueLen == 0 {
       fmt.Println("queue is empty")
       return
    }
    originalHead := queue.head
    for i := 1; i <= queueLen; i++ { // 遍历队列长度个元素
       fmt.Printf("array[%d]=%d\t", i, queue.array[originalHead])
       originalHead = (originalHead + 1) % queue.maxSize
    }
    fmt.Println()
}

func main() {

    // 先创建一个队列
    queue := CircleQueue{
       maxSize: 5,
       head:    0,
       tail:    0,
    }

    // 添加数据
    var key string
    var val int

    fmt.Println("1. 输入push 表示添加数据到队列")
    fmt.Println("2. 输入pop 表示从队列中获取数据")
    fmt.Println("3. 输入show 表示显示队列")
    fmt.Println("4. 输入exit 表示退出")

    for {
       fmt.Printf("请输入指令：")

       if _, err := fmt.Scanln(&key); err != nil {
          panic(err)
       }

       keyMap := map[string]struct{}{"pop": struct{}{}, "push": struct{}{}, "show": struct{}{}, "exit": struct{}{}}
       if _, exist := keyMap[key]; !exist { // 输入的指令不正确
          fmt.Println("请输入正确的指令（add/get/show/exit）！")
          continue
       }

       switch key {
       case "push":
          fmt.Printf("输入需要添加到队列的数据：")
          _, err := fmt.Scanln(&val)
          if err != nil {
             panic(err)
          }

          if err := queue.Push(val); err != nil {
             fmt.Println(err.Error())
          } else {
             fmt.Println("加入队列成功！")
          }
       case "pop":
          data, err := queue.Pop()
          if err != nil {
             fmt.Println(err.Error())
          } else {
             fmt.Printf("取出元素：%d\n", data)
          }
       case "show":
          fmt.Printf("当前队列为：")
          queue.ShowCircleQueue()
       case "exit":
          os.Exit(0)
       }
    }
}

1
2
3
4
5
6

func InitRing(num int) *JosephusRing{}  // num:初始化成员的数量
func GetRingElems(first *JosephusRing) {}  // first:Josephus环的第一个成员的指针
func PlayGame(first *JosephusRing, startNo int, countNo int) {}  
// first:Josephus环的第一个成员的指针
// startNo:开始计数的成员的ID号（从1开始）。
// countNo:每次数数的步数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

type JosephusRing struct {
    id   int
    next *JosephusRing
}

func InitRing(num int) *JosephusRing { // 指定成员的个数进行初始化环
    first := &JosephusRing{}
    last := &JosephusRing{}
    if num < 1 {
       fmt.Println("成员数量至少为1！")
       return nil
    }
    for i := 1; i <= num; i++ {
       rData := &JosephusRing{
          id: i,
       }
       if i == 1 { // 第一个成员
          first = rData     // first指向链表的第一个元素，此后就不再改变
          last = rData      // 通过移动last来实现链表元素的增长，初始值为第一个元素
          last.next = first // 将新加入的元素指向first
       } else {
          last.next = rData // 将新的元素加入链表，并将last指向新的元素
          rData.next = first
          last = rData
       }
    }
    return first
}

func GetRingElems(first *JosephusRing) {
    if first.next == nil {
       fmt.Println("链表为空，没有任何成员！")
       return
    }
    last := first
    fmt.Println()
    for {
       fmt.Printf("[id=%d]--->", last.id)
       if last.next == first { // 遍历到最后一个元素了
          break
       }
       last = last.next
    }
}

func PlayGame(first *JosephusRing, startNo int, countNo int) {
    if first.next == nil {
       fmt.Println("链表为空！")
       return
    }
    last := first // 需要一个last指针指向最后(也就是first之前的那个元素)，因为要删除first结点，必须要找打它的前一个结点
    for {         // 将last指向最后的元素
       if last.next == first {
          break
       }
       last = last.next
    }
    // 让first和last都移动startNo-1次（移动到起始位置）（因为startNo表示的是开始的编号，但first已经指向第1个元素了，所以只需要移动startNo-1次）
    for i := 1; i <= startNo-1; i++ {
       first = first.next
       last = last.next
    }
    // 游戏开始，开始数数（countNo）
    // first始终指向的是要删除的成员
    for {
       // 移动countNo-1次（因为成员自身也算一次）
       for i := 1; i <= countNo-1; i++ {
          first = first.next
          last = last.next
       }

       // 删除first指向的结点
       fmt.Printf("\nid=%d的元素被删除！", first.id)
       first = first.next
       last.next = first

       // 循环的终止条件：链表中只有一个元素（first=last）
       if last == first {
          break
       }
    }
    fmt.Printf("\nid=%d的元素被删除！", first.id)
}

func main() {
    first := InitRing(5)
    GetRingElems(first)
    PlayGame(first, 2, 3)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package main

/**
    从小到大排序
    选择排序：每轮选择一个无需中的最小值，n-1轮后，数组有序。
    技巧：先写内层循环，然后再嵌套一个外层循环。
    先假设我们只需要找一次最小值，具体操作如下：
       1.假设arr[0]就是最小元素(min=arr[0])；（注意：需要使用一个变量index记录下标0，后面交换的时候要用到）
       2.遍历数组的每个元素，依次与min进行比较，如果有比min值更小的，则更新min的值和下标index；
       3.交换arr[0]和arr[index]的值。
    这样就完成了一次最小值的排序，我们只需要在外面嵌套一层for循环，将0改成循环变量j即可。这样就大大简化了我们写代码的过程。
*/

func main() {
  arr := []int{3, 8, 1, 5, 4, 7, 6, 9, 2}
  result := SelectionSort(arr)
  fmt.Println(result)
}

func SelectionSort(arr []int) []int {
    newArr := arr
    for j := 0; j < len(arr)-1; j++ {
       //minArr := newArr[j] // 之前用了一个变量来存最小值，后面发现可以优化一下，只需要记录下标minIndex就可以了，所以将这里注释掉
       minIndex := j
       for i := j + 1; i < len(arr); i++ { // 找出最小值的下标
          if newArr[i] < newArr[minIndex] {
             minIndex = i // 更新minIndex
          }
       }
       newArr[minIndex], newArr[j] = newArr[j], newArr[minIndex]
    }
    return newArr
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package main

import "fmt"

/**
* Description:
	技巧：也是和选择排序一样，先写内层循环，然后再嵌套一层循环。
* @Author Hollis
* @Create 2023-10-12 18:20
 */

func main() {
    arr := []int{3, 8, 1, 5, 4, 7, 6, 9, 2}
    result := InsertSort(arr)
    fmt.Println(result)
}

func InsertSort(arr []int) []int {
    newArr := arr
    for i := 1; i <= len(newArr)-1; i++ {
       // 先确定第二个元素应该插入的位置
       insertVal := newArr[i]
       insertIndex := i - 1

       for insertIndex >= 0 && newArr[insertIndex] > insertVal {
          newArr[insertIndex+1] = newArr[insertIndex]
          insertIndex--
       }
       if insertIndex+1 != i {
          newArr[insertIndex+1] = insertVal
       }
    }
    return newArr
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func main() {
    myHashMap := Constructor() // 创建哈希表实例

    myHashMap.Insert("apple", 1) // 插入键值对
    myHashMap.Insert("banana", 2)
    myHashMap.Insert("cherry", 3)

    fmt.Println(myHashMap.Get("apple")) // 输出: 1
    fmt.Println(myHashMap.Get("banana")) // 输出: 2

    myHashMap.Delete("banana") // 删除键值对
    fmt.Println(myHashMap.Get("banana")) // 输出: -1
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

type MyHashMap struct {
    data [1000][]KeyValue
}

type KeyValue struct {
    key   string
    value int
}

/** Initialize your data structure here. */
func Constructor() MyHashMap {
    return MyHashMap{}
}

/** value will always be non-negative. */
func (this *MyHashMap) Insert(key string, value int) {
    index := hash(key)
    for i, kv := range this.data[index] {
        if kv.key == key {
            this.data[index][i].value = value
            return
        }
    }
    this.data[index] = append(this.data[index], KeyValue{key, value})
}

/** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
func (this *MyHashMap) Get(key string) int {
    index := hash(key)
    for _, kv := range this.data[index] {
        if kv.key == key {
            return kv.value
        }
    }
    return -1
}

/** Removes the mapping of the specified value key if this map contains a mapping for the key */
func (this *MyHashMap) Delete(key string) {
    index := hash(key)
    for i, kv := range this.data[index] {
        if kv.key == key {
            this.data[index] = append(this.data[index][:i], this.data[index][i+1:]...)
            return
        }
    }
}

func hash(s string) int {
    h := 0
    for _, ch := range s {
        h = 31*h + int(ch)
    }
    return h % 1000
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

func main() {
    arr := []int{3, 8, 1, 5, 4, 7, 6, 9, 2}
    help := make([]int, len(arr))
    MergeSort(arr, help, 0, len(arr)-1)
    fmt.Println(arr)
}

func MergeSort(arr, help []int, left, right int) {
    if left >= right {
       return
    }

    middle := left + (right-left)>>1      // 求中点
    MergeSort(arr, help, left, middle)    // 左部分有序
    MergeSort(arr, help, middle+1, right) // 右部分有序

    Merge(arr, help, left, middle, right) // 将左右数组合并到help数组中（middle参数用来分割左右数组）
}

func Merge(arr, help []int, left, middle, right int) { // 左：left...middle，右：middle+1...right。help为辅助辅助，存放合并后的值。
    p1 := left
    p2 := middle + 1
    i := left // 两个数组中比较出来的数字，应该放在help数组中的位置
    for ; p1 <= middle && p2 <= right; i++ {
       if arr[p1] <= arr[p2] {
          help[i] = arr[p1]
          p1++
       } else {
          help[i] = arr[p2]
          p2++
       }
    }
    for ; p1 <= middle; i++ {  // 将p1或p2中剩下的元素添加到help数组中
       help[i] = arr[p1]
       p1++
    }
    for ; p2 <= right; i++ {
       help[i] = arr[p2]
       p2++
    }
    for i := left; i <= right; i++ {
       arr[i] = help[i]
    }
}