单词解释
1.稳定
排序前a在b的前面，排序后a仍然在b的前面，则为稳定排序
2.不稳定
排序前a在b的前面，排序后a在b的后面，则为不稳定排序
3.时间复杂度
需要比较的次数
4.空间复杂度
算法在计算机中占有的内存
排序算法
1.冒泡排序
算法描述
1.比较两个相邻的元素，如果前者大于后者，则交换两者位置
2.重复以上动作，直到排序完成
代码
function bubbleSort(arr) {
let length=arr.length
for(let i = 0;i<length-1;i++){ // 做length次这样的比较，就可以排好序。
// 例如最后一个数是1，最小的，只需要调动length次就可以排好
for(let j = 0 ;j <length-1-i;j++){
if(arr[j]>arr[j+1]){
let temp=arr[j]
arr[j]=arr[j+1]
arr[j+1]=temp
}
}
}
return arr
}
图片解释
2.选择排序
选择数组中最小值（最大值），将其放入新数组中，然后从剩下的数组中再次选取最小值（最大值）
一个长度为n的数组应该比较n-1次后会变成有序数组
最稳定的算法，时间复杂度一直都是O(n*n)
代码
function selectSort(arr) {
let length=arr.length
let minIndex,temp
for(let i =0;i<length;i++){
minIndex=i
for(let j = i+1;j<length;j++){
if(arr[j]<arr[minIndex]){ // 如果后者小于前者，那么交换位置
minIndex=j
}
}
temp=arr[minIndex]
arr[minIndex]=arr[i]
arr[j]=temp
}
return arr
}
图片描述
3.插入排序
逐个取数组中的元素，如果大于刚刚取的上一个的值，便插入到上一个值的后面；如果小于刚刚取的上一个的值，便插入到上一个值的前面
function insertSort(arr) {
let length=arr.length
let preIndex,current
for(let i = 1;i<length;i++){
preIndex=i-1
current=arr[i] // 将现在要比较的值保存到current中
while(arr[preIndex]>current && preIndex >=0){
// 把比较大的元素往后移
arr[preIndex+1]=arr[preIndex]
preIndex--
}
arr[preIndex+1]=current
}
return arr
}
4.希尔排序
是简单插入排序的改善版，它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
原理是将原有的数组按照一定的gap（增量）切割成n组，进行排序后，此时的数组是部分有序
最后的gap值为1，即整个数组被分成了一组。此时的数组已经接近有序了，因此插入排序的效率变高
代码
function ShellSort(arr) {
let length=arr.length
for(let gap= Math.floor(length/2);gap>0;gap=gap/2){
for(let i =gap ; i<length ;i++){
let temp=arr[i]
let preIndex=i
while(preIndex-gap>=0 && temp>arr[preIndex-gap]){
arr[preIndex]=arr[preIndex-gap]
preIndex=preIndex-gap
}
arr[preIndex]=temp
}
}
return arr
}
5.归并排序
采用了分治法，将长度为n的一个数组分成长度为n/2的小数组。直到最终gap=1，合成一个大的数组
可以理解为先分，分完排序后再合。合的时候也要按照顺序。
时间复杂度：O(nlogn)
空间复杂度：O(n)
代码
// 采用递归的方法，当length==2时，就不再排序
function mergeSort(arr) {
let length=arr.length
if(length<2){
return arr
}
let middle=Math.floor(length/2),
left=arr.slice(0,middle),
right=arr.slice(middle)
// 递归
return merge(mergeSort(left),mergeSort(right))
}
// 合并数组的操作
function merge(left,right){
let result=[]
while (left.length>=0 && right.length >= 0) {
if (left[0] <= right[0]) {
// 逐个返回第一个比较小的元素
// shift() 删除数组的第一个元素并返回
result.push(left.shift())
} else {
result.push(right.shift())
}
}
while(left.length){
result.push(left.shift())
}
while(right.length){
result.push(right.shift())
}
}
6.快速排序
在数组中找一个基准，比基准大的放在基准后面，比基准小的放在基准前面。此时该基准是有序的，左面的都比它小，右面的都比它大。相当于把该数组分割成了两个小数组。
然后再对左面和右面的数组分别进行排序操作，递归操作，直到数组的长度为1。
单向调整：
代码
// 单项调整,left为比较的第一个数字，right为最后一个数字
function partion(arr,left,right) {
let pivot = arr[left]; // pivot存放基准元素。基准元素左侧都小于它，右侧都大于它。
//
let i = left // i记录pivot元素的位置，i代表左指针，左指针始终大于基准元素
let j ;// j记录移动指针的位置
for(j=i+1;j<=right;j++){ // 移动指针始终从左指针的下一个开始向右移动。
if(arr[j]<pivot){ // 如果当下指针指向的数据，是小于基准元素的，那么基准元素向右挪一位，并与当前指针的元素交换
i++
[arr[i],arr[j]] = [arr[j],arr[i]]
}
}
[arr[i],arr[left]] = [arr[left],arr[i]]
//返回主元的下标
return i
}
function quickSort(arr,left,right) {
let center
if (left<right){
center=partion(arr,left,right)
quickSort(arr,left,center-1) // 左半部分排序
quickSort(arr,center+1,right) //右半部分排序
}
}
双向调整
// 单项调整,left为比较的第一个数字，right为最后一个数字
function partion(arr,left,right) {
let pivot = arr[left];
let i = left+1;
let j = right;
while (i<=j){
while (arr[i]<pivot && i<=j){
i++
}
while (arr[j]>pivot && i<= j){
j--
}
// if (i>j){
// break
// }
if (i<=j){
[arr[i],arr[j]] = [arr[j],arr[i]]
i++
j--
}
}
[arr[j],arr[left]] = [arr[left],arr[j]]
//返回主元的下标
return j
}
function quickSort(arr,left,right) {
let center
if (left<right){
center=partion(arr,left,right)
quickSort(arr,left,center-1) // 左半部分排序
quickSort(arr,center+1,right) //右半部分排序
}
}
7.堆排序
堆的特点就是堆顶的元素是一个最值，大顶堆的堆顶是最大值，小顶堆则是最小值。
二叉堆是一种特殊的堆，具有以下特性：
（1）具有完全二叉树的特性。
（2）堆中的任何一个父节点的值都大于等于它左右孩子节点的值，或者都小于等于它左右孩子节点的值。
二叉堆的主要三个操作：
（1）插入一个节点。
（2）删除一个节点。（一般删除根节点）
（3）构建一个二叉堆。
（1）插入一个节点
插入节点时，都是插入到完全二叉树最后的位置
然后将其与父元素作比较，如果小于父元素，则上浮。
（2）删除一个节点
删除根节点后，首先要恢复二叉堆的特性。
采取的策略是，根节点删除后，用二叉堆最后一个元素顶上来
例如在下图中，删除0节点后，5上浮，比较5与1和3，然后5下沉，1上浮，再次比较。
（3）构建二叉树
所谓构建，就是给你一个有n个节点的无序的完全二叉树，然后把它构建成二叉堆。
刚才我们在删除一个节点的时候，把最后一个元素补到根元素的位置上去，然后再让这个元素依次下沉，实际上，在这个元素还没有下沉之前，它就可以看作是一颗无序的完全二叉树了。
也就是说，要把一个无序的完全二叉树调整为二叉堆，我们可以让所有非叶子节点依次下沉。不过下沉的顺序不是从根节点开始下沉(想一下相必你就 知道不能从根节点开始下沉)，而是从下面的非叶子节点下称，在依次往上。
因此，二叉堆排序的原理便是：
给你一个无序的数组，我们需要把这个数组构建成二叉堆，然后在通过堆顶逐个删除的方式来实现堆排序。
let len;
function buildMaxHeap(arr) {
len=arr.length
for(let i = Math.floor(len/2);i>=0;i--){
heapify(arr,i)
}
}
function heapify(arr,i) {
let left=i*2+1,
right=i*2+2,
largest=i;
if(left<len && arr[left] >arr[largest]){
largest=left
}
if(right<len && arr[right] > arr[largest]){
largest=right
}
if(largest != i){
swap(arr,i,largest)
heapify(arr,largest)
}
}
function heapSort(arr) {
buildMaxHeap(arr)
for(let i = arr.length -1; i>0;i--){
swap(arr,0,i);
len--
heapify(arr,0)
}
return arr
}
// 交换数组中两个元素
function swap(arr, i, j) {
var temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
2780
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
