JavaScript实现十大常用排序算法

冒泡排序  选择排序  插入排序  快速排序  归并排序  希尔排序  堆排序 计数排序 桶排序 计数排序

冒泡排序:

原理

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

   
       
   
        
   
         
   
          
   
         
         
   
          
   
           // 使用冒泡排序
          
         
        
   
         
   
          
   
         
         
   
          
   
           const bubbleSort = (arr) => {
          
         
        
   
         
   
          
   
         
         
   
          
     let len = arr.length
          
         
        
   
         
   
          
   
         
         
   
          
     for(let i = 0; i < len - 1; i++) { // 外层的循环遍历到 倒数第二个
          
         
        
   
         
   
          
   
         
         
   
          
       for(let q = i + 1; q < len; q++) { // 内层的遍历 遍历到到最后一个
          
         
        
   
         
   
          
   
         
         
   
          
         if(arr[i] > arr[q]) {  // 如果前面的大于后面的 则交换为位置
          
         
        
   
         
   
          
   
         
         
   
          
           let temp = arr[i]
          
         
        
   
         
   
          
   
         
         
   
          
   
                   arr[i] = arr[q]
          
         
        
   
         
   
          
   
         
         
   
          
   
                   arr[q] = temp
          
         
        
   
         
   
          
   
         
         
   
          
   
                 }
          
         
        
   
         
   
          
   
         
         
   
          
   
               }
          
         
        
   
         
   
          
   
         
         
   
          
       console.log(`第${i+1}次排序后的记过${arr}`)
          
         
        
   
         
   
          
   
         
         
   
          
   
             }
          
         
        
   
         
   
          
   
         
         
   
          
     return arr
          
         
        
   
         
   
          
   
         
         
   
          
   
           }
          
         
        
   
         
   
          
   
         
         
   
          
   
           let res = bubbleSort([2,5,3,7,5,9,3,5,7,2,1])
          
         
        
   
         
   
          
   
         
         
   
          
   
           console.log(`最终结果是:${res}`)
          
         
       
      
   
       
      
      
   

   打印的效果
   

选择排序:

原理:

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

代码如下:

  

   

    

     

    
    

     

      // 使用选择排序
     
    
   

    

     

    
    

     

      const selectSort = (arr) => {
     
    
   

    

     

    
    

     
  let len = arr.length
     
    
   

    

     

    
    

     
  let minIndex,temp
     
    
   

    

     

    
    

     
  for(let i = 0; i < len - 1; i++){
     
    
   

    

     

    
    

     

          minIndex = i // 排序第i个位置应该是几
     
    
   

    

     

    
    

     
    for(let q = i; q < len; q++){
     
    
   

    

     

    
    

     
      if(arr[q] < arr[minIndex]) { 
     
    
   

    

     

    
    

     

              minIndex = q
     
    
   

    

     

    
    

     

            }
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

          temp = arr[i]
     
    
   

    

     

    
    

     

          arr[i] = arr[minIndex] // 交换i与minIndex的位置
     
    
   

    

     

    
    

     

          arr[minIndex] = temp
     
    
   

    

     

    
    

     
    console.log(`第${i+1}次排序:${arr}`)
     
    
   

    

     

    
    

     

        }
     
    
   

    

     

    
    

     
  return arr
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      let res = selectSort([2,5,3,7,5,9,3,5,7,2,1])
     
    
   

    

     

    
    

     

      console.log(`最终排序结果${res}`)
     
    
  
 

  
 
 

执行结果如下

插入排序

原理:

每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

  

   

    

     

    
    

     

      // 使用插入排序
     
    
   

    

     

    
    

     

      const insertionSort = (arr) => {
     
    
   

    

     

    
    

     
  let len = arr.length
     
    
   

    

     

    
    

     
  let preIndex,current
     
    
   

    

     

    
    

     
  for(let i = 0; i < len; i++) {
     
    
   

    

     

    
    

     

          preIndex = i - 1
     
    
   

    

     

    
    

     

          current = arr[i]
     
    
   

    

     

    
    

     
    while(preIndex >=0 && arr[preIndex] > current) {
     
    
   

    

     

    
    

     

            arr[preIndex + 1] = arr[preIndex]
     
    
   

    

     

    
    

     

            preIndex --
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

          arr[preIndex + 1] = current
     
    
   

    

     

    
    

     
    console.log(`第${i}次排序:${arr}`)
     
    
   

    

     

    
    

     

        }
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      let res = insertionSort([2,5,3,7,5,9,3,5,7,2,1])
     
    
   

    

     

    
    

     

      console.log(`最终结果${res}`)
     
    
  
 

  
 
 

执行结果 执行过程动态

文章来源: fizzz.blog.csdn.net，作者：拿我格子衫来，版权归原作者所有，如需转载，请联系作者。

原文链接：fizzz.blog.csdn.net/article/details/100033236