Ruby实现的各种排序算法

   这篇文章主要介绍了Ruby实现的各种排序算法,本文给出了Bubble sort、Insertion sort、Selection sort、Shell sort等排序的实现方法,需要的朋友可以参考下

  时间复杂度:Θ(n^2)

  Bubble sort

  代码如下:

  def bubble_sort(a)

  (a.size-2).downto(0) do |i|

  (0..i).each do |j|

  a[j], a[j+1] = a[j+1], a[j] if a[j] > a[j+1]

  end

  end

  return a

  end

  Selection sort

  代码如下:

  def selection_sort(a)

  b = []

  a.size.times do |i|

  min = a.min

  b << min

  a.delete_at(a.index(min))

  end

  return b

  end

  Insertion sort

   代码如下:

  def insertion_sort(a)

  a.each_with_index do |el,i|

  j = i - 1

  while j >= 0

  break if a[j] <= el

  a[j + 1] = a[j]

  j -= 1

  end

  a[j + 1] = el

  end

  return a

  end

  Shell sort

  代码如下:

  def shell_sort(a)

  gap = a.size

  while(gap > 1)

  gap = gap / 2

  (gap..a.size-1).each do |i|

  j = i

  while(j > 0)

  a[j], a[j-gap] = a[j-gap], a[j] if a[j] <= a[j-gap]

  j = j - gap

  end

  end

  end

  return a

  end

  时间复杂度:Θ(n*logn)

  Merge sort

   代码如下:

  def merge(l, r)

  result = []

  while l.size > 0 and r.size > 0 do

  if l.first < r.first

  result << l.shift

  else

  result << r.shift

  end

  end

  if l.size > 0

  result += l

  end

  if r.size > 0

  result += r

  end

  return result

  end

  def merge_sort(a)

  return a if a.size <= 1

  middle = a.size / 2

  left = merge_sort(a[0, middle])

  right = merge_sort(a[middle, a.size - middle])

  merge(left, right)

  end

  Heap sort

  代码如下:

  def heapify(a, idx, size)

  left_idx = 2 * idx + 1

  right_idx = 2 * idx + 2

  bigger_idx = idx

  bigger_idx = left_idx if left_idx < size && a[left_idx] > a[idx]

  bigger_idx = right_idx if right_idx < size && a[right_idx] > a[bigger_idx]

  if bigger_idx != idx

  a[idx], a[bigger_idx] = a[bigger_idx], a[idx]

  heapify(a, bigger_idx, size)

  end

  end

  def build_heap(a)

  last_parent_idx = a.length / 2 - 1

  i = last_parent_idx

  while i >= 0

  heapify(a, i, a.size)

  i = i - 1

  end

  end

  def heap_sort(a)

  return a if a.size <= 1

  size = a.size

  build_heap(a)

  while size > 0

  a[0], a[size-1] = a[size-1], a[0]

  size = size - 1

  heapify(a, 0, size)

  end

  return a

  end

  Quick sort

  代码如下:

  def quick_sort(a)

  (x=a.pop) ? quick_sort(a.select{|i| i <= x}) + [x] + quick_sort(a.select{|i| i > x}) : []

  end

  时间复杂度:Θ(n)

  Counting sort

   代码如下:

  def counting_sort(a)

  min = a.min

  max = a.max

  counts = Array.new(max-min+1, 0)

  a.each do |n|

  counts[n-min] += 1

  end

  (0...counts.size).map{|i| [i+min]*counts[i]}.flatten

  end

  Radix sort

   代码如下:

  def kth_digit(n, i)

  while(i > 1)

  n = n / 10

  i = i - 1

  end

  n % 10

  end

  def radix_sort(a)

  max = a.max

  d = Math.log10(max).floor + 1

  (1..d).each do |i|

  tmp = []

  (0..9).each do |j|

  tmp[j] = []

  end

  a.each do |n|

  kth = kth_digit(n, i)

  tmp[kth] << n

  end

  a = tmp.flatten

  end

  return a

  end

  Bucket sort

   代码如下:

  def quick_sort(a)

  (x=a.pop) ? quick_sort(a.select{|i| i <= x}) + [x] + quick_sort(a.select{|i| i > x}) : []

  end

  def first_number(n)

  (n * 10).to_i

  end

  def bucket_sort(a)

  tmp = []

  (0..9).each do |j|

  tmp[j] = []

  end

  a.each do |n|

  k = first_number(n)

  tmp[k] << n

  end

  (0..9).each do |j|

  tmp[j] = quick_sort(tmp[j])

  end

  tmp.flatten

  end

  a = [0.75, 0.13, 0, 0.44, 0.55, 0.01, 0.98, 0.1234567]

  p bucket_sort(a)

  # Result:

  [0, 0.01, 0.1234567, 0.13, 0.44, 0.55, 0.75, 0.98]

时间: 2024-09-25 19:28:33

Ruby实现的各种排序算法的相关文章

Ruby实现的合并排序算法

  这篇文章主要介绍了Ruby实现的合并排序算法,本文直接给出实现代码,需要的朋友可以参考下 算法课的作业,利用分治法,合并排序. ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 #encoding: utf-8 #author: xu jin, 4100213 #date: Oct 27, 2012 #MergeSort #to sort a

Ruby实现的合并排序算法_ruby专题

算法课的作业,利用分治法,合并排序. #encoding: utf-8 #author: xu jin, 4100213 #date: Oct 27, 2012 #MergeSort #to sort an array by using MergeSort algorithm #example output: #The original array is:[4, 32, 84, 58, 49, 40, 75, 29, 82, 21, 70, 37, 70] #The sorted array i

Ruby实现的各种排序算法_ruby专题

时间复杂度:Θ(n^2) Bubble sort 复制代码 代码如下: def bubble_sort(a)    (a.size-2).downto(0) do |i|      (0..i).each do |j|        a[j], a[j+1] = a[j+1], a[j] if a[j] > a[j+1]      end    end    return a  end Selection sort 复制代码 代码如下: def selection_sort(a)    b =

PHP 四种基本排序算法的代码实现(1)

许多人都说算法是程序的核心,算法的好坏决定了程序的质量.作为一个初级phper,虽然很少接触到算法方面的东西.但是对于基本的排序算法还是应该掌握的,它是程序开发的必备工具.这里介绍冒泡排序,插入排序,选择排序,快速排序四种基本算法,分析一下算法的思路. 前提:分别用冒泡排序法,快速排序法,选择排序法,插入排序法将下面数组中的值按照从小到大的顺序进行排序. $arr(1,43,54,62,21,66,32,78,36,76,39); 1. 冒泡排序 思路分析:在要排序的一组数中,对当前还未排好的序

常用的各种排序算法

//常用的排序算法 #include <iostream> using namespace std; typedef int ElemType; /* 1.插入排序 (1)直接插入排序算法 算法思想:将等排序列划分为有序与无序两部分,然后再依次将无序部分插入到已经有序的部分,最后 就可以形成有序序列. 操作步骤如下: 1)查找出元素L(i)在表中的插入位置K: 2)将表中的第K个元素之前的元素依次后移一个位置: 3)将L(i)复制到L(K). 时间复杂度为:O(n^2) */ void Ins

各种排序算法汇总

目录 简介 交换排序 冒泡排序 快速排序 插入排序 直接插入排序 希尔排序 选择排序 简单选择排序 堆排序 归并排序 基数排序 总结 简介 排序是计算机内经常进行的一种操作,其目的是将一组"无序"的记录序列调整为"有序"的记录序列.分内部排序和外部排序.若整个排序过程不需要访问外存便能完成,则称此类排序问题为内部排序.反之,若参加排序的记录数量很大,整个序列的排序过程不可能在内存中完成,则称此类排序问题为外部排序.内部排序的过程是一个逐步扩大记录的有序序列长度的过程

九大排序算法总结

排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存. 常见的内部排序算法有:插入排序.希尔排序.选择排序.冒泡排序.归并排序.快速排序.堆排序.基数排序等. 算法一:插入排序 插入排序是一种最简单直观的排序算法,它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入. 算法步骤 1)将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当

内部排序算法:基数排序

基本思想 基数排序是一种非比较型整数排序算法,其原理是将整数按位数切割成不同的数字,然后按每个位数分别比较.由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数,所以基数排序也不是只能使用于整数. 基数排序可以采用两种方式: LSD(Least Significant Digital):从待排序元素的最右边开始计算(如果是数字类型,即从最低位个位开始). MSD(Most Significant Digital):从待排序元素的最左边开始计算(如果是数字类型,即从最高位开始). 我们以L

桶排序算法

桶排序 (Bucket sort)或所谓的箱排序,是一个排序算法,工作的原理是将数组分到有限数量的桶子里.每个桶子再个别排序(有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序).桶排序是鸽巢排序的一种归纳结果.当要被排序的数组内的数值是均匀分配的时候,桶排序使用线性时间(Θ(n)).但桶排序并不是比较排序,他不受到 O(n log n) 下限的影响. 本文地址:http://www.cnblogs.com/archimedes/p/bucket-sort-algorithm.html