自己学习的记录，方便自己理解和记忆，注释是自己的理解与记忆的方法，仅用于学习，如有错误，请大家多多指正，谢谢大家。
各个排序方法的时间复杂度：
图片来源：https://www.cnblogs.com/AlbertP/p/10847627.html
1. 简单选择排序
每一轮选择出最大或者最小的值，放到他的位置上；这样每一轮都会确定一个位置。除了和自己比较 所以要比较n-1轮（n为数组的长度）
function selectSort(nums) {
//因为要比较n-1轮 同时也是要比较的元素 从i个开始 所以是length-1
for ( let i = 0; i < nums.length - 1; i++) {
//记录最小的位置 也就是我们需要确定的位置 就是i
let index = i;
//开始比较 从i的下面一位开始比较
for (let j = i + 1; j < nums.length; j++) {
//与最小值进行比较 如果更小 就更新位置
if (nums[j] < nums[index]) {
//更新更小值的位置
index = j;
}
//之后继续比较
}
//for循环结束后 就是比较了一轮 找出了最小值的位置在哪里 就是index
//然后开始交换
let temp = nums[index];
nums[index] = nums[i];
nums[i] = temp;
}
}
let arr = [2,5,3,10,-3,1,6,4];
selectSort(arr);
console.log(arr); //[ -3, 1, 2, 3, 4, 5, 6, 10]
比较的过程：
第一轮：2 5 3 10 -3 1 6 4 =》-3 5 3 10 2 1 6 4
第二轮：-3 5 3 10 2 1 6 4 =》-3 1 3 10 2 5 6 4
第三轮：-3 1 3 10 2 5 6 4 =》 -3 1 2 10 3 5 6 4
第四轮：-3 1 2 10 3 5 6 4 =》-3 1 2 3 10 5 6 4
第五轮：-3 1 2 3 10 5 6 4 =》 -3 1 2 3 4 5 6 10
第六轮： -3 1 2 3 4 5 6 10 index没有更新
第七轮： -3 1 2 3 4 5 6 10 index 没有更新
最后一个元素就不需要比较了 所以需要比较n-1轮。
排序完毕 期间index都是会更新 更新最小值的位置。序列arr = [5 8 5 2 9]，我们知道第一遍选择第1个元素5会和2交换，那么原序列中两个5的相对前后顺序就被破坏了，所以选择排序是一个不稳定的排序算法。
时间复杂度：O(n2)
空间复杂度：O(1)
2.冒泡排序
思想就是两两比较，每一轮比较都会选择一个最大的元素或者最小的元素，放到位置上。
function pupple(nums) {
//比较n轮
for (let i = 0; i < nums.length ; i++) {
//前后两个元素进行比较 每一轮 就少比较i个 因为 已经有i个冒泡到后面了 排好序了
for (let j = 0; j < nums.length - i - 1; j++) {
if ( nums[j] > nums[j+1]) {
//如果后一个元素比前一个小 就交换 位置
let temp = nums[j+1];
nums[j+1] = nums[j];
nums[j] = temp;
}
}
}
}
let arr = [2,5,3,10,-3,1,6,4];
selectSort(arr);
console.log(arr); //[ -3, 1, 2, 3, 4, 5, 6, 10]
比较的过程：
第一轮：2,5,3,10,-3,1,6,4 =》2, 3, 5, -3,1, 6, 4, 10
第二轮：2 3 5 -3 1 6 4 10=》2 3 -3 1 5 4 6 10
第三轮：2 3 -3 1 5 4 6 10 =》2 -3 1 3 4 5 6 10
第四轮：2 -3 1 3 4 5 6 10 =》-3 1 2 3 4 5 6 10
第五轮：-3 1 2 3 4 5 6 10 =》 -3 1 2 3 4 5 6 10
第六轮：-3 1 2 3 4 5 6 10 =》-3 1 2 3 4 5 6 10
第七轮：-3 1 2 3 4 5 6 10 =》-3 1 2 3 4 5 6 10
第八轮：-3 1 2 3 4 5 6 10 =》-3 1 2 3 4 5 6 10
冒泡排序是一个不稳定的排序算法。
3.插入排序
插入排序，就是寻找自己的位置，将数字插入进去。比较前半部分，进行插入。
function insertSort (nums) {
//因为要向前比较 所以i从1开始
for(let i = 1; i < nums.length; i++) {
//当前元素 向前一个一个比较 寻找自己的位置
for (let j = i; j > 0; j--) {
if(nums[j] < nums[j-1]) {
//如果当前元素比前一个元素小 就交换位置 继续比较
let temp = nums[j];
nums[j] = nums[j-1];
nums[j-1] = temp;
}
}
}
}
let arr = [2,5,3,10,-3,1,6,4];
pupple(arr);
console.log(arr); //[ -3, 1, 2, 3, 4, 5, 6, 10]
比较的过程：
第一轮：2,5,3,10,-3,1,6,4 =》2,5,3,10,-3,1,6,4
第二轮：2,5,3,10,-3,1,6,4=》2,3,5,10,-3,1,6,4
第三轮：2,3,5,10,-3,1,6,4 =》2,3,5,10,-3,1,6,4
第四轮：2,3,5,10,-3,1,6,4 =》-3 2,3,5,10,1,6,4
第五轮：-3,2,3,5,10,1,6,4 =》 -3,1,2,3,5,10,6,4
第六轮：-3,1,2,3,5,10,6,4 =》-3,1,2,3,5,6,10,4
第七轮：-3,1,2,3,5,6,10,4 =》-3,1,2,3,4,5,6,10
插入排序是稳定的算法。
4.归并排序
先把数组分为两部分再合并，一分为二
先写合并的逻辑 需要一个辅助数组
//left 左边数组的起始位置
//right 右边数组的结束位置
//mid是中间的索引 将nums数组一分为二
//temp是辅助数组 将排序的结果存到temp当中
function merge(nums, left, mid, right, temp) {
//两边数组进行比较
let i = left;//左边数组的起始索引
let j = mid + 1;//右边数组的起始索引
let t = 0;//新数组的索引
//开始比较
while (i <= mid && j <=right) {
if (nums[i] < nums[j]) {
//如果左边数组小于右边数组的值 就加入temp 同时两者都索引自增
temp[t++] = nums[i++];
}else {
temp[t++] = nums[j++];
}
}
//比较完后把剩余的数组 加入到temp当中
while(i <= mid ){
temp[t++] = nums[i++];
}
while(j <= right) {
temp[t++] = nums[j++];
}
//这时候temp是一个排好序的数组 结果放入原数组 覆盖left到right这一部分
t = 0;
for (let k = left; k <= right; k++){
nums[k] = temp[t];
t = t + 1;
}
}
//分而治之
function mergeSort(nums, start, end, temp) {
if (start < end) {
//计算中间索引
let mid = parseInt((start + end) / 2);
//两部分比较大小合并
mergeSort(nums, start, mid, temp);
mergeSort(nums, mid+1, end, temp);
//合并两边的数组
merge(nums, start, mid, end, temp);
}
}
let arr = [2,5,3,10,-3,1,6,4];
let temp = [];
mergeSort(arr, 0, arr.length - 1, temp);
console.log(arr);//[ -3, 1, 2, 3, 4, 5, 6, 10]
比较的过程：自底向上 排序合并的过程
2,5,3,10,-3,1,6,4 =》2 5 3 10 -3 1 4 6
2 5 3 10 -3 1 4 6 =》 2 3 5 10 -3 1 4 6
2 3 5 10 -3 1 4 6 =》-3 1 2 3 4 5 6 10
5.快速排序
利用分治和交换排序的思想：
第一步：选择第一个数字分离出来为基数
第二步：然后将序列中大于基数的放在基数右边，小于基数的放在基数的左边
第三步：然后对基数的左边和右边两个序列重复第二步和第三步
相当要有一个基准元素，然后用双指针来每一个元素都和基准元素比较，比这个元素的大的 就放在右边，比这个元素大的 就放在左边。
所以先写交换逻辑
参数 nums数组
left 左边的索引
right 右边的索引
function adjustArray (nums, left, right) {
if (left > right) return;//递归中之条件
//定基准元素 第一个元素就是
let pivot = nums[left];
//开始比较
while(left < right) {
//从后面往前比较 比较的时候应该同时比较索引 因为--和++操会导致越界
while (nums[right] >= pivot && left < right) {
//索引递减
right--;
}
if(nums[right] < pivot) {
//如果小于基准元素
nums[left] = nums[right];
left++;
}
//从前面开始比较
while (nums[left] <= pivot && left < right) {
left++;
}
if(nums[left] > pivot) {
nums[right] = nums[left];
right--;
}
}
//比较之后 确定了基准元素需要放的位置
nums[left] = pivot;
return left;//返回位置 将数组一分为二 继续进行比较排序
}
//快排算法
function quickSort(nums, start, end){
if( start < end){
let i = adjustArray(nums, start, end);//获得一分为二的那个中间索引
quickSort(nums,start, i-1);
quickSort(nums,i+1,end);
}
}
let arr = [2,5,3,10,-3,1,6,4];
quickSort(arr, 0, arr.length -1);
console.log(arr); //[ -3, 1, 2, 3, 4, 5, 6, 10]
比较的过程：每一轮都有一个元素在最终位置上
第一轮：2,5,3,10,-3,1,6,4 =》1 -3 2 10 3 5 6 4
第二轮：1 -3 2 10 3 5 6 4=》-3 1 2 4 3 5 6 10
第三轮：-3 1 2 4 3 5 6 10 =》-3 1 2 3 4 5 6 10
第四轮：-3 1 2 **3 4 5 6 ** 10 =》-3 1 2 3 4 5 6 10
快速排序不稳定。
6 堆排序
首先一个数组要形成一个堆，然后最顶端的就是最大的值，如果是小顶堆最顶端就是最小值。将根与最后一个节点交换，就相当于把最大的值放在数组的最后一个位置。所以每一轮也是确定一个数。
function sort(arr) {
//实现一个堆结构 大顶堆 从最后一个父节点开始 到第一个父节点
for (let i = parseInt(arr.length/2) - 1; i >= 0; i--) {
//一个父节点就要形成一个堆结构 一直往下
toHeap(i, arr, arr.length);
}
// 也就是说每次都是根节点是最大的数 把他排除掉 之后继续做大顶堆 这是顶就是第二大的数 相当于每次都放在了最后 每一轮都排好了顺序
for(let j = arr.length - 1; j > 0; j--) {
swap(arr, 0, j);
toHeap(0, arr, j);
}
}
function swap(arr,i,j){
let empty = arr[i];
arr[i] = arr[j];
arr[j] = empty;
}
function toHeap(i, arr, length) {
//先保存父节点的值
let temp = arr[i];
//左孩子和右孩子
for (let k = 2 * i + 1; k < length; k = 2 * k + 1) {
//比较左右孩子的大小
if (k + 1 < length && arr[k] < arr[k + 1]) {
//右孩子大
k++;
}
//将大的孩子与父节点比较
if (arr[k] > temp) {
arr[i] = arr[k];
i = k;
//继续子树也要保证这个结构
}else{
break;
}
}
//把父元素补上
arr[i] = temp;
}
参考：
1.堆排序 https://blog.csdn.net/weixin_46726346/article/details/112974224
911
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
