Sıralama Algoritmaları

/// countingSort - değerleri tutan bir diziyi sıralamak için.
///
/// Algoritmanın verimli çalışması için sıralacak
/// değerlerin aralığı sıralanacak öğelerin sayısından
/// çok daha büyük olmamalıdır.
///
/// param nums - girdi - sıralanacak değerler dizisi
/// param size - girdi - dizideki öğelerin sayısı
///
void counting_sort(int *nums, int size)
{
// search for the minimum and maximum values in the input
int i, min = nums[0], max = min;
for(i = 1; i < size; ++i)
{
if (nums < min)
min = nums;
else if (nums > max)
max = nums;
}

// create a counting array, counts, with a member for
// each possible discrete value in the input.
// initialize all counts to 0.
int distinct_element_count = max - min + 1;
int[] counts = new int[distinct_element_count];
for(i=0; i<distinct_element_count; ++i)
counts = 0;

// accumulate the counts - the result is that counts will hold
// the offset into the sorted array for the value associated with that index
for(i=0; i<size; ++i)
++counts[ nums - min ];

// store the elements in the array
int j=0;
for(i=min; i<=max; i++)
for(int z=0; z<counts[i-min]; z++)
nums[j++] = i;

delete[] counts;

Genişletmek için tıklayın...

while not InOrder(deck) do Shuffle(deck);

Genişletmek için tıklayın...

public int[] BogoSort(int[] numbers)
{
Random rnd = new Random();
while(true)
{
boolean sorted = true;
for(int i = 0; i < numbers.length-1; i++)
if(numbers > numbers[i+1])
sorted = false;
if (sorted)
return numbers;
for(int i = numbers.length - 1; i > 0; i--)
{
int rand = rnd.nextInt(i);
int temp = numbers;
numbers = numbers[rand];
numbers[rand] = temp;
}
}
}

Genişletmek için tıklayın...

Seçmeli sıralama algoritması​

Seçmeli Sıralama'nın nasıl çalıştığını gösteren görüntü​

for i ← 0 to n-2 do
min ← i
for j ← (i + 1) to n-1 do
if A[j] < A[min]
min ← j
swap A and A[min]

Genişletmek için tıklayın...

Seçmeli Sıralama Algoritmasının Örnek Kodu

public int[] secmeliSiralama(int[] dizi)
{
int enkucuk, yedek;
for (int i = 0; i < dizi.Length - 1; i++)
{
enkucuk = i;
for (int j = i + 1; j < dizi.Length; j++)
if (dizi[j] < dizi[enkucuk])
enkucuk = j;
if (enkucuk != i)
{
yedek = dizi;
dizi = dizi[enkucuk];
dizi[enkucuk] = yedek;
}
}
return dizi;

Genişletmek için tıklayın...

6 elemanlı içeriği karışık olarak verilmiş bir bir sayı dizisinin Seçmeli Sıralama algoritması kullanılarak nasıl küçükten-büyüğe doğru sıralandığını göstermektedir. 1. adımda dizinin ilk elemanı (6) alınır. Bu eleman diğer 5 eleman ile karşılaştırılır. Eğer bulunan eleman(1) ilk elemandan küçükse 1.elman ile yer değiştirilir. 2. adımda dizinin ikinci elemanı(3) alınır. Bu eleman kalan 4 eleman ile karşılaştırılır. Eğer bulunan eleman(2) ikinci elemandan küçükse 2. eleman ile yer değiştirilir ve bu işlem dizi sonuna kadar devam eder. Böylelikle dizi küçükten-büyüğe sıralanmış olur.

Karışık halde: 9 4 2 8 3 1 5 6 7
Sıraya dizilmiş: 1 2 3 4 5 6 7 8 9

Genişletmek için tıklayın...

function combsort11(array input)
gap := input.size //öğeler arasındaki aralığın başlangıç boyutunu belirle

loop until gap <= 1 or swaps = 0
//yeni bir tarama için aralığın boyutunu güncelle
if gap > 1
gap := gap / 1.3
if gap = 10 or gap = 9
gap := 11
end if
end if

i := 0
swaps := 0 // Açıklama için kabarcık sıralamasına bakınız

// giriş listesinin üzerinden tek bir "tarama"
loop until i + gap >= array.size //Benzer yaklaşım için kabuk sıralamasına bakınız
if array > array[i+gap]
swap(array, array[i+gap])
swaps := 1 // Aritmetik taşma düzeltmesi için
end if
i := i + 1
end loop

end loop
end function

Genişletmek için tıklayın...

function heapSort(a, count) is
input: an unordered array a of length count

(first place a in max-heap order)
heapify(a, count)

end := count - 1
while end > 0 do
(swap the root(maximum value) of the heap with the last element of the heap)
swap(a[end], a[0])
(decrease the size of the heap by one so that the previous max value will
stay in its proper placement)
end := end - 1
(put the heap back in max-heap order)
siftDown(a, 0, end)

function heapify(a,count) is
(start is assigned the index in a of the last parent node)
start := (count - 1) / 2

while start ≥ 0 do
(sift down the node at index start to the proper place such that all nodes below
the start index are in heap order)
siftDown(a, start, count-1)
start := start - 1
(after sifting down the root all nodes/elements are in heap order)

function siftDown(a, start, end) is
input: end represents the limit of how far down the heap
to sift.
root := start

while root * 2 + 1 ≤ end do (While the root has at least one child)
child := root * 2 + 1 (root*2+1 points to the left child)
(If the child has a sibling and the child's value is less than its sibling's...)
if child < end and a[child] < a[child + 1] then
child := child + 1 (... then point to the right child instead)
if a[root] < a[child] then (out of max-heap order)
swap(a[root], a[child])
root := child (repeat to continue sifting down the child now)
else
return

Genişletmek için tıklayın...

function heapify(a,count) is
(end is assigned the index of the first (left) child of the root)
end := 1

while end < count
(sift up the node at index end to the proper place such that all nodes above
the end index are in heap order)
siftUp(a, 0, end)
end := end + 1
(after sifting up the last node all nodes are in heap order)

function siftUp(a, start, end) is
input: start represents the limit of how far up the heap to sift.
end is the node to sift up.
child := end
while child > start
parent := ⌊(child - 1) ÷ 2⌋
if a[parent] < a[child] then (out of max-heap order)
swap(a[parent], a[child])
child := parent (repeat to continue sifting up the parent now)
else
return

Genişletmek için tıklayın...

procedure strandSort( A : list of sortable items ) defined as:
while length( A ) > 0
clear sublist
sublist[ 0 ] := A[ 0 ]
remove A[ 0 ]
for each i in 0 to length( A ) do:
if A[ i ] > sublist[ last ] then
append A[ i ] to sublist
remove A[ i ]
end if
end for
merge sublist into results
end while
return results
end procedure

Genişletmek için tıklayın...

public static LinkedList<int> sort(LinkedList<int> array) {
LinkedList<int> results = new LinkedList<int>();
LinkedList<int> sublist = new LinkedList<int>();
while (array.Count != 0)
{
sublist.Clear();
sublist.AddLast(array.First.Value);
array.RemoveFirst();
LinkedListNode<int> i = array.First;
while (i != null)
{
if(i.Value >= sublist.Last.Value)
{
sublist.AddLast(i.Value);
LinkedListNode<int> temp = i;
i = i.Next;
array.Remove(temp);
}
else
{
i = i.Next;
}
}

i = results.First;
while (sublist.Count != 0)
{
if (i == null)
{
results.AddLast(sublist.First.Value);
sublist.RemoveFirst();
}
else if (sublist.First.Value < i.Value)
{
results.AddBefore(i, sublist.First.Value);
sublist.RemoveFirst();
}
else
{
i = i.Next;
}
}
}
return results;
}

Genişletmek için tıklayın...

public static <E extends Comparable<? super E>> List<E> sort(Collection<E> coll) {
List<E> results = new LinkedList<E>();

while (!coll.isEmpty())
{
LinkedList<E> sublist = new LinkedList<E>();
Iterator<E> i = coll.iterator();
sublist.addLast(i.next());
while (i.hasNext())
{
E val = i.next();
if (val.compareTo(sublist.getLast()) >= 0)
{
sublist.addLast(val);
i.remove();
}
}

if (!results.isEmpty())
{
ListIterator<E> li = results.listIterator();
E current = li.next();
while (!sublist.isEmpty())
{
if (sublist.getFirst().compareTo(current) < 0)
li.add(sublist.removeFirst());
else if (li.hasNext())
current = li.next();
else
break;
}
}
results.addAll(sublist);
}
return results;
}

Genişletmek için tıklayın...