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

简介:

   直接上代码:

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  int int  {
     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,如需转载请自行联系原作者
目录
相关文章
|
4天前
|
算法 搜索推荐 索引
数据结构与算法 排序(下)
数据结构与算法 排序(下)
10 1
|
4天前
|
缓存 算法 搜索推荐
数据结构与算法 排序(上)
数据结构与算法 排序(上)
9 0
[数据结构]-玩转八大排序(二)&&冒泡排序&&快速排序
[数据结构]-玩转八大排序(二)&&冒泡排序&&快速排序
|
7天前
|
搜索推荐 算法 C++
[数据结构]-玩转八大排序(一)&&插入排序&&选择排序
[数据结构]-玩转八大排序(一)&&插入排序&&选择排序
|
7天前
|
搜索推荐 C语言
【C语言/数据结构】排序(归并排序|计数排序|排序算法复杂度)
【C语言/数据结构】排序(归并排序|计数排序|排序算法复杂度)
11 0
|
7天前
|
C语言
【C语言/数据结构】排序(快速排序及多种优化|递归及非递归版本)
【C语言/数据结构】排序(快速排序及多种优化|递归及非递归版本)
9 0
|
7天前
|
C语言
【C语言/数据结构】排序(选择排序,推排序,冒泡排序)
【C语言/数据结构】排序(选择排序,推排序,冒泡排序)
12 0
|
7天前
|
C语言
【C语言/数据结构】排序(直接插入排序|希尔排序)
【C语言/数据结构】排序(直接插入排序|希尔排序)
14 4
|
13天前
数据结构第六课 -------迭代排序(快速排序和归并排序)
数据结构第六课 -------迭代排序(快速排序和归并排序)
|
13天前
数据结构第六课 -----排序-2
数据结构第六课 -----排序
数据结构第六课 -----排序-2