Go常见手搓demo

博客:cbb777.fun

全平台账号:安妮的心动录

github: https://github.com/anneheartrecord

下文中我说的可能对，也可能不对，鉴于笔者水平有限，请君自辨。有问题欢迎大家找我讨论

手搓快排

需要注意的点有两个
1.循环里两数交换的条件为 i < j 意味着左指针还在右指针的左侧 即两者还没相遇
2.递归的时候一个是j 一个是j+1 把数组一分为二进行递归

func main() {
    nums := []int{3, 1, 2, 4, 6, 5}
    quickSort(nums, 0, len(nums)-1)
    fmt.Println(nums)
}

func quickSort(nums []int, l, r int) {
    if l >= r {
        return
    }
    i, j, mid := l-1, r+1, nums[(l+r)/2]
    for i < j {
        i++
        for nums[i] < mid {
            i++
        }
        j--
        for nums[j] > mid {
            j--
        }
        if i < j {
            nums[i], nums[j] = nums[j], nums[i]
        }
    }
    quickSort(nums, l, j)
    quickSort(nums, j+1, r)
}

手搓堆排

需要注意的点：
1.heapify用来递归做调整 其中heapSize表示堆大小 i表示要操作的节点下标 left 和 right 的值分别是 2i+1 与 2i+2
2.buildHeap和heapify都传参都是i,n，而堆排的时候是维护一个当前大小的堆，所以是0,i

func main() {
    nums := []int{3, 1, 2, 4, 6, 5}
    heapSort(nums)
    fmt.Println(nums)
}

func buildHeap(nums []int, heapSize int) {
    for i := heapSize / 2; i >= 0; i-- {
        heapify(nums, i, heapSize)
    }
}

func heapSort(nums []int) {
    heapSize := len(nums)
    buildHeap(nums, heapSize)
    for i := heapSize - 1; i >= 0; i-- {
        nums[i], nums[0] = nums[0], nums[i]
        heapify(nums, 0, i)
    }
}

func heapify(nums []int, i, heapSize int) {
    largest := i
    left, right := 2*i+1, 2*i+2
    if left < heapSize && nums[left] > nums[largest] {
        largest = left
    }
    if right < heapSize && nums[right] > nums[largest] {
        largest = right
    }
    if largest != i {
        nums[largest], nums[i] = nums[i], nums[largest]
        heapify(nums, largest, heapSize)
    }
}

实现一个生产者-消费者模型

要注意的就是
通过select来实现一有消息就读，如果读完就退出
那怎么判断是否读完呢？这里就需要生产者主动关闭channel了

func main() {
    ch := make(chan int,10)
    go Processor(ch)
    go Consumer(ch)
  //睡一会
    time.Sleep(15 * time.Second)
}

func Processor(ch chan int) {
    for i := 0; i < 10; i++ {
        ch <- i
        // 模拟发时间的时延 这里可有可无
        //time.Sleep(1 * time.Second)
        fmt.Println("process:", i)
    }
    close(ch)
}

func Consumer(ch chan int) {
    for {
        select {
      // 有数据就读出来 关闭了就退出
        case i, ok := <-ch:
            if ok {
                fmt.Println("consumer:", i)
            } else {
                fmt.Println("over!")
                return
            }
        }
    }
}

实现两个goroutine打印奇偶数

需要注意的点是
关闭通道的时候需要异步进行，也就是异步Wait()，然后立马关掉ch
同步的话会有一个问题就是Even和Odd都往这个ch中写东西了，但是没有人去消费它，所以我们只能选择手动关闭。但是等待for range完毕，然后同步关闭的话会导致ch阻塞（因为for range不是消费）

func Even(wg *sync.WaitGroup, ch chan int) {
    defer wg.Done()
    for i := 0; i <= 100; i += 2 {
        ch <- i
    }
}

func Odd(wg *sync.WaitGroup, ch chan int) {
    defer wg.Done()
    for i := 1; i <= 100; i += 2 {
        ch <- i
    }
}

func main() {
    var wg sync.WaitGroup
    ch := make(chan int)
    wg.Add(2)
    go Even(&wg, ch)
    go Odd(&wg, ch)
    go func() {
        wg.Wait()
        close(ch)
    }()
    for v := range ch {
        fmt.Println("number:", v)
    }
}

实现两个goroutine交替打印奇偶数

需要注意的点：
通道必须得是有缓冲的，不然在main goroutine中往里面<-1就会阻塞住，下面的go协程就不会执行了

func Even(ch chan int) {
    for i := 0; i <= 100; i += 2 {
        <-ch
        fmt.Println("number:", i)
        ch <- 1
    }
}

func Odd(ch chan int) {
    for i := 1; i <= 100; i += 2 {
        <-ch
        fmt.Println("number:", i)
        ch <- 1
    }
}

func main() {
    ch := make(chan int, 1)
    ch <- 1
    go Even(ch)
    go Odd(ch)
    time.Sleep(time.Second)
}

本文由mdnice多平台发布