js冒泡排序法——选择排序(other)——计数排序（桶排序）——快速排序——插入排序-更新

Posted 2022-07-15 勇敢*牛牛

javascript排序算法

• • JavaScript——冒泡排序法
  • JavaScript——选择排序
  • JavaScript——计数排序（桶排序）
  • JavaScript——快速排序(递归二分法)
  • JavaScript——插入排序

JavaScript——冒泡排序法

时间复杂度：O(nlogn)

冒泡排序的英文Bubble Sort，是一种最基础的交换排序。
之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。

第一轮: 两两比较, 如果前一个大于后一个, 交换位置 一轮过后, 最大的放在了最后面
重复第一轮:
重复 length - 1 轮

从大到小

var array = [1,2,8,4,5,12];
for(var i =0;i<array.length;i++)
    for(var j=0;j<array.length-i-1;j++)
        if(array[j] < array[j+1])
            var count = array[j];
            array[j] = array[j+1];
            array[j+1] = count;
        
    

console.log(array);

从小到大

var array = [1,2,8,4,4,12];
for(var i =0;i<array.length;i++)
	for(var j=0;j<array.length-i-1;j++)
	    if(array[j] > array[j+1])
	        var count = array[j];
	        array[j] = array[j+1];
	        array[j+1] = count;
	    
	

	console.log(array);

---

JavaScript——选择排序

时间复杂度O(n^2)

算法思想：选择排序，从头至尾扫描序列，找出最小的一个元素，和第一个元素交换
接着从剩下的元素中继续这种选择和交换方式，最终得到一个有序序列。

第一轮:
找到数组内最小的数据的索引
把最小的移动到最前面
第二轮:
找到除了第一个以外的内容中最小的数据的索引
把第二次找到的数字放在第二个位置
重复 length - 1 轮

从小到大

var min; //保存每次搜索到的最小值；
var index; //保存最小值的下标；

var array = [1,2,8,4,4,12];
for(var i = 0; i < array.length; i++)
    min = array[i]; //将未排序部分的最左边的数假设为最小值；
    index = i;
    for(var j = 0; j < array.length - i - 1; j++)
        if(array[j+i+1] >= min) //若大于最小值则继续；
            continue;
        else //更新最小值与下标
            min = array[j+i+1];
            index = j+i+1;
        
    
    array[index] = array[i]; //交换最小值与第一个被假设为最小值的元素位置；
    array[i] = min;

console.log(array);

从大到小

var min; //保存每次搜索到的最小值；
var index; //保存最小值的下标；
for(var i = 0; i < array.length; i++)
    min = array[i]; //将未排序部分的最左边的数假设为最小值；
    index = i;
    for(var j = 0; j < array.length - i - 1; j++)
        if(array[j+i+1] <= min) //若大于最小值则继续；
            continue;
        else //更新最小值与下标
            min = array[j+i+1];
            index = j+i+1;
        
    
    array[index] = array[i]; //交换最小值与第一个被假设为最小值的元素位置；
    array[i] = min;

console.log(array);

other

var arr  = [4,9,8,5,7,1,5,6,0,3]

var minIndex = 0
for(var j=0;j<arr.length;j++)
	for(var i=j+1;i<arr.length;i++)
	    if(arr[i]<arr[minIndex]) minIndex = i
	

	if(minIndex !== 0)
	     var tmp =arr[j];
	     arr[j]  = arr[minIndex];
	     arr[minIndex] = tmp
	 

console.log(arr);
console.log(minIndex);

---

JavaScript——计数排序（桶排序）

准备一个原始数组(001)
准备一个新的空数组(002)
遍历原始数组(001) 把每一个数据当做新数组(002)的索引
在新数组(002) 内的值当做个数来填充
遍历新数组(002) 把索引当数据填充回去, 填充多少个(值是多少填充多少个)

var arr  = [7,3,24,5,20,1,0,12,10,0,5]
var temp = []//计个数
for(var i=0;i<arr.length;i++)
	//把原始数组内的数据当做新数组内的索引使用
    temp[arr[i]] ? temp[arr[i]]++ : temp[arr[i]] = 1     

arr.length = 0;

console.log(temp);

for(var i=0; i<temp.length; i++)
    if(!temp[i]) continue
    // 回填的个数
    var count = temp[i];
    // 回填的数据
    data = i;
    // 多相同数字一次赋值
    for(var j=0;j<count;j++)
        arr[arr.length] = data
    


console.log(arr);

---

JavaScript——快速排序(递归二分法)

逻辑:

排序算法 - 快速排序(递归二分法)
逻辑:
把一个数组拿出最中间一个数据
把数组中剩下的数据和这个中心位置数据比较
准备两个新数组, 一个叫做 left 一个叫做 right
小的放在 left 内, 大的放在 right 内
递归把 左边的数组 和 右边的数组 按照之前的方法继续

function quickSort(arr)
    if(arr.length <= 1)
        return arr
    
    var centerIndex = parseInt(arr.length/2)
    var center  = arr.splice(centerIndex,1)[0]

    var left  =[],right= [];
    for(var i=0;i<arr.length;i++)
        if(arr[i] < center) left.push(arr[i])
        else right.push(arr[i])

    
    return quickSort(left).concat(center,quickSort(right))
    //或者
    return [...quickSort(left),center,...quickSort(right)]


var res = quickSort(arr)
console.log(res);

---

JavaScript——插入排序

=> 直接遍历数组(从 [1] 开始遍历)
	-> 把当前这个索引位置数据拿出来
	-> 从当前位置的前一个位置开始向前比较
	-> 如果 没循环到头 && 我比前一个大
+ 让前一个占领当前的位置
	-> 把自己放在这个位置

<h1>一起吃火锅唱歌跳舞</h1>
<script>
    var arr =[4,7,5,3,2,4,9,1,8,6]
    console.log('原始数据：',arr);
    for(var i=1;i<arr.length;i++)
        var temp = arr[i];
        var j=i-1
        for(;j>=0 && temp > arr[j];j--)
            arr[j+1] = arr[j] 
        
        console.log(arr);
        arr[j+1] = temp

        console.log('变化后的：',arr);
    

---