Browse Source

提交go关于排序算法代码

master
viviman 3 years ago
parent
commit
8a3d0edc2c
  1. 58
      golang_learn/data_likou/数据流的中位数.go
  2. 9
      golang_learn/data_paixu/01算法入门概念.md
  3. 34
      golang_learn/data_paixu/02算法运行效率与时间复杂度.go
  4. 81
      golang_learn/data_paixu/02算法运行效率与时间复杂度.md
  5. 35
      golang_learn/data_paixu/03简单判断时间复杂度.go
  6. 8
      golang_learn/data_paixu/03简单判断时间复杂度.md
  7. 36
      golang_learn/data_paixu/04空间复杂度.go
  8. 9
      golang_learn/data_paixu/04空间复杂度.md
  9. 37
      golang_learn/data_paixu/05递归.go
  10. 11
      golang_learn/data_paixu/05递归.md
  11. 38
      golang_learn/data_paixu/06汉偌塔问题.go
  12. 33
      golang_learn/data_paixu/06汉偌塔问题.md
  13. 39
      golang_learn/data_paixu/07顺序查找.go
  14. 14
      golang_learn/data_paixu/07顺序查找.md
  15. 40
      golang_learn/data_paixu/08二分查找.go
  16. 18
      golang_learn/data_paixu/08二分查找.md
  17. 41
      golang_learn/data_paixu/09查找方式对比.go
  18. 11
      golang_learn/data_paixu/09查找方式对比.md
  19. 42
      golang_learn/data_paixu/10排序.go
  20. 25
      golang_learn/data_paixu/10排序.md
  21. 43
      golang_learn/data_paixu/11冒泡排序.go
  22. 68
      golang_learn/data_paixu/11冒泡排序.md
  23. 44
      golang_learn/data_paixu/12选择排序.go
  24. 67
      golang_learn/data_paixu/12选择排序.md
  25. 45
      golang_learn/data_paixu/13插入排序.go
  26. 44
      golang_learn/data_paixu/13插入排序.md
  27. 46
      golang_learn/data_paixu/14快速排序.go
  28. 69
      golang_learn/data_paixu/14快速排序.md
  29. 47
      golang_learn/data_paixu/15树.go
  30. 50
      golang_learn/data_paixu/15树.md
  31. 48
      golang_learn/data_paixu/16堆排序.go
  32. 92
      golang_learn/data_paixu/16堆排序.md
  33. 49
      golang_learn/data_paixu/17归并排序.go
  34. 69
      golang_learn/data_paixu/17归并排序.md
  35. 50
      golang_learn/data_paixu/18希尔排序.go
  36. 54
      golang_learn/data_paixu/18希尔排序.md
  37. 51
      golang_learn/data_paixu/19计数排序.go
  38. 42
      golang_learn/data_paixu/19计数排序.md
  39. 52
      golang_learn/data_paixu/20桶排序.go
  40. 28
      golang_learn/data_paixu/20桶排序.md
  41. 53
      golang_learn/data_paixu/21排序方式对比.go
  42. 38
      golang_learn/data_paixu/21排序方式对比.md
  43. BIN
      golang_learn/data_paixu/img/冒泡排序.gif
  44. BIN
      golang_learn/data_paixu/img/分类.png
  45. BIN
      golang_learn/data_paixu/img/堆排序.gif
  46. BIN
      golang_learn/data_paixu/img/归并排序.gif
  47. BIN
      golang_learn/data_paixu/img/快速排序.gif
  48. BIN
      golang_learn/data_paixu/img/快速排序示例图.png
  49. BIN
      golang_learn/data_paixu/img/总结.png
  50. BIN
      golang_learn/data_paixu/img/选择排序.gif

58
golang_learn/data_likou/数据流的中位数.go

@ -0,0 +1,58 @@
package main
/***
295. 数据流的中位数
中位数是有序列表中间的数如果列表长度是偶数中位数则是中间两个数的平均值
例如
[2,3,4] 的中位数是 3
[2,3] 的中位数是 (2 + 3) / 2 = 2.5
设计一个支持以下两种操作的数据结构
void addNum(int num) - 从数据流中添加一个整数到数据结构中
double findMedian() - 返回目前所有元素的中位数
示例
addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3)
findMedian() -> 2
进阶:
如果数据流中所有整数都在 0 100 范围内你将如何优化你的算法
如果数据流中 99% 的整数都在 0 100 范围内你将如何优化你的算法
*/
func main() {
}
type MedianFinder struct {
Nums []int
}
/** initialize your data structure here. */
func Constructor() MedianFinder {
}
func (this *MedianFinder) AddNum(num int) {
for i, j := 0, len(this.Nums); i < j; i++ {
if this.Nums[i] > num {
this.Nums[]
}
}
}
func (this *MedianFinder) FindMedian() float64 {
}
/**
* Your MedianFinder object will be instantiated and called as such:
* obj := Constructor();
* obj.AddNum(num);
* param_2 := obj.FindMedian();
*/

9
golang_learn/data_paixu/01算法入门概念.md

@ -0,0 +1,9 @@
# 算法 Algorithm
> 程序 = 数据结构 + 算法
* 说明
* 数据结构【静态】
* 算法【动态】

34
golang_learn/data_paixu/02算法运行效率与时间复杂度.go

@ -0,0 +1,34 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 0 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/06/29 15:29 321 04 空间复杂度.md
2021/06/29 15:29 228 05 递归.md
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/06/29 15:29 145 07 顺序查找.md
2021/06/29 15:29 212 08 二分查找.md
2021/06/29 15:29 163 09 查找方式对比.md
2021/06/29 15:29 484 10 排序.md
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/06/29 15:29 2,161 12 选择排序.md
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
24 个文件 24,336 字节
3 个目录 179,901,222,912 可用字节

81
golang_learn/data_paixu/02算法运行效率与时间复杂度.md

@ -0,0 +1,81 @@
# 算法运行效率与时间复杂度
* **时间复杂度**
> 使用表示算法运行的快慢 和 循环次数
> 1、时间复杂度=o(1)
```java
print('Hello World!')
```
> 2、时间复杂度=o(n)
```java
for(int i = 0; i < n; i++){
print('Hello World!')
}
```
> 3、时间复杂度=o(n*m)
```java
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
print('Hello World!')
}
}
```
> **注意区分**
>
> 理解:**问题规模**
>
> 4、时间复杂度=o(1)
```java
print('Hello World!')
print('Hello Java!')
print('Hello Zhang!')
```
> 5、时间复杂度=o(n<sup>2</sup>)
```java
for(int i = 0; i < n; i++){
print('Hello Java!')
for(int j = 0; j < m; j++){
print('Hello World!')
}
}
```
> 5、时间复杂度=o(log<sub>2</sub> n) 或者 o(log n)
```java
while(n>1){
print('Hello World!')
n = n / 2
}
```
> 当n=64, 则输出为64、32、16、8、4、2
>
> 由于2<sup>6</sup>=64,则log<sub></sub>64=6。
>
> 以此类推:`n = n / 3` 为 o(log<sub>3</sub> n)
>
> 以此类推:`n = n / 4` 为 o(log<sub>4</sub> n)
>
> **总结**:只要问题规模出现**循环减半**情况,则使用**对数**描述时间复杂度;
>
> ​ 只要问题规模出现**多层循环**情况,则使用**次幂**描述时间复杂的。
---------
* **小结**
> 时间复杂度是用来描述估计算法运行时间的一个式子(单位)。
>
> **一般来说**,时间复杂度高的算法比复杂度低的算法慢。
>
> 常见的时间复杂度排序(按效率排序 【主要:o(1) < o(log n) < o(n)
>
> ​ o(1) < o(log n) < o(n) < o(n * log n) < o(n<sup>2</sup>) < o(n<sup>2</sup> * log n) < o(n<sup>3</sup>)

35
golang_learn/data_paixu/03简单判断时间复杂度.go

@ -0,0 +1,35 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 0 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/06/29 15:29 228 05 递归.md
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/06/29 15:29 145 07 顺序查找.md
2021/06/29 15:29 212 08 二分查找.md
2021/06/29 15:29 163 09 查找方式对比.md
2021/06/29 15:29 484 10 排序.md
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/06/29 15:29 2,161 12 选择排序.md
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
25 个文件 25,945 字节
3 个目录 179,901,218,816 可用字节

8
golang_learn/data_paixu/03简单判断时间复杂度.md

@ -0,0 +1,8 @@
# 简单判断时间复杂度
* 快速判断算法复杂度
* 确定问题规模n
* 循环减半过程 => log n (只要问题规模出现**循环减半**情况,则使用**对数**描述时间复杂度)
* k层关于n的循环 => n<sup>k</sup> (只要问题规模出现**多层循环**情况,则使用**次幂**描述时间复杂的)
* 复杂情况:根据算法执行过程判断

36
golang_learn/data_paixu/04空间复杂度.go

@ -0,0 +1,36 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 0 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/06/29 15:29 145 07 顺序查找.md
2021/06/29 15:29 212 08 二分查找.md
2021/06/29 15:29 163 09 查找方式对比.md
2021/06/29 15:29 484 10 排序.md
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/06/29 15:29 2,161 12 选择排序.md
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
26 个文件 27,615 字节
3 个目录 179,901,214,720 可用字节

9
golang_learn/data_paixu/04空间复杂度.md

@ -0,0 +1,9 @@
# 空间复杂度
* 空间复杂度:用来评估算法内存占用大小的式子
* 空间复杂度的表示方式与时间复杂度完全一样
* 算法使用了几个变量:o(1)
* 算法使用了长度为n的一维列表:o(n)
* 算法使用了m行n列的二维列表:o(n)
* “空间换时间”

37
golang_learn/data_paixu/05递归.go

@ -0,0 +1,37 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 0 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/06/29 15:29 145 07 顺序查找.md
2021/06/29 15:29 212 08 二分查找.md
2021/06/29 15:29 163 09 查找方式对比.md
2021/06/29 15:29 484 10 排序.md
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/06/29 15:29 2,161 12 选择排序.md
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
27 个文件 29,338 字节
3 个目录 179,901,210,624 可用字节

11
golang_learn/data_paixu/05递归.md

@ -0,0 +1,11 @@
# 递归
* **递归**两个特点
* 调用自身
* 结束条件 【隐含:存在判断条件】
* **总结**
* 先递归后执行 : **相对倒续**输出
* 先执行后递归 : **正常顺序**输出

38
golang_learn/data_paixu/06汉偌塔问题.go

@ -0,0 +1,38 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 0 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/06/29 15:29 212 08 二分查找.md
2021/06/29 15:29 163 09 查找方式对比.md
2021/06/29 15:29 484 10 排序.md
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/06/29 15:29 2,161 12 选择排序.md
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
28 个文件 31,108 字节
3 个目录 179,901,206,528 可用字节

33
golang_learn/data_paixu/06汉偌塔问题.md

@ -0,0 +1,33 @@
# 汉偌塔问题
* **问题分析**
* 1、把`n-1`个圆盘从A经过C移动到B
* 2、把第`n`个圆盘从A移动到C
* 3、把`n-1`个圆盘从B经过A移动到C
* **原理**
* 代码
```java
public static void main(String[] args) {
run(3, "A", "B", "C");
}
private static void run(Integer n, String a, String b, String c) {
if (n>0) {
run(n-1, a, c, b);
System.out.println("从【"+a+"】移动到【"+c+"】");
run(n-1, b, a, c);
}
}
```
```go
```

39
golang_learn/data_paixu/07顺序查找.go

@ -0,0 +1,39 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 0 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/06/29 15:29 163 09 查找方式对比.md
2021/06/29 15:29 484 10 排序.md
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/06/29 15:29 2,161 12 选择排序.md
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
29 个文件 32,931 字节
3 个目录 179,901,202,432 可用字节

14
golang_learn/data_paixu/07顺序查找.md

@ -0,0 +1,14 @@
# 列表查找
* 介绍
* **列表查找**(线性查找):从列表中查找指定元素
* **代码**
```java
```
```go
```

40
golang_learn/data_paixu/08二分查找.go

@ -0,0 +1,40 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 0 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/06/29 15:29 484 10 排序.md
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/06/29 15:29 2,161 12 选择排序.md
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
30 个文件 34,805 字节
3 个目录 179,901,198,336 可用字节

18
golang_learn/data_paixu/08二分查找.md

@ -0,0 +1,18 @@
# 二分查找
* **介绍**
* 关键字
* 开始为左,截止为右.
* **候选区**(左<)
* 左>右,不存在后选取区
* **原理**
* **代码**
```java
```
```go
```

41
golang_learn/data_paixu/09查找方式对比.go

@ -0,0 +1,41 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 0 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/06/29 15:29 2,161 12 选择排序.md
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
31 个文件 36,730 字节
3 个目录 179,901,194,240 可用字节

11
golang_learn/data_paixu/09查找方式对比.md

@ -0,0 +1,11 @@
# 二分查找与线性查找的比较
* **二分查找**
* 复杂度O(log n)
* 前提必须进行排序
* **线性查找**
* 复杂度O(n)
*

42
golang_learn/data_paixu/10排序.go

@ -0,0 +1,42 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 0 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/06/29 15:29 2,161 12 选择排序.md
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
32 个文件 38,710 字节
3 个目录 179,901,190,144 可用字节

25
golang_learn/data_paixu/10排序.md

@ -0,0 +1,25 @@
# 排序
* **排序**:将一组“无序”的记录列表调整为“有序”的记录列表
* 列表排序:将无序列表变为有序列表
* 输入:无序排序
* 输出:有序排序
* 常见排序方式
* 排序 Low B三人组
* 冒泡排序
* 选择排序
* 插入排序
* 排序NB三人组
* 快速排序
* 堆排序
* 归并排序
* 其他排序
* 希尔排序
* 计数排序
* 基数排序
*

43
golang_learn/data_paixu/11冒泡排序.go

@ -0,0 +1,43 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 0 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
33 个文件 40,737 字节
3 个目录 179,901,186,048 可用字节

68
golang_learn/data_paixu/11冒泡排序.md

@ -0,0 +1,68 @@
# 冒泡排序 `原地排序` `推荐`
* **介绍**
* 复杂度O()
* **过程**:列表每两个相邻的数,如果前面比后面大,则交换这两个数;一趟排序完成后,则无序区减少一个属,有序增加一个数。
* **优化**:若存在无序区未发生交换,则表示已经排序完毕.
* **原理**
* 1.比较相邻的元素。如果第一个比第二个大,就交换他们两个。
* 2.对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
* 3.针对所有的元素重复以上的步骤,除了最后一个。
* 4.持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
* **代码**
```java
```
```go
/**
Bubble 实现冒泡排序
a : 被排序数组
返回:排序完毕数组
*/
func Bubble(a []int) []int {
for i,j := 0, len(a); i < j; i++ { // 循环列表元素每一个元素
for ii := i + 1; ii < j ; ii++ { // 循环无序列表部分
if a[i] > a[ii] { // 从一个元素与一个无序值比较
a[ii], a[i] = a[i], a[ii] // 较大的值移至后边
}
}
}
return a
}
```
```go
/**
Bubble 【优化】实现冒泡排序
a : 被排序数组
返回:排序完毕数组
*/
func Bubble(a []int) []int {
for i,j := 0, len(a); i < j; i++ { // 循环列表元素每一个元素
b := true // 定义变量优化
for ii := i + 1; ii < j ; ii++ { // 循环无序列表部分
if a[i] > a[ii] { // 从一个元素与一个无序值比较
a[ii], a[i] = a[i], a[ii] // 较大的值移至后边
b = false // 发生交换
}
}
if b { // 为存在交换,结束循环
break
}
}
return a
}
```
* **过程**
> 我们可以由上图知道,冒泡排序是一种交换排序。那么什么又是交换排序呢?可以从字面意思上分析,两两比较待排序的关键字,并交换不满足次序要求的那对数,直到整个表都满足次序要求为止。而冒泡名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端,故名冒泡排序。
>
> 我们可以看下图,以数组为[29,10,14,37,25,18,30]为例:
![冒泡排序](.\img\冒泡排序.gif)

44
golang_learn/data_paixu/12选择排序.go

@ -0,0 +1,44 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 2,078 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/08/27 17:10 0 12选择排序.go
2021/06/29 15:29 1,588 13 插入排序.md
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
34 个文件 42,815 字节
3 个目录 179,901,181,952 可用字节

67
golang_learn/data_paixu/12选择排序.md

@ -0,0 +1,67 @@
# 选择排序 `非原地排序` `推荐`
* **介绍**
* 复杂度O(n<sup>2</sup>)
* `不推荐`~~过程:~~~~分趟查询最小值,将值插入到新数组,原数组移除该趟相对最小值.~~
* `推荐`过程:一趟排序最小的数,放到第一个位置; 在一趟在无序区记录最小的数,放置第二个位置; ... ...
* 关键词
* 有序区和无序区
* 无序区最小数的位置
* 数值对调
* **原理**
* 1、对于给定的一组记录,经过第一轮比较后得到最小的记录;
* 2、将该记录的位置与第一个记录的位置交换;
* 3、对不包括第一个记录以外的其他记录进行第二次比较,得到最小记录并与第二个位置记录交换;
* 4、重复该过程,知道进行比较的记录只剩下一个为止。
* **代码**
```java
public static void selectSort(int[] a) {
if (a == null || a.length <= 0) {
return;
}
for (int i = 0; i < a.length; i++) {
int temp = a[i];
int flag = i; // 将当前下标定义为最小值下标
for (int j = i + 1; j < a.length; j++) {
if (a[j] < temp) {// a[j] < temp 从小到大排序a[j] > temp 从大到小排序
temp = a[j];
flag = j; // 如果有小于当前最小值的关键字将此关键字的下标赋值给flag
}
}
if (flag != i) {
a[flag] = a[i];
a[i] = temp;
}
}
}
```
```go
/**
Select 实现选择排序 O(n * n)
a : 被排序数组
返回:排序完毕数组
*/
func Select(a []int) []int {
for i,j := 0, len(a); i < j; i++ { // 循环列表元素每一个元素
theMin := i // 记录最小值记录
for ii := i + 1; ii < j ; ii++ { // 循环无序列表部分
if a[theMin] > a[ii] { // 较大的值移至后边
theMin = ii // 较大的值移至后边
}
}
if theMin != i {
a[i], a[theMin] = a[theMin], a[i]
}
}
return a
}
```
* **过程**
![选择排序](.\img\选择排序.gif)

45
golang_learn/data_paixu/13插入排序.go

@ -0,0 +1,45 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 2,078 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/08/27 17:10 2,129 12选择排序.go
2021/06/29 15:29 1,588 13 插入排序.md
2021/08/27 17:10 0 13插入排序.go
2021/06/29 15:29 2,018 14 快速排序.md
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
35 个文件 44,944 字节
3 个目录 179,901,177,856 可用字节

44
golang_learn/data_paixu/13插入排序.md

@ -0,0 +1,44 @@
# 插入排序 `不推荐`
* **介绍**
* **插入排序**,顾名思义其基本操作就是插入,不断把一个个元素插入到一个序列中,最终得到排序序列。为此只需维护好所构造序列的排序性质,最终就能自然得到结果。
* 复杂度O(n<sup>2</sup>)
* 过程: 通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。
* **原理**
* 从第一个元素开始,该元素可以认为已经被排序;
* 取出下一个元素,在已经排序的元素序列中从后向前扫描;
* 如果被扫描的元素(已排序)大于新元素,将该元素后移一位;
* 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
* 将新元素插入到该位置后;
* 重复步骤2~5。
* **代码**
```java
```
```go
/**
Insert 实现插入排序 O(n * n)
a : 被排序数组
返回:排序完毕数组
*/
func Insert(s []int) []int {
n := len(s)
if n < 2 {
return s
}
for i := 1; i < n; i++ {
for j := i; j > 0 && s[j] < s[j - 1]; j-- {
// 选择第j张比较第j - 1张小,则循环交换较大的值
swap(s, j, j - 1)
}
}
return s
}
func swap(slice []int, i int, j int) {
slice[i], slice[j] = slice[j], slice[i]
}
```

46
golang_learn/data_paixu/14快速排序.go

@ -0,0 +1,46 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 2,078 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/08/27 17:10 2,129 12选择排序.go
2021/06/29 15:29 1,588 13 插入排序.md
2021/08/27 17:10 2,180 13插入排序.go
2021/06/29 15:29 2,018 14 快速排序.md
2021/08/27 17:10 0 14快速排序.go
2021/06/29 15:29 1,345 15 .md
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
36 个文件 47,124 字节
3 个目录 179,901,173,760 可用字节

69
golang_learn/data_paixu/14快速排序.md

@ -0,0 +1,69 @@
# 快速排序
* **介绍**
* 复杂度O(n log(n))
* 思路:取一个元素p(第一个元素),使元素p`归位`; 列表被p分成两部分,左边都比p小,右边都比p大; 递归完成排序.
* 过程: `锁定`从右边找第一个数值p,先从右边找比p小的数,把右边的值写到左边空位上;然后从左边找比p大的数,把左边的值写到右边空位上; 依次取完所有的数值.
* 关键字:
* `归位`获取中数的下标
* 归位是指将列表通过两端对调比一个值的方式,将数组分成关于每个数对称的两部分和一个中间值。
* 目的:使目标具有一致性和折半处理的格式。
* 递归
* 存在问题
* 最坏情况存在(`优化`:加入随机替换)
* 极端情况下排序效率低
* 快速排序 `>` 归并排序 `>` 堆排序
* **原理**
>
* **代码**
```java
```
```go
/**
Quick 实现快速排序 O(n * log(n))
a : 被排序数组
返回:排序完毕数组
*/
func Quick(slice []int, left, right int) []int {
if left < right {
mid := partition(slice, left, right) // 获取归位中值
Quick(slice, left, mid-1) // 操作 中值 左边数组
Quick(slice, mid+1, right) // 操作 中值 右边数组
}
return slice
}
/**
partition 归位函数,获取一个关于某值对称的数组和中间值
*/
func partition(slice []int, left, right int) int {
tmp := slice[left] // 获取左侧第一个数
for left < right {
// 进行逐个实现归位操作,将列表形成一个对称列表
// 左边比 tmp 大的数,调至右边
for left < right && slice[right] >= tmp {
right--
}
slice[left] = slice[right]
// 右边比 tmp 小的数,调至左边
for left < right && slice[left] <= tmp {
left++
}
slice[right] = slice[left]
}
slice[left] = tmp
return left
}
```
* **过程**
![快速](.\img\快速排序.gif)
![快速排序示例图](.\img\快速排序示例图.png)

47
golang_learn/data_paixu/15树.go

@ -0,0 +1,47 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 2,078 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/08/27 17:10 2,129 12选择排序.go
2021/06/29 15:29 1,588 13 插入排序.md
2021/08/27 17:10 2,180 13插入排序.go
2021/06/29 15:29 2,018 14 快速排序.md
2021/08/27 17:10 2,231 14快速排序.go
2021/06/29 15:29 1,345 15 .md
2021/08/27 17:10 0 15.go
2021/06/29 15:29 2,609 16 堆排序.md
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
37 个文件 49,355 字节
3 个目录 179,901,169,664 可用字节

50
golang_learn/data_paixu/15树.md

@ -0,0 +1,50 @@
# 树
* **基础**
* 树的`定义`
* 树是一种数据结构
* 树是一种可以递归定义的数据结构
* 树是由n个结点组成的集合
* `n=0`表示空树
* `n>0`表示存在一个结点为根,其他结点可以分为m个集合,每个集合本身又是一个树
* 树的`概念`
* `根`和`叶子`:
* `树的深度/高度`:树存在的层
* `树的度`:结点分叉的度
​ 整棵树的度指最大的度
* `孩子结点/父结点`:描述结点关系
* `子树`:树的分支
* `二叉树`
* 二叉树是指`度`不超过2的树
* 每一个结点最多右两个孩子结点
* 两个孩子结点被区分为左孩子结点和右孩子结点
* `满二叉树`
* 每一层的结点数都达到最大值
* `完全二叉树`
* `定义`:叶子节点只能出现在最下层和次下层,并且最下面一层的结点都集中在该层最左边的若干位置的二叉树
* `简化1`:从根进行编号,中间不间断的二叉树
* `简化2`:由满二叉树从右边拿走部分节点
* 二叉树的`存储方式`
* 链式存储方式
* 父节点与左孩子节点下标关系: i => 2i + 1
* 父节点与右孩子节点下标关系: i => 2i + 2
* 顺序存储方式

48
golang_learn/data_paixu/16堆排序.go

@ -0,0 +1,48 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 2,078 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/08/27 17:10 2,129 12选择排序.go
2021/06/29 15:29 1,588 13 插入排序.md
2021/08/27 17:10 2,180 13插入排序.go
2021/06/29 15:29 2,018 14 快速排序.md
2021/08/27 17:10 2,231 14快速排序.go
2021/06/29 15:29 1,345 15 .md
2021/08/27 17:10 2,276 15.go
2021/06/29 15:29 2,609 16 堆排序.md
2021/08/27 17:10 0 16堆排序.go
2021/06/29 15:29 1,646 17 归并排序.md
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
38 个文件 51,631 字节
3 个目录 179,901,165,568 可用字节

92
golang_learn/data_paixu/16堆排序.md

@ -0,0 +1,92 @@
# 堆排序
* **介绍**
* `定义`
* 堆是一种特殊的完全二叉树结构
* 大根堆:一棵完全二叉树满足任意节点的值都比孩子结点大
* 小根堆:一棵完全二叉树满足任意节点的值都比孩子结点小
* 堆的向下调整`性质`
* `目的`其实就是一个排序的过程
* `体现`通过向下调整实现获得大根堆
* `总结`当根节点的左右子树都是堆时,但是根不满足堆,可以通过一次向下的调整来将其变换成一个堆。
* 复杂度O(n log(n))
* 思路: 通过建立堆,并重复使用向下调整的性质进行数据排序。
* 过程:
* `1`建立堆
* `2`得到堆顶元素为最大元素
* `3`去除堆顶,将堆`最后元素(原因是保证堆成立)`放到堆顶,此时可以通过一次调整重新是堆有序.
* `4`堆顶元素为第二大元素
* `5` 可以`重复3`直到堆变空
* 关键字:
* 构建堆(农村包围城市)
* 向下排序
* 实现排序:完全二叉树 `>``>` 向下调整 `>` 输出元素
* 存在问题
* 在快的排序算法在相对较慢
* 快速排序 `>` 归并排序 `>` 堆排序
* 应用
* 实现解决top-K问题
* top-K对比
* 排序后切片 O(n log(n))
* 排序LowB三人组 O(kn)
* 堆排序思路 O(n log(k))
* **原理**
>
* **代码**
```java
```
```go
/**
Heap 进行排序
1. 建堆
2. 交换值并向下调整
*/
func Heap(li []int) []int {
n := len(li)
for i := (n-2) / 2; i >= 0; i-- { // 创建堆
sift(li, i, n - 1)
}
for i := n - 1; i >= 0; i-- { // 先做交换(减少内存)后做向下调整
li[0], li[i] = li[i], li[0]
sift(li, 0, i - 1)
}
return li
}
/**
sift 向下调整
li 数组列表
low 堆的根节点的下标
high 堆的最后一个元素的下标
*/
func sift(li []int, low, high int) {
/**
i 指一层中的根
j 开始是左孩子
t 指一层中某个需要调整的值
*/
i, j, t := low, 2 * low + 1, li[low]
for j <= high { // 在范围内进行循环,防止越界
if j + 1 <= high && li[j+1] > li[j] { // 比较一个根下的两个孩子大小,取大值的位置
j = j + 1
}
if li[j] > t { // 与指定根值比较,若值比根大,继续循环
li[i], i, j = li[j], j, 2 * i + 1
} else {
// li[i] = t // 将临时值放回,移至循环结束位置
break
}
}
li[i] = t // 将临时值放回
}
```

49
golang_learn/data_paixu/17归并排序.go

@ -0,0 +1,49 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 2,078 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/08/27 17:10 2,129 12选择排序.go
2021/06/29 15:29 1,588 13 插入排序.md
2021/08/27 17:10 2,180 13插入排序.go
2021/06/29 15:29 2,018 14 快速排序.md
2021/08/27 17:10 2,231 14快速排序.go
2021/06/29 15:29 1,345 15 .md
2021/08/27 17:10 2,276 15.go
2021/06/29 15:29 2,609 16 堆排序.md
2021/08/27 17:10 2,325 16堆排序.go
2021/06/29 15:29 1,646 17 归并排序.md
2021/08/27 17:10 0 17归并排序.go
2021/06/29 15:29 1,284 18 希尔排序.md
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
39 个文件 53,956 字节
3 个目录 179,901,161,472 可用字节

69
golang_learn/data_paixu/17归并排序.md

@ -0,0 +1,69 @@
# 归并排序
* **介绍**
* `归并特性`
* 一个列表两段有序,通过归并实现合并成一段有序列表。
* 复杂度O(n log(n))
* 思路:先分解在合并
* 过程:
* 分解:将列表越分越小,直至分成一个元素;
* 终止条件:一个元素是有序的;
* 合并:将两个有序列表归并,列表越来越大。
* 关键字:
* 分解
* 归并
* 存在问题
* 需要额外的内存开销
* 快速排序 `>` 归并排序 `>` 堆排序
* **原理**
* 通过对若干个有序结点序列的归并来实现排序。
* 所谓归并是指将若干个已排好序的部分合并成一个有序的部分。
* **代码**
```java
```
```go
/**
MergeSort 实现归并排序(前提列表有序)
包含:分解 + 合并
*/
func MergeSort(li []int, low, high int) {
if low < high {
mid := (low + high) / 2
MergeSort(li, low, mid)
MergeSort(li, mid + 1, high)
Merge(li, low, mid, high)
}
}
/**
Merge 归并
*/
func Merge(li []int, low, mid, high int) {
i, j, lt, t := low, mid + 1, make([]int, len(li)), 0
for i <= mid && j <= high { // 将结果拼接到新的数组
if li[i] < li[j] {
lt[t], i, t = li[i], i + 1, t + 1
} else {
lt[t], j, t = li[j], j + 1, t + 1
}
}
for i <= mid {
lt[t], i, t = li[i], i + 1, t + 1
}
for j <= high {
lt[t], j, t = li[j], j + 1, t + 1
}
for i, j := low, 0 ; i <= high; i, j = i + 1, j + 1 { // 因为存在递归,将数值填回数组
li[i] = lt[j]
}
}
```
* **过程**
![并归排序](.\img\归并排序.gif)

50
golang_learn/data_paixu/18希尔排序.go

@ -0,0 +1,50 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 2,078 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/08/27 17:10 2,129 12选择排序.go
2021/06/29 15:29 1,588 13 插入排序.md
2021/08/27 17:10 2,180 13插入排序.go
2021/06/29 15:29 2,018 14 快速排序.md
2021/08/27 17:10 2,231 14快速排序.go
2021/06/29 15:29 1,345 15 .md
2021/08/27 17:10 2,276 15.go
2021/06/29 15:29 2,609 16 堆排序.md
2021/08/27 17:10 2,325 16堆排序.go
2021/06/29 15:29 1,646 17 归并排序.md
2021/08/27 17:10 2,376 17归并排序.go
2021/06/29 15:29 1,284 18 希尔排序.md
2021/08/27 17:10 0 18希尔排序.go
2021/06/29 15:29 1,442 19 计数排序.md
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
40 个文件 56,332 字节
3 个目录 179,901,153,280 可用字节

54
golang_learn/data_paixu/18希尔排序.md

@ -0,0 +1,54 @@
# 希尔排序
* **介绍**
* 定义
* 希尔排序是一种分组插入排序算法。
* 复杂度 比较多类别,复杂度不一
* 过程:
* 插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率。
* 插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位。
* 关键字:
* 插入排序
* 缩小增量排序
* **原理**
* 按下标的一定增量分组 ,分成多个子序列,然后对各个子序列进行直接插入排序算法排序;
* 然后依次缩减增量再进行排序,直到增量为1时,进行最后一次直接插入排序,排序结束。
* **代码**
```java
```
```go
...
for d := len(a); d >= 1; d = d/2 {
Shell(a, d)
}
...
/**
Shell 实现希尔排序 O(n * n)
a : 被排序数组
返回:排序完毕数组
*/
func Shell(s []int, get int) {
n := len(s)
if n < 2 {
return
}
for i := get; i < n; i++ {
for j := i; j > 0 && s[j] < s[j - get]; j = j - get {
// 选择第j张比较第j - get张小,则循环交换较大的值
swap(s, j, j - get)
}
}
}
func swap(slice []int, i int, j int) {
slice[i], slice[j] = slice[j], slice[i]
}
```

51
golang_learn/data_paixu/19计数排序.go

@ -0,0 +1,51 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 2,078 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/08/27 17:10 2,129 12选择排序.go
2021/06/29 15:29 1,588 13 插入排序.md
2021/08/27 17:10 2,180 13插入排序.go
2021/06/29 15:29 2,018 14 快速排序.md
2021/08/27 17:10 2,231 14快速排序.go
2021/06/29 15:29 1,345 15 .md
2021/08/27 17:10 2,276 15.go
2021/06/29 15:29 2,609 16 堆排序.md
2021/08/27 17:10 2,325 16堆排序.go
2021/06/29 15:29 1,646 17 归并排序.md
2021/08/27 17:10 2,376 17归并排序.go
2021/06/29 15:29 1,284 18 希尔排序.md
2021/08/27 17:10 2,427 18希尔排序.go
2021/06/29 15:29 1,442 19 计数排序.md
2021/08/27 17:10 0 19计数排序.go
2021/06/29 15:29 362 20 桶排序.md
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
41 个文件 58,759 字节
3 个目录 179,901,149,184 可用字节

42
golang_learn/data_paixu/19计数排序.md

@ -0,0 +1,42 @@
# 计数排序
* **介绍**
* 定义
* 计数排序是一种非常快捷的**稳定性强**的排序方法,时间复杂度O(n+k),其中n为要排序的数的个数,k为要排序的数的组大值。
* 复杂度 O(n)
* 思路: 一组数在排序之前先统计这组数中其他数小于这个数的个数,则可以确定这个数的位置。
* 过程:
* 首先需要三个数组,第一个数组记录A要排序的数列大小为n,第二个数组B要记录比某个数小的其他数字的个数所以第二个数组的大小应当为K(数列中最大数的大小),第三个数组C为记录排序好了的数列的数组,大小应当为n。
* 接着需要确定数组最大值并确定B数组的大小。并对每个数由小到大的记录数列中每个数的出现次数。因为是有小到大通过出现次数可以通过前面的所有数的出现次数来确定比这个数小的数的个数,从而确定其位置。
* 关键字:
* 计数
* 按顺序输出
* 存在问题
* 仅可以对0-100之间的数进行排序。
* **代码**
```java
```
```go
/**
Count 实现计数排序
限制:仅限百内之整数
*/
func Count(li []int, max int) {
a := make([]int, max)
for i := 0; i < len(li); i++ {
a[li[i]] += 1
}
for i, j := 0, 0; i < max; i++ {
for ii := a[i]; ii > 0; ii, j = ii-1, j+1 {
li[j] = i
}
}
}
```

52
golang_learn/data_paixu/20桶排序.go

@ -0,0 +1,52 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 2,078 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/08/27 17:10 2,129 12选择排序.go
2021/06/29 15:29 1,588 13 插入排序.md
2021/08/27 17:10 2,180 13插入排序.go
2021/06/29 15:29 2,018 14 快速排序.md
2021/08/27 17:10 2,231 14快速排序.go
2021/06/29 15:29 1,345 15 .md
2021/08/27 17:10 2,276 15.go
2021/06/29 15:29 2,609 16 堆排序.md
2021/08/27 17:10 2,325 16堆排序.go
2021/06/29 15:29 1,646 17 归并排序.md
2021/08/27 17:10 2,376 17归并排序.go
2021/06/29 15:29 1,284 18 希尔排序.md
2021/08/27 17:10 2,427 18希尔排序.go
2021/06/29 15:29 1,442 19 计数排序.md
2021/08/27 17:10 2,478 19计数排序.go
2021/06/29 15:29 362 20 桶排序.md
2021/08/27 17:10 0 20桶排序.go
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
42 个文件 61,237 字节
3 个目录 179,901,145,088 可用字节

28
golang_learn/data_paixu/20桶排序.md

@ -0,0 +1,28 @@
# 桶排序 `不推荐`
* **介绍**
* 定义
* 桶排序是对计数排序的优化。
* 首先将元素分在不同的桶中,在对每个桶中的元素排序。
* 复杂度 O(n)
* 思路:
* 过程:
*
* 关键字:
*
* 存在问题
*
* **原理**
>
* **代码**
```java
```
```go
```

53
golang_learn/data_paixu/21排序方式对比.go

@ -0,0 +1,53 @@
驱动器 D 中的卷是 Data
卷的序列号是 D649-8FB3
D:\ViviCode\golangs_learn\golang_learn\data_paixu 的目录
2021/08/27 17:10 <DIR> .
2021/08/27 17:10 <DIR> ..
2021/06/29 15:29 124 01 算法入门概念.md
2021/08/27 17:10 1,542 01算法入门概念.go
2021/06/29 15:29 1,779 02 算法运行效率与时间复杂度.md
2021/08/27 17:10 1,609 02算法运行效率与时间复杂度.go
2021/06/29 15:29 406 03 简单判断时间复杂度.md
2021/08/27 17:10 1,670 03简单判断时间复杂度.go
2021/06/29 15:29 321 04 空间复杂度.md
2021/08/27 17:10 1,723 04空间复杂度.go
2021/06/29 15:29 228 05 递归.md
2021/08/27 17:10 1,770 05递归.go
2021/06/29 15:29 581 06 汉偌塔问题.md
2021/08/27 17:10 1,823 06汉偌塔问题.go
2021/06/29 15:29 145 07 顺序查找.md
2021/08/27 17:10 1,874 07顺序查找.go
2021/06/29 15:29 212 08 二分查找.md
2021/08/27 17:10 1,925 08二分查找.go
2021/06/29 15:29 163 09 查找方式对比.md
2021/08/27 17:10 1,980 09查找方式对比.go
2021/06/29 15:29 484 10 排序.md
2021/08/27 17:10 2,027 10排序.go
2021/06/29 15:29 2,351 11 冒泡排序.md
2021/08/27 17:10 2,078 11冒泡排序.go
2021/06/29 15:29 2,161 12 选择排序.md
2021/08/27 17:10 2,129 12选择排序.go
2021/06/29 15:29 1,588 13 插入排序.md
2021/08/27 17:10 2,180 13插入排序.go
2021/06/29 15:29 2,018 14 快速排序.md
2021/08/27 17:10 2,231 14快速排序.go
2021/06/29 15:29 1,345 15 .md
2021/08/27 17:10 2,276 15.go
2021/06/29 15:29 2,609 16 堆排序.md
2021/08/27 17:10 2,325 16堆排序.go
2021/06/29 15:29 1,646 17 归并排序.md
2021/08/27 17:10 2,376 17归并排序.go
2021/06/29 15:29 1,284 18 希尔排序.md
2021/08/27 17:10 2,427 18希尔排序.go
2021/06/29 15:29 1,442 19 计数排序.md
2021/08/27 17:10 2,478 19计数排序.go
2021/06/29 15:29 362 20 桶排序.md
2021/08/27 17:10 2,527 20桶排序.go
2021/06/29 15:29 1,103 21 排序方式对比.md
2021/08/27 17:10 0 21排序方式对比.go
2021/08/27 17:10 442 a.txt
2021/08/27 17:05 <DIR> img
43 个文件 63,764 字节
3 个目录 179,901,140,992 可用字节

38
golang_learn/data_paixu/21排序方式对比.md

@ -0,0 +1,38 @@
# 排序算法
* **引言**
> 排序是数据处理中十分常见且核心的操作,虽说实际项目开发中很小几率会需要我们手动实现,各种集成的api已经帮我们省略了思考如何构建排序的时间,但如果我们从原理上出发,了解它们的实现机制,对我们学习算法还是十分有好处的。
* **排序分类**
> 八大排序算法均属于内部排序。如果按照策略来分类,大致可分为:交换排序、插入排序、选择排序、归并排序和基数排序。如下图所示:
![分类](.\img\分类.png)
* **总结**
![总结](.\img\总结.png)
* 关键词
* 冒泡排序
* 形如冒水泡(大数)
* 快速排序
* 归位(关于某值对称的数组)
* 递归
* 直接插入排序
* 扫描位置(指插入的位置)
* 希尔排序
*
* 简单选择排序
* 扫描一遍(获取最小数)
* 对调位置
* 堆排序
* 归并排序
* 将两个数组排有序
* 将两个数组归并到一起
* 基数排序

BIN
golang_learn/data_paixu/img/冒泡排序.gif

Binary file not shown.

After

Width:  |  Height:  |  Size: 157 KiB

BIN
golang_learn/data_paixu/img/分类.png

Binary file not shown.

After

Width:  |  Height:  |  Size: 58 KiB

BIN
golang_learn/data_paixu/img/堆排序.gif

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.7 MiB

BIN
golang_learn/data_paixu/img/归并排序.gif

Binary file not shown.

After

Width:  |  Height:  |  Size: 244 KiB

BIN
golang_learn/data_paixu/img/快速排序.gif

Binary file not shown.

After

Width:  |  Height:  |  Size: 375 KiB

BIN
golang_learn/data_paixu/img/快速排序示例图.png

Binary file not shown.

After

Width:  |  Height:  |  Size: 111 KiB

BIN
golang_learn/data_paixu/img/总结.png

Binary file not shown.

After

Width:  |  Height:  |  Size: 74 KiB

BIN
golang_learn/data_paixu/img/选择排序.gif

Binary file not shown.

After

Width:  |  Height:  |  Size: 342 KiB

Loading…
Cancel
Save