Golang实现七大排序(2)

1. 计数排序

func Count(arr []int, nLength int) {
    if nil == arr || nLength <= 0 {
        return
    }
    var max int = 0
    for i := 0; i < nLength; i++ {
        if arr[i] > max {
            max = arr[i]
        }
    }

    var arrTemp []int = make([]int, max+1)

    for i := 0; i < nLength; i++ {
        arrTemp[arr[i]]++
    }
    var j int = 0
    for i := 0; i < max+1; i++ {
        if arrTemp[i] > 0 {
            arr[j] = i
            arrTemp[i]--
            j++
        }

    }
}

2. shell排序

func Shell(arr []int, nLength int) {
    if nil == arr || nLength <= 0 {
        return
    }
    fmt.Println("nLength:", nLength)
    // 确定步长
    for gap := nLength / 2; gap >= 1; gap /= 2 {
        fmt.Println("gap:", gap)
        // 对每一个步长对应的数组进行插入排序
        for i := gap; i < nLength; i += gap {
            flag := i - gap
            temp := arr[i]
            for flag >= 0 && arr[flag] > temp {
                arr[flag+gap] = arr[flag]
                flag -= gap
            }
            arr[flag+gap] = temp
        }
    }
}

3. 合并排序

func Shell(arr []int, nLength int) {
    if nil == arr || nLength <= 0 {
        return
    }
    fmt.Println("nLength:", nLength)
    // 确定步长
    for gap := nLength / 2; gap >= 1; gap /= 2 {
        fmt.Println("gap:", gap)
        // 对每一个步长对应的数组进行插入排序
        for i := gap; i < nLength; i += gap {
            flag := i - gap
            temp := arr[i]
            for flag >= 0 && arr[flag] > temp {
                arr[flag+gap] = arr[flag]
                flag -= gap
            }
            arr[flag+gap] = temp
        }
    }
}

4 堆排序

func Heap(arr []int, nLength int) {
    if len(arr) <= 0 || nLength <= 0 {
        return
    }
    // 将原有的数组调整成大堆的样子
    // 调整可以从根节点往下调整，也可以从最后一个非叶子节点往上调整
    for i := nLength/2 - 1; i >= 0; i-- {
        adjust(arr, i, nLength)
    }

    // 依次将大堆的堆顶的元素 从放到数组的末尾往前放，并调整剩下的元素，保证是一个大堆
    for i := nLength - 1; i >= 0; i-- {
        arr[0] = arr[0] ^ arr[i]
        arr[i] = arr[0] ^ arr[i]
        arr[0] = arr[0] ^ arr[i]
        // 调整除了最后i个元素，剩下的元素，使其成为大堆
        adjust(arr, 0, i)
    }

}

func adjust(arr []int, adjustIndex int, nLength int) {

    for {
        // 当前节点有两个孩子
        if 2*adjustIndex+2 < nLength {
            // 右节点大于左节点
            if arr[2*adjustIndex+2] > arr[2*adjustIndex+1] {
                // 右节点与父节点交换
                arr[adjustIndex] = arr[adjustIndex] ^ arr[2*adjustIndex+2]
                arr[2*adjustIndex+2] = arr[adjustIndex] ^ arr[2*adjustIndex+2]
                arr[adjustIndex] = arr[adjustIndex] ^ arr[2*adjustIndex+2]
                // 调整右节点为待调整的树
                adjustIndex = 2*adjustIndex + 2
            } else {
                // 左节点与父节点交换
                arr[adjustIndex] = arr[adjustIndex] ^ arr[2*adjustIndex+1]
                arr[2*adjustIndex+1] = arr[adjustIndex] ^ arr[2*adjustIndex+1]
                arr[adjustIndex] = arr[adjustIndex] ^ arr[2*adjustIndex+1]
                // 调整左节点为待调整的树
                adjustIndex = 2*adjustIndex + 1
            }
        } else if 2*adjustIndex+1 < nLength { //  当前节点有一个节点（左节点）
            // 子节点大于父节点
            if arr[2*adjustIndex+1] > arr[adjustIndex] {
                arr[adjustIndex] = arr[adjustIndex] ^ arr[2*adjustIndex+1]
                arr[2*adjustIndex+1] = arr[adjustIndex] ^ arr[2*adjustIndex+1]
                arr[adjustIndex] = arr[adjustIndex] ^ arr[2*adjustIndex+1]
                // 调整左节点为待调整的树
                adjustIndex = 2*adjustIndex + 1
            } else {
                break
            }
        } else {
            // 没有子节点 无需调整
            break
        }
    }
}