排序算法 go

package main

import (
    "fmt"
)

func QuickSort(arr []int) {
    if len(arr) < 2 {
        return
    }
    left, right := -1, len(arr)
    pivot := arr[(left+right)>>1]
    for left < right {
        for {
            left++
            if arr[left] >= pivot {
                break
            }

        }
        for {
            right--
            if arr[right] <= pivot {
                break
            }
        }
        if left < right {
            arr[left], arr[right] = arr[right], arr[left]
        }
    }
    QuickSort(arr[:right+1])
    QuickSort(arr[right+1:])
}

func main() {
    arr := []int{-2, 3, -5}
    QuickSort(arr)
    fmt.Println(arr)
}

package main

import "fmt"

func mergeSort(arr []int) {
    if len(arr) < 2 {
        return
    }
    mid := len(arr)>>1 - 1
    mergeSort(arr[:mid+1])
    mergeSort(arr[mid+1:])
    tmp := make([]int, 0, len(arr))
    l, r := 0, mid+1
    for l <= mid || r <= len(arr)-1 {
        if l > mid || (r <= len(arr)-1 && arr[r] < arr[l]) {
            tmp = append(tmp, arr[r])
            r++
        } else {
            tmp = append(tmp, arr[l])
            l++
        }
    }
    copy(arr, tmp)
}

func main() {
    arr := []int{-2, 3, -5}
    mergeSort(arr)
    fmt.Println(arr)
}

package main

import (
    "fmt"
)

func heapMax(arr []int) {
    if len(arr) < 2 {
        return
    }
    depth := len(arr)>>1 - 1
    for i := depth; i > -1; i-- {
        down(arr, i)
    }
    for i := len(arr) - 1; i > -1; i-- {
        arr[0], arr[i] = arr[i], arr[0]
        down(arr[:i], 0)
    }
}

func down(arr []int, i int) {
    max := i
    leftChild := i<<1 + 1
    rightChild := i<<1 + 2
    if leftChild < len(arr) && arr[leftChild] > arr[max] {
        max = leftChild
    }
    if rightChild < len(arr) && arr[rightChild] > arr[max] {
        max = rightChild
    }
    if max != i {
        arr[i], arr[max] = arr[max], arr[i]
        down(arr, max)
    }
}

func main() {
    arr := []int{5, 2, 3, 1}
    heapMax(arr)
    fmt.Println(arr)
}