
先把最小的元素拿出来
剩下的,再把最小的拿出来
剩下的,再把最小的拿出来


索引i指向0的位置
索引j指向i+1的元素
j 后面的元素遍历,找到最小的标记为minindex
交换minindex 和 i

时间复杂度O(n^2)
空间复杂度O(1)

第一轮 n 次,第二轮 n-1 次
1 + 2 + 3 + … + (n-1) + n

扑克牌的排序 就是 插入排序


j 往前 插入

时间复杂度O(n^2)
空间复杂度O(1)
基本思想:每次比较相邻的元素

如果 > ,就互换

一直到最后

第一轮之后,最大的元素一定在最后
所以在第二轮,最后一个元素就不用比较了




平均时间复杂度:O(n^2)
空间复杂度O(1)
更加复杂的递归算法
O(nlogn)的时间复杂度

将一个数组一分为二 ,分别排序,得到两个排序后的子数组

对两个子数组排序的方法还是继续划分
MergeSort(arr, l, r)
对 arr数组的 l 到 r 区间进行排序
MergeSort(arr, l, r)
int mid = (l + r) / 2
MergeSort(arr, l, mid)
MergeSort(arr, mid+1, r)
merge(arr, l, mid, r)
if(l >= r) return;




计算mid

将数据复制一份,标记左右 i , j = mid + 1

使用i j 两个索引 对比,result 直接写入原区间

终止条件:i >= mid , j > r


归并排序过程无法原地完成
空间复杂度:由于需要 copy 一份出来,所以是O(n)
时间复杂度:

MergeSort:每一层总和都会有 n
一共有 logn层
所以是O(n logn)

冒泡排序每次只能一位
希尔排序希望 很大的元素能够很快的移动到最后面
距离为4 (n/2)分组

每一组内,元素进行插入排序

完成一轮组内的插入排序之后

距离为2 (n/4)分组

再次组内插入排序

距离为(n/8)的排序
由于只有8个,所以也就是array本身
全体进行插入排序

希尔排序经过前面的分组内排序之后,
数组已经大体上都是有序的了
插入排序只需要找到前面一个不小于的即可
因此 最后 插入排序会省一些前面的比较步骤



因此也称为 O(n^1.5)
20世纪对世界影响最大的算法之一
归并排序不管数组的内容,直接一分为二,再进行排序
快排从当前数组中选择一个元素当作基点

比如选择了4当作基点,前面都 < 4,后面都 > 4
如何将4移动到正确的位置,就是快排的核心

这个将基点移动到正确位置的过程,称为partition

如何获取 基准 元素?
随便获取就可以,最简单的就是直接获取第一个元素

partition的返回值是 p (标定点对应的索引)
递归函数的宏观语意:
quickSort(arr, l, r)
对arr中 l 到 r 的排序


开辟两个临时数组left right
不是原地排序

L:基准元素
J:<>分界点
i:当前访问的元素
当e >= v的时候
i ++ 就好了
e直接并入大的区间
当e < v的时候

只需要将j+1个元素和e进行互换
j++即可

最后将L的位置和J的位置进行互换
初始化,i j l

比基准大

比基准小

J++ ,扩充前面的元素
交换i j 指向的元素

4) 交换l j基准点

retrun j
后续再对前面 和 后面 进行递归的QuickSort
归并排序
快排的复杂度 和 之前归并的复杂度分析是相思的


快速排序
快排可能是不平均的两部分


虽然快排的最差情况是O(n^2)的,但是概率很低,
大概率还是O(nlogn)

partition原地排序:空间复杂度O(1)
partition非原地排序:空间复杂度O(logn)
出队顺序和入队顺序无关,和优先级相关
例如OS中任务进程的调度

上浮下沉 Sift UP Sift Down

下沉操作,复杂度为O(logn),可以重新构建成堆

时间复杂度:O(nlogn), 空间复杂度:O(1)