คำถามนี้มีจุดประสงค์เพื่อใช้อ้างอิงสำหรับคำถามเกี่ยวกับการเรียงลำดับอาร์เรย์ใน PHP เป็นเรื่องง่ายที่จะคิดว่ากรณีของคุณมีลักษณะเฉพาะและมีค่าสำหรับคำถามใหม่ แต่ส่วนใหญ่เป็นวิธีแก้ไขปัญหาเล็กน้อยในหน้านี้

หากคำถามของคุณถูกปิดซ้ำซ้อนกับคำถามนี้โปรดขอให้คำถามของคุณเปิดขึ้นมาใหม่ก็ต่อเมื่อคุณสามารถอธิบายได้ว่าทำไมมันถึงแตกต่างอย่างชัดเจนจากด้านล่างทั้งหมด

ฉันจะจัดเรียงอาร์เรย์ใน PHP ได้อย่างไร
ฉันจะจัดเรียงอาร์เรย์ที่ซับซ้อนใน PHP ได้อย่างไร
ฉันจะจัดเรียงอาร์เรย์ของวัตถุใน PHP ได้อย่างไร

1. อาร์เรย์หนึ่งมิติพื้นฐาน รวม อาร์เรย์หลายมิติรวม อาร์เรย์ของวัตถุ รวม การเรียงลำดับหนึ่งอาร์เรย์ขึ้นอยู่กับอีกอาร์เรย์หนึ่ง

2. เรียงลำดับด้วย SPL

3. จัดเรียงที่มั่นคง

สำหรับคำตอบที่ใช้งานได้จริงโดยใช้ฟังก์ชั่นที่มีอยู่ของ PHP ดูที่ 1. สำหรับคำตอบโดยละเอียดเกี่ยวกับการเรียงลำดับอัลกอริธึม (ฟังก์ชั่นของ PHP ที่ใช้และสิ่งที่คุณอาจต้องการสำหรับกรณีที่ซับซ้อนจริงๆ

พื้นฐานอาร์เรย์หนึ่งมิติ

$array = array(3, 5, 2, 8);

ฟังก์ชั่นการจัดเรียงที่ใช้งานได้:

• sort
• rsort
• asort
• arsort
• natsort
• natcasesort
• ksort
• krsort

ความแตกต่างระหว่างผู้ที่เป็นเพียงการไม่ว่าจะเป็นสมาคมที่สำคัญค่าจะถูกเก็บไว้ (ที่ " a" ฟังก์ชั่น) ไม่ว่าจะเรียงลำดับจากน้อยไปสูงหรือย้อนกลับ ( " r') ไม่ว่าจะเรียงลำดับค่าหรือปุ่ม (' k") และวิธีการเปรียบเทียบค่า (" nat" กับปกติ) ดูhttp://php.net/manual/en/array.sorting.phpสำหรับภาพรวมและลิงก์ไปยังรายละเอียดเพิ่มเติม

อาร์เรย์หลายมิติรวมถึงอาร์เรย์ของวัตถุ

$array = array(
    array('foo' => 'bar', 'baz' => 42),
    array('foo' => ...,   'baz' => ...),
    ...
);

หากคุณต้องการเรียงลำดับ$arrayโดยปุ่ม 'foo' ของแต่ละรายการคุณต้องมีฟังก์ชั่นการเปรียบเทียบที่กำหนดเอง sortฟังก์ชั่นด้านบนและที่เกี่ยวข้องทำงานบนค่าง่าย ๆ ที่พวกเขารู้วิธีเปรียบเทียบและเรียงลำดับ PHP ไม่เพียง "รู้" ว่าจะทำอย่างไรกับค่าที่ซับซ้อนเช่นarray('foo' => 'bar', 'baz' => 42)แม้ว่า; ดังนั้นคุณต้องบอก

ต้องการทำเช่นนั้นคุณจะต้องสร้างฟังก์ชั่นการเปรียบเทียบ ฟังก์ชันนั้นใช้สององค์ประกอบและจะต้องส่งคืน0หากองค์ประกอบเหล่านี้ถือว่าเท่ากันค่าที่ต่ำกว่า0ถ้าค่าแรกต่ำกว่าและค่าสูงกว่า0ถ้าค่าแรกสูงกว่า นั่นคือทั้งหมดที่ต้องการ:

function cmp(array $a, array $b) {
    if ($a['foo'] < $b['foo']) {
        return -1;
    } else if ($a['foo'] > $b['foo']) {
        return 1;
    } else {
        return 0;
    }
}

บ่อยครั้งที่คุณจะต้องการใช้ฟังก์ชั่นที่ไม่ระบุชื่อเป็นโทรกลับ หากคุณต้องการที่จะใช้วิธีการหรือวิธีการคงดูที่วิธีการอื่น ๆ ของการระบุการเรียกกลับใน PHP

จากนั้นคุณใช้หนึ่งในฟังก์ชันเหล่านี้:

• usort
• uasort
• uksort

อีกครั้งพวกเขาต่างกันเพียงแค่ว่าพวกเขารักษาความสัมพันธ์ของคีย์ - ค่าและเรียงตามค่าหรือคีย์ อ่านเอกสารประกอบสำหรับรายละเอียด

ตัวอย่างการใช้งาน:

usort($array, 'cmp');

usortจะใช้สองรายการจากอาร์เรย์และเรียกcmpใช้ฟังก์ชันของคุณกับพวกเขา ดังนั้นcmp()จะเรียกว่ามี$aฐานะarray('foo' => 'bar', 'baz' => 42)และเป็นอีก$b array('foo' => ..., 'baz' => ...)จากนั้นฟังก์ชันจะกลับไปusortที่ค่าใดที่มีขนาดใหญ่กว่าหรือว่ามีค่าเท่ากันหรือไม่ usortทำซ้ำกระบวนการนี้ผ่านค่าที่แตกต่างกันสำหรับ$aและ$bจนกว่าจะมีการเรียงลำดับอาร์เรย์ cmpฟังก์ชั่นจะถูกเรียกว่าหลายครั้งอย่างน้อยหลายครั้งตามที่มีค่าใน$arrayกับชุดที่แตกต่างของค่าสำหรับ$aและ$bทุกครั้ง

ในการทำความคุ้นเคยกับแนวคิดนี้ให้ลอง:

function cmp($a, $b) {
    echo 'cmp called with $a:', PHP_EOL;
    var_dump($a);
    echo 'and $b:', PHP_EOL;
    var_dump($b);
}

สิ่งที่คุณทำคือกำหนดวิธีการที่กำหนดเองเพื่อเปรียบเทียบสองรายการนั่นคือทั้งหมดที่คุณต้องการ สามารถใช้ได้กับค่าทุกประเภท

โดยวิธีการนี้จะทำงานกับค่าใด ๆ ค่าไม่จำเป็นต้องมีอาร์เรย์ที่ซับซ้อน หากคุณมีการเปรียบเทียบแบบกำหนดเองที่คุณต้องการคุณสามารถทำได้ด้วยการเรียงลำดับตัวเลขอย่างง่ายเช่นกัน

sort เรียงลำดับตามการอ้างอิงและไม่ส่งคืนสิ่งที่มีประโยชน์!

โปรดทราบว่าอาร์เรย์เรียงลำดับอยู่ในสถานที่คุณไม่จำเป็นต้องกำหนดค่าส่งคืนให้กับสิ่งใด $array = sort($array)จะแทนที่อาร์เรย์ด้วยtrueไม่ใช่ด้วยอาร์เรย์ที่เรียงลำดับ เพิ่งได้sort($array);ผล

การเปรียบเทียบตัวเลขที่กำหนดเอง

หากคุณต้องการเรียงลำดับโดยใช้bazคีย์ซึ่งเป็นตัวเลขสิ่งที่คุณต้องทำคือ:

function cmp(array $a, array $b) {
    return $a['baz'] - $b['baz'];
}

ขอขอบคุณที่อำนาจของ MATHผลตอบแทนที่คุ้มค่านี้ <0, 0 หรือ> 0 ขึ้นอยู่กับว่าเป็นราคาที่ต่ำกว่าหรือเท่ากับขนาดใหญ่กว่า$a$b

โปรดทราบว่าสิ่งนี้จะไม่ทำงานได้ดีกับfloatค่าเนื่องจากจะถูกลดลงintและสูญเสียความแม่นยำ ใช้อย่างชัดเจน-1, 0และ1ค่าตอบแทนแทน

วัตถุ

หากคุณมีอาร์เรย์ของวัตถุมันจะทำงานในลักษณะเดียวกัน:

function cmp($a, $b) {
    return $a->baz - $b->baz;
}

ฟังก์ชั่น

คุณสามารถทำอะไรก็ได้ที่คุณต้องการในฟังก์ชั่นการเปรียบเทียบรวมถึงฟังก์ชั่นการโทร:

function cmp(array $a, array $b) {
    return someFunction($a['baz']) - someFunction($b['baz']);
}

เงื่อนไข

ทางลัดสำหรับเวอร์ชันเปรียบเทียบสตริงแรก:

function cmp(array $a, array $b) {
    return strcmp($a['foo'], $b['foo']);
}

strcmpไม่ว่าสิ่งที่คาดหวังของcmpที่นี่ก็จะส่งกลับ-1, หรือ01

ผู้ประกอบการยานอวกาศ

PHP 7 เปิดตัวโอเปอเรเตอร์ยานอวกาศซึ่งรวมและทำให้ง่ายขึ้นเท่ากัน / เล็กลง / ใหญ่กว่าการเปรียบเทียบข้ามประเภท:

function cmp(array $a, array $b) {
    return $a['foo'] <=> $b['foo'];
}

จัดเรียงตามหลายฟิลด์

หากคุณต้องการเรียงลำดับตามหลักfooแต่ถ้าfooเท่ากับสำหรับสององค์ประกอบเรียงตามbaz:

function cmp(array $a, array $b) {
    if (($cmp = strcmp($a['foo'], $b['foo'])) !== 0) {
        return $cmp;
    } else {
        return $a['baz'] - $b['baz'];
    }
}

สำหรับผู้ที่คุ้นเคยนี้จะเทียบเท่ากับการสอบถาม SQL ORDER BY foo, bazกับ
ยังเห็นรุ่นนี้ชวเลขอย่างมากและวิธีการสร้างเช่นฟังก์ชั่นการเปรียบเทียบแบบไดนามิกสำหรับจำนวนข้อของคีย์

จัดเรียงเป็นแบบคงที่ด้วยตนเอง

หากคุณต้องการเรียงลำดับองค์ประกอบลงใน "ลำดับด้วยตนเอง" เช่น"foo", "bar", "baz" :

function cmp(array $a, array $b) {
    static $order = array('foo', 'bar', 'baz');
    return array_search($a['foo'], $order) - array_search($b['foo'], $order);
}

สำหรับข้างต้นหากคุณใช้ PHP 5.3 หรือสูงกว่า (และคุณควรจริง ๆ ) ให้ใช้ฟังก์ชั่นที่ไม่ระบุชื่อสำหรับรหัสที่สั้นกว่าและเพื่อหลีกเลี่ยงการมีฟังก์ชั่นสากลอื่น ๆ

usort($array, function (array $a, array $b) { return $a['baz'] - $b['baz']; });

นั่นเป็นวิธีที่ง่ายในการเรียงลำดับอาเรย์หลายมิติที่ซับซ้อนได้ คิดอีกครั้งในแง่ของการสอน PHP ว่าจะบอกว่าอะไรในสองรายการที่ "ยิ่งใหญ่กว่า" ; ให้ PHP ทำการจัดเรียงจริง

นอกจากนี้สำหรับทั้งหมดข้างต้นเพื่อสลับระหว่างลำดับจากน้อยไปมากและจากมากไปน้อยเพียงสลับ$aและ$bอาร์กิวเมนต์ไปมา เช่น:

return $a['baz'] - $b['baz']; // ascending
return $b['baz'] - $a['baz']; // descending

การเรียงลำดับหนึ่งอาร์เรย์ขึ้นอยู่กับอีกอาร์เรย์หนึ่ง

แล้วมันก็มีสิ่งแปลกประหลาดarray_multisortซึ่งทำให้คุณสามารถเรียงลำดับหนึ่งอาเรย์จากอีกอันหนึ่งได้:

$array1 = array( 4,   6,   1);
$array2 = array('a', 'b', 'c');

ผลลัพธ์ที่คาดหวังที่นี่จะเป็น:

$array2 = array('c', 'a', 'b');  // the sorted order of $array1

ใช้array_multisortเพื่อไปที่นั่น:

array_multisort($array1, $array2);

ในฐานะของ PHP 5.5.0 คุณสามารถใช้array_columnเพื่อแยกคอลัมน์จากหลายมิติอาเรย์และเรียงลำดับอาเรย์ในคอลัมน์นั้น:

array_multisort(array_column($array, 'foo'), SORT_DESC, $array);

ในฐานะของ PHP 7.0.0 คุณยังสามารถแยกคุณสมบัติจากอาร์เรย์ของวัตถุ

_{หากคุณมีกรณีทั่วไปมากขึ้นอย่าลังเลที่จะแก้ไขคำตอบนี้}

วิธีการขั้นพื้นฐานส่วนใหญ่ได้รับการคุ้มครองโดยการหลอกลวงฉันจะพยายามดูประเภทอื่น ๆ

เรียงลำดับด้วย SPL

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));

เอาท์พุต

c
b
a

SplMaxHeap

คลาส SplMaxHeap จัดเตรียมฟังก์ชันการทำงานหลักของฮีปให้สูงสุดอยู่ด้านบน

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

SplMinHeap

คลาส SplMinHeap จัดเตรียมฟังก์ชันการทำงานหลักของฮีปให้อยู่ในระดับต่ำสุด

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

ประเภทอื่น ๆ เรียง

เรียงลำดับฟอง

จากบทความ Wikipedia เกี่ยวกับ Bubble Sort:

Bubble sort บางครั้งเรียกว่า sinking sort ไม่ถูกต้องเป็นอัลกอริธึมการเรียงลำดับแบบง่าย ๆ ที่ทำงานโดยการก้าวผ่านรายการที่จะเรียงลำดับซ้ำ ๆ กันเปรียบเทียบแต่ละคู่ของรายการที่อยู่ติดกันและสลับพวกมันหากเรียงผิด การส่งผ่านรายการซ้ำจนกว่าจะไม่จำเป็นต้องมีการสลับซึ่งบ่งชี้ว่ารายการถูกเรียงลำดับ อัลกอริทึมได้รับชื่อจากวิธีที่ "ฟอง" องค์ประกอบเล็กลงไปด้านบนของรายการ เนื่องจากมันใช้การเปรียบเทียบเพื่อใช้งานกับองค์ประกอบเท่านั้นจึงเป็นการเปรียบเทียบแบบเรียงลำดับ แม้ว่าอัลกอริทึมนั้นง่าย แต่อัลกอริธึมการเรียงลำดับส่วนใหญ่จะมีประสิทธิภาพมากกว่าสำหรับรายการขนาดใหญ่

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;
}

เรียงลำดับการคัดเลือก

จากบทความ Wikipedia เกี่ยวกับการเลือกการจัดเรียง:

ในวิทยาการคอมพิวเตอร์การเรียงลำดับการเลือกเป็นอัลกอริทึมการเรียงลำดับโดยเฉพาะการเรียงลำดับการเปรียบเทียบในสถานที่ มันมีความซับซ้อนของเวลา O (n2) ทำให้ไม่มีประสิทธิภาพในรายการขนาดใหญ่และโดยทั่วไปจะทำงานได้แย่กว่าการเรียงลำดับการแทรกที่คล้ายกัน การเรียงลำดับการเลือกนั้นถูกบันทึกไว้เพื่อความเรียบง่ายและมีข้อได้เปรียบด้านประสิทธิภาพเหนืออัลกอริทึมที่ซับซ้อนมากขึ้นในบางสถานการณ์

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;
}

เรียงลำดับการแทรก

จากบทความ Wikipedia เกี่ยวกับการจัดเรียงการแทรก:

การเรียงลำดับการแทรกเป็นอัลกอริทึมการเรียงลำดับแบบง่าย ๆ ที่สร้างอาร์เรย์เรียงลำดับสุดท้าย (หรือรายการ) ทีละรายการ มันมีประสิทธิภาพน้อยกว่าในรายการขนาดใหญ่กว่าอัลกอริธึมขั้นสูงเช่น quicksort, heapsort หรือ merge sort อย่างไรก็ตามการเรียงลำดับการแทรกมีข้อดีหลายประการ:

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 บน Shellsort:

Shellsort หรือที่เรียกว่าการเรียงลำดับของเชลล์หรือวิธีการของเชลล์เป็นการเรียงลำดับแบบแทนที่ มันทำให้การเรียงลำดับการแลกเปลี่ยนทั่วไปเช่นการแทรกหรือการเรียงลำดับฟองโดยเริ่มต้นการเปรียบเทียบและการแลกเปลี่ยนขององค์ประกอบที่มีองค์ประกอบที่อยู่ห่างไกลก่อนที่จะจบด้วยองค์ประกอบที่อยู่ใกล้เคียง

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;
}

เรียงลำดับหวี

จากบทความ Wikipedia ในการจัดเรียง Comb:

Comb sort เป็นอัลกอริธึมการเรียงลำดับที่ค่อนข้างง่ายซึ่ง แต่เดิมออกแบบโดย Wlodzimierz Dobosiewicz ในปี 1980 ต่อมามันถูกค้นพบอีกครั้งโดย Stephen Lacey และ Richard Box ในปี 1991 Comb sort ปรับปรุงการเรียงลำดับฟอง

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;
}

เรียงลำดับการผสาน

จากบทความ Wikipedia ใน Merge sort:

ในวิทยาการคอมพิวเตอร์การเรียงลำดับการผสาน (เช่นการสะกดการรวมกันแบบปกติ) เป็นขั้นตอนวิธีการเรียงลำดับโดยใช้การเปรียบเทียบ O (n log n) การใช้งานส่วนใหญ่สร้างการเรียงแบบเสถียรซึ่งหมายความว่าการใช้งานจะเก็บรักษาลำดับการป้อนข้อมูลขององค์ประกอบที่เท่ากันในเอาต์พุตที่เรียงลำดับ

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

จากบทความ Wikipedia บน Quicksort:

Quicksort หรือการจัดเรียงพาร์ติชั่นการแลกเปลี่ยนเป็นอัลกอริทึมการเรียงลำดับที่พัฒนาโดย Tony Hoare โดยเฉลี่ยแล้วทำการเปรียบเทียบ O (n log n) กับการเรียงลำดับ n รายการ ในกรณีที่เลวร้ายที่สุดมันทำการเปรียบเทียบ O (n2) แม้ว่าพฤติกรรมนี้จะหายาก

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));
}

เรียงลำดับการเรียงสับเปลี่ยน

จากบทความ Wikipedia เกี่ยวกับการเรียงลำดับการเรียงลำดับ:

เรียงลำดับการเรียงสับเปลี่ยนซึ่งดำเนินการโดยการสร้างการเรียงสับเปลี่ยนที่เป็นไปได้ของอาร์เรย์ / รายการจนกระทั่งค้นพบรายการเรียงลำดับ

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;
}

เรียง Radix

จากบทความ Wikipedia บน Radix sort:

ในวิทยาศาสตร์คอมพิวเตอร์ Radix sort เป็นอัลกอริธึมการเรียงลำดับเลขจำนวนเต็มแบบไม่เปรียบเทียบที่เรียงลำดับข้อมูลด้วยคีย์จำนวนเต็มโดยการจัดกลุ่มคีย์ตามตัวเลขแต่ละตัวซึ่งใช้ตำแหน่งและค่าที่สำคัญเหมือนกัน

// 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;
}

จัดเรียงที่มั่นคง

สมมติว่าคุณมีอาร์เรย์ดังนี้

['Kale', 'Kaleidoscope', 'Aardvark', 'Apple', 'Leicester', 'Lovely']

และตอนนี้คุณต้องการเรียงตามตัวอักษรแรกเท่านั้น:

usort($array, function($a, $b) {
    return strcmp($a[0], $b[0]);
});

ผลลัพธ์ที่ได้คือ:

['Apple', 'Aardvark', 'Kale', 'Kaleidoscope', 'Lovely', 'Leicester']

การเรียงลำดับไม่เสถียร!

ผู้สังเกตการณ์ที่กระตือรือร้นอาจสังเกตเห็นว่าอัลกอริธึมการเรียงลำดับอาร์เรย์ (QuickSort) ไม่ได้สร้างผลลัพธ์ที่มีเสถียรภาพและคำสั่งดั้งเดิมระหว่างคำของตัวอักษรตัวแรกตัวเดียวกันไม่ได้ถูกเก็บรักษาไว้ กรณีนี้ไม่สำคัญและเราควรเปรียบเทียบสตริงทั้งหมด แต่สมมติว่ากรณีการใช้งานของคุณมีความซับซ้อนมากขึ้นเช่นการเรียงลำดับสองรายการต่อเนื่องกันในสาขาต่าง ๆ ที่ไม่ควรยกเลิกงานของกันและกัน

การเปลี่ยนแปลงของ Schwartzian

การแปลงชวาร์ตเซียนหรือที่เรียกกันว่าสำนวนตกแต่ง - เรียงซ้อน - undecorate ผลกระทบการจัดเรียงที่มั่นคงด้วยอัลกอริทึมการเรียงลำดับไม่แน่นอนโดยเนื้อแท้

ก่อนอื่นให้คุณตกแต่งองค์ประกอบของอาร์เรย์แต่ละชุดด้วยอาร์เรย์อื่นที่ประกอบด้วยคีย์หลัก (ค่า) และคีย์รอง (ดัชนีหรือตำแหน่ง):

array_walk($array, function(&$element, $index) {
    $element = array($element, $index); // decorate
});

สิ่งนี้จะแปลงอาเรย์เป็น:

[
    ['Kale', 0], ['Kaleidoscope', 1], 
    ['Aardvark', 2], ['Apple', 3], 
    ['Leicester', 4], ['Lovely', 5]
]

ตอนนี้เราปรับขั้นตอนการเปรียบเทียบ เราเปรียบเทียบตัวอักษรตัวแรกอีกครั้ง แต่หากเหมือนกันจะมีการใช้รหัสรองเพื่อรักษาลำดับเดิม:

usort($array, function($a, $b) {
    // $a[0] and $b[0] contain the primary sort key
    // $a[1] and $b[1] contain the secondary sort key
    $tmp = strcmp($a[0][0], $b[0][0]);

    if ($tmp != 0) {
        return $tmp; // use primary key comparison results
    }

    return $a[1] - $b[1]; // use secondary key
});

หลังจากนั้นเรายกเลิกการตกแต่ง:

array_walk($array, function(&$element) {
    $element = $element[0];
});

ผลสุดท้าย:

['Aardvark', 'Apple', 'Kale', 'Kaleidoscope', 'Leicester', 'Lovely']

สิ่งที่เกี่ยวกับการใช้ซ้ำ?

คุณต้องเขียนฟังก์ชันการเปรียบเทียบของคุณใหม่เพื่อทำงานกับองค์ประกอบอาเรย์ที่ถูกเปลี่ยนรูป คุณอาจไม่ต้องการแก้ไขฟังก์ชั่นการเปรียบเทียบที่ละเอียดอ่อนของคุณดังนั้นนี่คือเสื้อคลุมสำหรับฟังก์ชั่นการเปรียบเทียบ:

function stablecmp($fn)
{
    return function($a, $b) use ($fn) {
        if (($tmp = call_user_func($fn, $a[0], $b[0])) != 0) {
            return $tmp;
        } else {
            return $a[1] - $b[1];
        }
    };
}

ลองเขียนขั้นตอนการจัดเรียงโดยใช้ฟังก์ชั่นนี้:

usort($array, stablecmp(function($a, $b) {
    return strcmp($a[0], $b[0]);
}));

Voila! รหัสการเปรียบเทียบที่แท้จริงของคุณกลับมาแล้ว

ตั้งแต่ PHP 5.3 ที่มีการปิดเป็นไปได้ที่จะใช้การปิดเพื่อกำหนดลำดับการเรียงของคุณ

ตัวอย่างเช่นสมมติว่า $ array เป็นอาร์เรย์ของวัตถุที่มีคุณสมบัติเดือน

 $orderArray = array("Jan","Feb","Mar","Apr","May","June","July","Aug","Sept","Oct","Nov","Dec");

 usort($array, function($a, $b) use ($orderArray){
       return array_search($a->month, $orderArray) - array_search($b->month, $orderArray);
 }); 

LINQ

ใน. NET, LINQ มักจะใช้สำหรับการเรียงลำดับซึ่งมีไวยากรณ์ที่ดีกว่าฟังก์ชั่นการเปรียบเทียบโดยเฉพาะอย่างยิ่งเมื่อวัตถุจะต้องมีการเรียงลำดับตามหลายสาขา มี LINQ to PHP หลายพอร์ตรวมถึงYaLinqo library * ด้วยมันสามารถจัดเรียงอาร์เรย์ด้วยบรรทัดเดียวโดยไม่ต้องเขียนฟังก์ชั่นการเปรียบเทียบที่ซับซ้อน

$sortedByName         = from($objects)->orderBy('$v->name');
$sortedByCount        = from($objects)->orderBy('$v->count');
$sortedByCountAndName = from($objects)->orderBy('$v->count')->thenBy('$v->name');

การเปรียบเทียบสามารถปรับแต่งเพิ่มเติมได้โดยผ่านการติดต่อกลับเป็นอาร์กิวเมนต์ที่สองตัวอย่างเช่น

$sortedByFilenameNat  = from($objects)->orderBy('$v->filename', 'strnatcmp');

นี่'$v->count'คือการจดชวเลขสำหรับfunction ($v) { return $v->count; }(สามารถใช้) กลุ่มเมธอดเหล่านี้ส่งคืนตัววนซ้ำตัววนซ้ำสามารถแปลงเป็นอาร์เรย์ได้โดยเพิ่ม->toArray()ท้ายถ้าจำเป็น

ภายในorderByวิธีการและเกี่ยวข้องกับการเรียกใช้ฟังก์ชันอาร์เรย์เรียงลำดับที่เหมาะสม ( uasort, krsort, multisort, usortฯลฯ )

LINQ มีวิธีการอื่น ๆ อีกมากมายที่ได้รับแรงบันดาลใจจาก SQL: การกรอง, การจัดกลุ่ม, การรวม, การรวมเป็นต้นมันเหมาะที่สุดสำหรับกรณีที่จำเป็นต้องทำการแปลงที่ซับซ้อนในอาร์เรย์และวัตถุโดยไม่ต้องพึ่งพาฐานข้อมูล

_{* พัฒนาโดยฉันดู readme สำหรับรายละเอียดเพิ่มเติมและเปรียบเทียบกับพอร์ต LINQ อื่น ๆ}

จัดเรียงหลายมิติตามค่าคีย์

เรียงลำดับตามธรรมชาติของอาเรย์หลายมิติโดยใช้ค่าคีย์และยังคงลำดับเดิม (ห้ามสลับคีย์หลัก):

function multisortByKeyValue( $k, $arr ) {
    $ids   = array();
    $index = 1;

    foreach ( $arr as $key => $row ) {
        $ids[ $key ] = intval( $row[ $k ] ) . '-' . $index . '-' . $key;
        $index ++;
    }

    natsort( $ids );

    $arr = array_merge( $ids, $arr );

    return $arr;
}

กรณีทดสอบ:

$arr = array(
    'id1' => array(
        'label'    => 'ID 1',
        'priority' => 30,
    ),
    'id2' => array(
        'label'    => 'ID 2',
        'priority' => 70,
    ),
    'id3' => array(
        'label'    => 'ID 3',
        'priority' => 20,
    ),
    'id4' => array(
        'label'    => 'ID 4',
        'priority' => 30,
    ),
);

$sorted = multisortByKeyValue( 'priority', $arr );

// $sorted equals to:
/*
array (
  'id3' => array (
    'label' => 'ID 3',
    'priority' => 20,
  ),
  'id1' => array (
    'label' => 'ID 1',
    'priority' => 30,
  ),
  'id4' => array (
    'label' => 'ID 4',
    'priority' => 30,
  ),
  'id2' => array (
    'label' => 'ID 2',
    'priority' => 70,
  ),
)
*/

มันสะดวกมากในการจัดเรียงอาร์เรย์ด้วยฟังก์ชันที่เรียงลำดับจากNspl :

การเรียงลำดับพื้นฐาน

// Sort array
$sorted = sorted([3, 1, 2]);

// Sort array in descending order
$sortedDesc = sorted([3, 1, 2], true);

จัดเรียงตามผลการทำงาน

// Sort array by the result of a given function (order words by length)
$sortedByLength = sorted(['bc', 'a', 'abc'], 'strlen');
$sortedByLengthDesc = sorted(['bc', 'a', 'abc'], true, 'strlen');

// Sort array by the result of user-defined function (order words by the 1st character)
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], function($v) { return $v[0]; }); 

// Which is the same as
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], itemGetter(0));
$sortedByTheFirstCharacterDesc = sorted(['bc', 'a', 'abc'], true, itemGetter(0));

// itemGetter(0) returns a function which takes an argument with access by index/key
// and returns the value at index 0

การเรียงลำดับอาร์เรย์หลายมิติ

// Sort multidimensional array (sort list of users by their names)
$users = [
    array('name' => 'Robert', 'age' => 20),
    array('name' => 'Alex', 'age' => 30),
    array('name' => 'Jack', 'age' => 25),
];
$sortedByName = sorted($users, itemGetter('name'));
$sortedByNameDesc = sorted($users, true, itemGetter('name'));

// itemGetter('name') returns a function which takes an argument with access by index/key
// and returns the value of the 'name' key

การเรียงลำดับอาร์เรย์ของวัตถุ

// Lets assume we have class User(name, age) with properties name and age
// and public methods getName() and getAge()
$users = [
    new User('Robert', 20),
    new User('Alex', 30),
    new User('Jack', 25),
];

// Sort list of objects by property value (sort list of users by their name)
$sortedByName = sorted($users, propertyGetter('name'));
$sortedByNameDesc = sorted($users, true, propertyGetter('name'));

// propertyGetter('name') returns a function which takes an object
// and returns the value of its 'name' property

// Sort list of objects by method result (sort list of users by their age)
$sortedByAge = sorted($users, methodCaller('getAge'));
$sortedByAgeDesc = sorted($users, true, methodCaller('getAge'));

// methodCaller('getAge') returns a function which takes an object
// and returns the result of its getAge() method

จัดเรียงด้วยฟังก์ชันเปรียบเทียบ

// Sort with a comparison function (order words lexicographically with strcmp)
$sortedLexicographically = sorted(['bc', 'a', 'abc'], false, null, 'strcmp');

// Sort with user-defined comparison function (order words by the 1st character)
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], false, null, function($v1, $v2) {
    return chr($v1[0]) - chr($v2[0]);
});

คุณสามารถดูตัวอย่างเหล่านี้ที่นี่

หากคุณต้องการสั่งซื้อด้วยค่าคีย์คุณสามารถทำได้หนึ่งบรรทัดหรูหราและชัดเจน โดยจะเรียงตามราคาจากน้อยไปมาก ใช้ array_multisort และ array_column

   Array([0] => Array ( [name] => eggs [price] => 1 ) [1] => Array ( [name] => coffee [price] => 9.99 ) [2] => Array ( [name] => rice [price] => 4.04 ) )

   array_multisort (array_column($array, 'price'), SORT_ASC, $array);

ผลิต

     Array ( [0] => Array ( [name] => eggs [price] => 1 ) [1] => Array ( [name] => rice [price] => 4.04 ) [2] => Array ( [name] => coffee [price] => 9.99 ) )

หน้านี้มีความครอบคลุมมาก แต่ฉันต้องการเพิ่มอีกเล็กน้อยเกี่ยวกับยูทิลิตี้ที่ยอดเยี่ยมของผู้ประกอบการยานอวกาศ (ตัวดำเนินการเปรียบเทียบสามทาง) - เด็กที่สวยงามของ PHP7 +

การใช้ตัวดำเนินการยานอวกาศเพื่อใช้เงื่อนไขการเรียงหลายแบบ

สิ่งนี้ทำให้เกิดความก้าวหน้าอย่างมากในการลดการขยายโค้ดและปรับปรุงความสามารถในการอ่าน

เมื่อเขียนเรียงลำดับที่กำหนดเองของคุณ ( usort()/uasort()uksort()ฟังก์ชั่นการ / ) ของคุณเพื่อประมวลผลหลายเงื่อนไขคุณจะต้องเขียนอาร์เรย์แบบสมดุลย์ที่ด้านใดด้านหนึ่งของตัวดำเนินการและส่งคืนผลลัพธ์ ไม่มีบล็อกเงื่อนไขซ้อนกันหรือส่งคืนหลายรายการ

องค์ประกอบจากทั้งสองด้านของผู้ปฏิบัติงานจะถูกเคลื่อนที่จากซ้ายไปขวาทีละครั้งและส่งคืนการประเมินผลทันทีที่พบการไม่ผูกหรือเมื่อมีการเปรียบเทียบองค์ประกอบทั้งหมด

ข้อมูลตัวอย่างสำหรับการสาธิตของฉัน:

$multidimArray = [
    'a' => [
        'boolean' => true,
        'natString' => 'text10',
        'object' => (object)['prop' => 2],
        'float' => -.5,
        'mixed' => []
    ],
    'b' => [
        'boolean' => true,
        'natString' => 'text12',
        'object' => (object)['prop' => 4],
        'float' => 0,
        'mixed' => null
    ],
    'c' => [
        'boolean' => false,
        'natString' => 'text100',
        'object' => (object)['prop' => 9],
        'float' => -.5,
        'mixed' => false
    ],
    'd' => [
        'boolean' => true,
        'natString' => 'text1',
        'object' => (object)['prop' => 9],
        'float' => -5,
        'mixed' => "\0"
    ],
    'e' => [
        'boolean' => false,
        'natString' => 'text2',
        'object' => (object)['prop' => 2],
        'float' => .5,
        'mixed' => ''
    ]
];

การสาธิต (เพื่อหลีกเลี่ยงการบวมหน้า Stackoverflow โปรดดูลิงค์สาธิตสำหรับผลลัพธ์):

• ตรรกะการเรียงลำดับ:

  1. บูลีน DESC (false = 0, true = 1 ดังนั้น trues ก่อน falses)

  2. ลอย ASC

     uasort($multidimArray, function($a, $b) {
         return [$b['boolean'], $a['float']] <=> [$a['boolean'], $b['float']];
     });

• ตรรกะการเรียงลำดับ:

  1. ผสม ASC
  2. วัตถุ ASC

  3. บูลีน ASC

     uasort($multidimArray, function($a, $b) {
         return [$a['mixed'], $a['object']->prop, $a['boolean']] <=> [$b['mixed'], $b['object']->prop, $b['boolean']];
     });

• ตรรกะการเรียงลำดับ:

  1. จำนวนคุณสมบัติของวัตถุ ASC
  2. การทำซ้ำของ DESC แบบผสม
  3. natString ความยาว ASC

  4. natString ASC

     uasort($multidimArray, function($a, $b) {
         return [count(get_object_vars($a['object'])), is_iterable($a['mixed']), strlen($a['natString']), $a['natString']]
                <=>
                [count(get_object_vars($b['object'])), is_iterable($b['mixed']), strlen($b['natString']), $b['natString']];
     });

ไวยากรณ์นี้ช่วยให้คุณสามารถจัดเรียงค่าผลลัพธ์การทำงานข้อมูลที่ซ้อนกันลึกและทิศทางการเรียงลำดับในรูปแบบที่สวยงาม นี่เป็นสิ่งที่ควรค่าแก่การใส่ลงในชุดเครื่องมือ php ของคุณ ... สำหรับกรณีที่คุณกำลังประมวลผลข้อมูลที่ไม่ใช่ฐานข้อมูลเพราะแน่นอนว่า SQL จะเป็นเทคนิคที่เหมาะสมกว่า

ตามดุลยพินิจของคุณเองจาก PHP7.4 คุณสามารถใช้ไวยากรณ์ลูกศรกับฟังก์ชั่นที่ไม่ระบุชื่อเหล่านี้ สคริปต์เดียวกันกับไวยากรณ์ลูกศร

ถ้าใครบางคนต้องการวิธีที่ง่ายกว่าในการจัดการอาร์เรย์ให้ใช้แพ็คเกจ Laravel Collection ซึ่งมีฟังก์ชั่น sortBy ที่ใช้งานซึ่งช่วยให้คุณเรียงลำดับโดยใช้ปุ่มเพียงง่ายๆ

$collection->sortBy('forename')->sortBy('surname');

เช่นในการเรียงลำดับแรกโดย a จากนั้น b จากนั้น c ประโยคที่ถูกต้องจะเป็น

sortBy('c')->sortBy('b')->sortBy('a')

https://packagist.org/packages/tightenco/collect

มีหลายวิธีในการเรียงลำดับ array ฉันจะพูดถึงวิธีการบางอย่างสำหรับการทำ task.fist ของทั้งหมดฉันจะให้อาร์เรย์จำนวนเต็มซึ่งเรียกว่า '$ numbers'

$number = array(8,9,3,4,0,1,2);

นี่เป็นวิธีปกติในการสร้างอาร์เรย์ สมมติว่าฉันต้องการเรียงลำดับอาร์เรย์นั้นจากมากไปหาน้อยสำหรับวิธีนั้นสามารถใช้ 'sort ()' ได้

<?php

    $number = array(8,9,3,4,0,1,2);
    sort($number);

   foreach ($number as $value) {
       echo $value."  ";
   }
?>

ตอนนี้ให้พิจารณาผลลัพธ์ของสิ่งนั้น

คุณสามารถดูอาเรย์ตัวเลขที่พิมพ์ได้ ถ้าคุณต้องการเรียงลำดับตัวเลขนั้นเรียงลำดับจากมากไปน้อยวิธีการ 'rsort ()' สามารถใช้สำหรับงานนั้นได้

<?php

     $number = array(8,9,3,4,0,1,2);
     rsort($number);

     foreach ($number as $value) {
        echo $value."  ";
     }
?>

พิจารณาผลลัพธ์

ตอนนี้อาเรย์จะเรียงตามลำดับจากมากไปน้อยลองพิจารณาอาเรย์แบบเชื่อมโยงฉันจะให้อาเรย์แบบเชื่อมโยง (อาเรย์แบบสัมพันธ์หมายความว่าอาเรย์ซึ่งแต่ละดัชนีมีค่าคีย์ที่ไม่ซ้ำกัน) เช่นนี้

$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);

ดังนั้นตอนนี้ฉันต้องการเรียงลำดับอาร์เรย์นี้ตามลำดับจากน้อยไปมากตามค่าของพวกเขา 'asort ()' สามารถใช้วิธีการนั้นได้

<?php

   $number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
   asort($number);

   foreach ($number as $value) {
      echo $value."  ";
    }
?>

หากเรียงลำดับจากมากไปน้อยตามค่าของพวกเขาสามารถใช้วิธีการ 'arsort ()' ได้ สมมติว่าคุณต้องการเรียงลำดับอาร์เรย์นั้นตามค่าคีย์ ในการนี้วิธีการ 'ksort ()' สามารถใช้งานได้

<?php

     $number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
     ksort($number);

     foreach ($number as $value) {
         echo $value."  ";
     }
?>

พิจารณาเอาท์พุท

ตอนนี้อาร์เรย์จะถูกจัดเรียงตามค่าคีย์ของพวกเขาหากคุณต้องการเรียงลำดับตามลำดับจากมากไปน้อยตามค่าคีย์พวกเขาสามารถใช้วิธี 'krsort ()' ได้

<?php

    $number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
    krsort($number);

    foreach ($number as $value) {
       echo $value."  ";
    }
?>

ตอนนี้อาร์เรย์ที่เชื่อมโยงจะถูกเรียงลำดับจากมากไปน้อยตามค่าคีย์ของพวกเขาดูที่เอาต์พุต

เหล่านี้เป็นวิธีการบางอย่างสำหรับการเรียงลำดับอาร์เรย์ในลำดับขึ้นหรือลงใน php.I หวังว่าคุณจะได้รับความคิดขอขอบคุณ!

วิธีที่ง่ายที่สุดคือใช้ฟังก์ชั่น usort เพื่อจัดเรียงอาร์เรย์โดยไม่ต้องวนซ้ำ: ด้านล่างเป็นตัวอย่าง:

   $array_compare= array("0" =>4,"1"=>2,"2"=>500,"3"=>100);

สิ่งนี้จะเรียงลำดับตามลำดับ:

usort($array_compare, function($a, $b) {
        return ($b['x1'] - $a['x1']) > 0 ? 1 :-1;
    });

สิ่งนี้จะเรียงตามลำดับจากน้อยไปมาก:

usort($array_compare, function($a, $b) {
        return ($b['x1'] - $a['x1']) < 0 ? 1 :-1;
    });