排序算法go实现

package main

import (
    "fmt"
)

func heapSort(arr []int) {
    length := len(arr)
    mid := length / 2

    // 从非叶子节点开始从下往上调整堆，结束循环后堆排序建立完毕
    for i := mid; i >= 0; i-- {
        heap(arr, i, length-1)
    }
    // 堆顶是最大的了, 取出第一个放到最后,然后从上往下调整堆
    for i := length - 1; i > 0; i-- {
        arr[i], arr[0] = arr[0], arr[i]
        heap(arr, 0, i-1)
    }
}

// 调整堆
func heap(arr []int, i int, last int) {
    left := 2*i + 1
    if left > last {
        return
    }
    max := left
    right := 2*i + 2

    // 如果右子树大, 取右边的
    if right <= last && arr[right] > arr[left] {
        max = right
    }

    if arr[i] > arr[max] {
        return
    }

    //交换, 父节点和两个子节点中大的交换一下
    arr[i], arr[max] = arr[max], arr[i]
    // 有调整，那子节点要重新调整一下
    heap(arr, max, last)
}

// 快排
func qsort(a []int) {
    n := len(a)
    if n <= 1 {
        return
    }
    pivot := a[0]
    low, high := 0, n-1
    for low < high {
        for low < high && a[high] > pivot {
            high--
        }
        a[low] = a[high]

        for low < high && a[low] < pivot {
            low++
        }
        a[high] = a[low]
    }
    a[low] = pivot
    qsort(a[:low])
    qsort(a[low+1:])
}

func main() {
    arr := []int{20, 30, 8, 5, 100}
    // 最大堆，按照从小到大的排序
    heapSort(arr)
    fmt.Println(arr)

    // 快排
    fmt.Println("quick sort")
    arr2 := []int{20, 30, 8, 5, 100}
    qsort(arr2)
    fmt.Println(arr2)
}