Büyük ve kendini hiç tekrar miktarı nedeniyle"Nasıl bir dizi benim eşsiz kar tanesi sıralama?"soru, bu PHP temel sıralama yöntemleri başvuru topluluğudur. Yinelenen bu bir belirgin olarak farklı değildir, yakın herhangi bir soru lütfen.

Nasıl PHP bir dizi sıralama?
Nasıl bir sıralama yaparımkarmaşıkPHP dizi?
Nasıl PHP nesneleri bir dizi sıralama?

1. Basic one dimensional arrays; Incl. Multi dimensional arrays, incl. arrays of objects; Incl. Sorting one array based on another
2. Sorting with SPL
3. Stable sort

Pratik cevap PHP mevcut işlevleri 1. kullanma, akademik için ayrıntılı cevap algoritmaları sıralama (PHP fonksiyonları uygulamak ve hangiolabilirgerçekten ihtiyacım var, çok karmaşık olgu), 2.

En temel yöntem zaten deceze ile kaplıdır yani bir bakıma diğer türleri bakmak için denemek istiyorum

SPL sıralama ile

SplHeap

class SimpleHeapSort extends SplHeap {
    public function compare($a, $b) {
        return strcmp($a, $b);
    }
}

// Let's populate our heap here (data of 2009)
$heap = new SimpleHeapSort();
$heap->insert("a");
$heap->insert("b");
$heap->insert("c");

echo implode(PHP_EOL, iterator_to_array($heap));

Çıktı

c
b
a

SplMaxHeap

SplMaxHeap sınıf bir yığın temel işlevleri, üst maksimum koruma sağlar.

$heap = new SplMaxHeap();
$heap->insert(1);
$heap->insert(2);
$heap->insert(3);

SplMinHeap

SplMinHeap sınıf bir yığın temel işlevleri, üstüne minimum tutmak sağlar.

$heap = new SplMinHeap ();
$heap->insert(3);
$heap->insert(1);
$heap->insert(2);

Bir Nevi diğer Türleri

Kabarcık Sıralama

Wikipedia article on Bubble Sort:

Kabarcık sıralama, bazen hatalı olarak batan sıralama, basit bir sıralama algoritması bu eserler art arda Atlama Listesi için sıralama, karşılaştırma her çifti bitişik öğeleri ve takas onları eğer onlar yanlış sipariş. Listenin üzerinden geçmek liste sıralanır gösterir herhangi bir swapları gerektiği kadar tekrarlanır. Yol adını alır algoritma daha küçük elemanlar "kabarcık" için listenin en üstüne. Sadece karşılaştırma öğeleri üzerinde çalışmak için kullanması nedeniyle, karşılaştırma bir tür. Algoritması basit olmasına rağmen, diğer sıralama algoritmaları en büyük listeleri için daha verimlidir.

function bubbleSort(array $array) {
    $array_size = count($array);
    for($i = 0; $i < $array_size; $i   ) {
        for($j = 0; $j < $array_size; $j   ) {
            if ($array[$i] < $array[$j]) {
                $tem = $array[$i];
                $array[$i] = $array[$j];
                $array[$j] = $tem;
            }
        }
    }
    return $array;
}

Seçim sıralama

the Wikipedia article on Selection sort:

Bilgisayar bilimleri, seçim gibi bir sıralama algoritması, özellikle yerinde karşılaştırma sıralama. (N2) O zaman karmaşıklığı, büyük listeler üzerinde verimsiz hale gelmiştir, ve genellikle kötü benzer eklemeli sıralama gerçekleştirir. Sıralama sadeliği dikkat çekiyor ve özellikle yardımcı bellek sınırlı olduğu bazı durumlarda daha karmaşık algoritmalar üzerinde performans avantajları vardır.

function selectionSort(array $array) {
    $length = count($array);
    for($i = 0; $i < $length; $i   ) {
        $min = $i;
        for($j = $i   1; $j < $length; $j   ) {
            if ($array[$j] < $array[$min]) {
                $min = $j;
            }
        }
        $tmp = $array[$min];
        $array[$min] = $array[$i];
        $array[$i] = $tmp;
    }
    return $array;
}

Eklemeli sıralama

Wikipedia article on Insertion sort:

Eklemeli sıralama son sıralı dizi (liste) bir defada tek bir öğe oluşturur basit bir sıralama algoritmasıdır. Quicksort, yığın sıralaması gibi daha gelişmiş algoritmalar daha büyük listeleri veya birleştirme sıralama çok daha verimli olur. Ancak, eklemeli sıralama çeşitli avantajları sağlar:

function insertionSort(array $array) {
    $count = count($array);
    for($i = 1; $i < $count; $i   ) {

        $j = $i - 1;
        // second element of the array
        $element = $array[$i];
        while ( $j >= 0 && $array[$j] > $element ) {
            $array[$j   1] = $array[$j];
            $array[$j] = $element;
            $j = $j - 1;
        }
    }
    return $array;
}

Shellsort

Wikipedia article on Shellsort:

Shellsort, ya da Kabuk Kabuk sıralama yöntemi olarak bilinen yerde karşılaştırma sıralama. Karşılaştırma ve uzak komşu elemanları ile bitirmeden önce elementleri, elementlerin alışverişi başlatarak alışverişi bir tür, ekleme veya kabarcık sıralama gibi, yaygınlaştırır.

function shellSort(array $array) {
    $gaps = array(
            1,
            2,
            3,
            4,
            6
    );
    $gap = array_pop($gaps);
    $length = count($array);
    while ( $gap > 0 ) {
        for($i = $gap; $i < $length; $i   ) {
            $tmp = $array[$i];
            $j = $i;
            while ( $j >= $gap && $array[$j - $gap] > $tmp ) {
                $array[$j] = $array[$j - $gap];
                $j -= $gap;
            }
            $array[$j] = $tmp;
        }
        $gap = array_pop($gaps);
    }
    return $array;
}

Tarak gibi

the Wikipedia article on Comb sort:

Tarak sıralama nispeten basit bir sıralama algoritması aslında 1980 yılında Wlodzimierz Dobosiewicz tarafından tasarlanmıştır. Daha sonra, 1991 yılında Stephen Lacey ve Richard Box tarafından keşfedildi. Tarak sıralama kabarcık sıralama geliştirir.

function combSort(array $array) {
    $gap = count($array);
    $swap = true;
    while ( $gap > 1 || $swap ) {
        if ($gap > 1)
            $gap /= 1.25;
        $swap = false;
        $i = 0;
        while ( $i   $gap < count($array) ) {
            if ($array[$i] > $array[$i   $gap]) {
                // swapping the elements.
                list($array[$i], $array[$i   $gap]) = array(
                        $array[$i   $gap],
                        $array[$i]
                );
                $swap = true;
            }
            $i   ;
        }
    }
    return $array;
}

Sıralama birleştirme

the Wikipedia article on Merge sort:

Bilgisayar bilimi, birleştirmeli sıralama (mergesort da yaygın yazıldığından) bir O(n log n) karşılaştırma tabanlı sıralama algoritması. Çoğu uygulamaları uygulama sıralanmış çıkışı eşit elemanlarının giriş düzenini korur anlamına gelir istikrarlı bir tür üretmek

function mergeSort(array $array) {
    if (count($array) <= 1)
        return $array;

    $left = mergeSort(array_splice($array, floor(count($array) / 2)));
    $right = mergeSort($array);

    $result = array();

    while ( count($left) > 0 && count($right) > 0 ) {
        if ($left[0] <= $right[0]) {
            array_push($result, array_shift($left));
        } else {
            array_push($result, array_shift($right));
        }
    }
    while ( count($left) > 0 )
        array_push($result, array_shift($left));

    while ( count($right) > 0 )
        array_push($result, array_shift($right));

    return $result;
}

Quicksort

the Wikipedia article on Quicksort:

Quicksort veya bölüm-exchange sıralama, ortalama(n günlük n) karşılaştırmalar n öğeleri sıralama yapan bir sıralama algoritması Tony Hoare tarafından geliştirilmiştir. En kötü durumda, bu davranış, nadir olsa da(n2) O karşılaştırmaları yapar.

function quickSort(array $array) {
    if (count($array) == 0) {
        return $array;
    }
    $pivot = $array[0];
    $left = $right = array();
    for($i = 1; $i < count($array); $i   ) {
        if ($array[$i] < $pivot) {
            $left[] = $array[$i];
        } else {
            $right[] = $array[$i];
        }
    }
    return array_merge(quickSort($left), array(
            $pivot
    ), quickSort($right));
}

Permütasyon sıralama

the Wikipedia article on Permutation sort:

Bu sıralanmış bir dizi keşfetmek kadar giriş/liste Olası permütasyon üreterek devam eder sıralama, permütasyon.

function permutationSort($items, $perms = array()) {
    if (empty($items)) {
        if (inOrder($perms)) {
            return $perms;
        }
    } else {
        for($i = count($items) - 1; $i >= 0; -- $i) {
            $newitems = $items;
            $newperms = $perms;
            list($foo) = array_splice($newitems, $i, 1);
            array_unshift($newperms, $foo);
            $res = permutationSort($newitems, $newperms);
            if ($res) {
                return $res;
            }
        }
    }
}

function inOrder($array) {
    for($i = 0; $i < count($array); $i   ) {
        if (isset($array[$i   1])) {
            if ($array[$i] > $array[$i   1]) {
                return False;
            }
        }
    }
    return True;
}

Taban sıralama

the Wikipedia article on Radix sort:

Bilgisayar Mühendisliği, taban sıralama aynı önemli konumu ve değeri paylaşan tek basamak tarafından anahtarları gruplandırarak tamsayı tuşları ile veri türlü olmayan karşılaştırmalı tamsayı sıralama algoritmasıdır.

// Radix Sort for 0 to 256
function radixSort($array) {
    $n = count($array);
    $partition = array();

    for($slot = 0; $slot < 256;    $slot) {
        $partition[] = array();
    }

    for($i = 0; $i < $n;    $i) {
        $partition[$array[$i]->age & 0xFF][] = &$array[$i];
    }

    $i = 0;

    for($slot = 0; $slot < 256;    $slot) {
        for($j = 0, $n = count($partition[$slot]); $j < $n;    $j) {
            $array[$i   ] = &$partition[$slot][$j];
        }
    }
    return $array;
}