Various sorting algorithms implemented by Ruby

This article introduces all sorts of algorithms that Ruby realizes, this article gives the realization method of bubble sort, insertion sort, Selection sort, Shell sort and so on, the friend who needs can refer to the following

Complexity of Time: Theta (n^2)

Bubble sort

The code is as follows:

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

The code is as follows:

Def Selection_sort (a)

b = []

A.size.times do |i|

Min = a.min

b << min

A.delete_at (min) (a.index)

End

Return b

End

Insertion Sort

The code is as follows:

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

The code is as follows:

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

Complexity of Time: Theta (N*LOGN)

Merge sort

The code is as follows:

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

The code is as follows:

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

The code is as follows:

Def Quick_sort (a)

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

End

Time complexity: Theta (N)

Counting sort

The code is as follows:

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

The code is as follows:

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

The code is as follows:

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 *). 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]