golang 数据结构实现之内部排序(一)

本文提供了五种不同的排序算法的Go语言实现,包括直接插入排序、折半插入排序、冒泡排序、简单选择排序和快速排序。每种算法都有详细的代码示例,适合初学者学习并理解各种排序算法的工作原理。

   直接上代码:

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
package sort
    
//直接插入排序
func DirectInsertSort(array []int) []int {
    len := len(array)
    var tmp, j int
    for i := 1; i < len; i++ {
        if array[i] < array[i-1] {
            tmp = array[i]
            for j = i - 1; tmp < array[j]; j-- {
                array[j+1] = array[j]
            }
            array[j+1] = tmp
        }
    }
    return array
}
    
//折半插入排序
func BinaryInsertSort(array []int) []int {
    var tmp, low, high, mid int
    len := len(array)
    for i := 1; i < len; i++ {
        tmp = array[i]
        low, high = 0, i-1
        for low <= high {
            mid = (low + high) / 2
            if array[mid] > array[i] {
                high = mid - 1
            else {
                low = mid + 1
            }
        }
        for j := i - 1; j >= high+1; j-- {
            array[j+1] = array[j]
        }
        array[high+1] = tmp
    }
    return array
}
    
//冒泡排序
func BubbleSort(array []int) []int {
    len := len(array)
    for i := 0; i < len-1; i++ {
        for j := len - 1; j > i; j-- {
            if array[j-1] > array[j] {
                array[j-1], array[j] = array[j], array[j-1]
            }
        }
    }
    return array
}
    
//简单选择排序
func SelectSort(array []int) []int {
    len := len(array)
    for i := 0; i < len-1; i++ {
        for j := len + 1; j < len; j++ {
            if array[j-1] > array[j] {
                array[j-1], array[j] = array[j], array[j-1]
            }
        }
    }
    return array
}
    
//快速排序
func QuickSort(array []int) []int {
    quickSort(array, 0, len(array)-1)
    return array
}
    
func quickSort(array []int, left, right int) {
    if left < right {
        pivotPosition := partition(array, left, right)
        quickSort(array, left, pivotPosition-1)
        quickSort(array, pivotPosition+1, right)
    }
}
    
func partition(array []int, left, right intint {
    pivot := array[left]
    for left < right {
        for left < right && array[right] > pivot {
            right--
        }
        array[left] = array[right]
        for left < right && array[left] <= pivot {
            left++
        }
        array[right] = array[left]
    }
    
    array[left] = pivot
    return left
}










本文转自 ponpon_ 51CTO博客,原文链接:http://blog.51cto.com/liuxp0827/1388684,如需转载请自行联系原作者
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值