ruby 快速排序、合并排序

最新推荐文章于 2024-03-07 18:17:15 发布

yangxing_star

最新推荐文章于 2024-03-07 18:17:15 发布

阅读量973

点赞数

分类专栏： ruby

本文链接：https://blog.csdn.net/yangxing_star/article/details/21248913

版权

ruby 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

 def qsort(list)
  return [] if list.size == 0
  x, *xs = *list
  less, more = xs.partition{|y| y < x}
  qsort(less) + [x] + qsort(more)
 end

 def qs(l)
  return [] if (x,*xs=l).empty?
  less, more = xs.partition{|y| y < x}
  qs(less) + [x] + qs(more)
 end

 def quicksort a
  (pivot = a.pop) ? quicksort(a.select{|i| i <= pivot}) + [pivot] + quicksort(a.select{|i| i > pivot}) : []
 end


   
   
    
    合并排序
   
   
   
   
    
    def 
    
    merge_sort
    
    (
    
    a
    
    )
   
   
   
       
    
    return 
    
    a 
    
    if 
    
    a
    
    .
    
    size 
    
    <= 
    
    1
   
   
   
       
    
    l
    
    , 
    
    r 
    
    = 
    
    split_array
    
    (
    
    a
    
    )
   
   
   
       
    
    result 
    
    = 
    
    combine
    
    (
    
    merge_sort
    
    (
    
    l
    
    ), 
    
    merge_sort
    
    (
    
    r
    
    ))
   
   
   
   
    
    end
   
   
   
   
    
     
   
   
   
   
    
    def 
    
    split_array 
    
    a
   
   
   
     
    
    mid 
    
    = 
    
    (
    
    a
    
    .
    
    size 
    
    / 
    
    2
    
    )
    
    .
    
    round
   
   
   
     
    
    [
    
    a
    
    .
    
    take
    
    (
    
    mid
    
    ), 
    
    a
    
    .
    
    drop
    
    (
    
    mid
    
    )
    
    ]
   
   
   
   
    
    end
   
   
   
   
    
     
   
   
   
   
    
    def 
    
    combine 
    
    a
    
    , 
    
    b
   
   
   
     
    
    return 
    
    b
    
    .
    
    empty? 
    
    ? 
    
    a 
    
    : 
    
    b 
    
    if 
    
    a
    
    .
    
    empty? 
    
    || 
    
    b
    
    .
    
    empty?
   
   
   
     
    
    smallest 
    
    = 
    
    a
    
    .
    
    first 
    
    <= 
    
    b
    
    .
    
    first 
    
    ? 
    
    a
    
    .
    
    shift 
    
    : 
    
    b
    
    .
    
    shift
   
   
   
     
    
    combine
    
    (
    
    a
    
    , 
    
    b
    
    )
    
    .
    
    unshift
    
    (
    
    smallest
    
    )
   
   
   
   
    
    end
   
   
   
   
    
     
   
   
   
   
    
    a 
    
    = 
    
    [
    
    6
    
    ,
    
    23
    
    ,
    
    53
    
    ,
    
    1
    
    ,
    
    2
    
    ,
    
    5
    
    ,
    
    62
    
    ,
    
    61
    
    ,
    
    33
    
    ,
    
    21
    
    ,
    
    14
    
    ,
    
    6
    
    ,
    
    23
    
    ].
    
    shuffle
   
   
   
   
    
    p 
    
    merge_sort
    
    (
    
    a
    
    ) 
    
    # p x <=> puts x.inspect