मैं PHP में सरणियों और डेटा को कैसे सॉर्ट कर सकता हूं?


292

यह सवाल PHP में सरणियों को छांटने के बारे में प्रश्नों के संदर्भ के रूप में है। यह सोचना आसान है कि आपका विशेष मामला अद्वितीय है और एक नए प्रश्न के योग्य है, लेकिन अधिकांश वास्तव में इस पृष्ठ के समाधानों में से एक हैं।

यदि आपका प्रश्न इस एक के डुप्लिकेट के रूप में बंद है, तो कृपया अपने प्रश्न को फिर से खोलने के लिए कहें, यदि आप समझा सकते हैं कि यह नीचे के सभी से अलग क्यों है।

मैं PHP में एक सरणी कैसे सॉर्ट करूं?
मैं PHP में एक जटिल सरणी को कैसे सॉर्ट करूं ?
मैं PHP में वस्तुओं की एक सरणी को कैसे सॉर्ट करता हूं?


  1. बुनियादी एक आयामी सरणियों; Incl। बहुआयामी सरणियाँ, झुकाव। वस्तुओं की सरणियाँ; Incl। एक सरणी को दूसरे के आधार पर क्रमबद्ध करना

  2. एसपीएल के साथ छंटनी

  3. स्थिर प्रकार

PHP के मौजूदा फ़ंक्शंस का उपयोग करते हुए व्यावहारिक उत्तर के लिए 1 देखें। छँटाई एल्गोरिदम पर अकादमिक इन-डिटेल उत्तर के लिए (जो PHP के फ़ंक्शंस लागू करते हैं और जिन्हें आपको वास्तव में, वास्तव में जटिल मामलों के लिए आवश्यकता हो सकती है), 2 देखें।


@jterry बिल्कुल, यही कारण है कि मैंने इसे अंततः बंद करने के लिए एक अच्छा संदर्भ प्रश्न किया है। प्रत्येक अद्वितीय हिमपात का जवाब देना व्यक्तिगत रूप से किसी की मदद नहीं करता है। :)
deceze

3
मुझे लगता है कि लोगों को बस php.net पर एक नज़र रखना चाहिए
अलेक्जेंडर जार्डिम

@ ऐलेक्स हा! पूर्ण रूप से। समस्या यह है: कोई भी RTFM नहीं। : D
छल

2
हमारे पास उन उत्तर पहले से ही हैं, मैं आपको सामग्री के डुप्लिकेट (या फिर से लिखने) के बजाय प्रत्येक उत्तर के अंदर सर्वश्रेष्ठ उत्तरों को सूचीबद्ध करने का सुझाव देता हूं। इसके अलावा सरणियों को व्यक्तिगत रूप से देखा जाता है, इसलिए यह कार्य किसी भी मामले में द्वैध के खिलाफ मतदान करने के लिए रहता है।
हकरे

1
@ डिसेज़: अगर कोई आरटीएफएम नहीं है, तो कोई भी आरटीएफक्यूए - मौजूदा क्यू एंड ए :)
हकरे

जवाबों:


164

मूल एक आयामी सरणियाँ

$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प्रत्येक प्रविष्टि की कुंजी 'फू' के आधार पर छांटना चाहते हैं, तो आपको एक कस्टम तुलना फ़ंक्शन की आवश्यकता है । उपरोक्त sortऔर संबंधित कार्य सरल मूल्यों पर काम करते हैं जो उन्हें पता है कि कैसे तुलना और छाँटना है। पीएचपी बस नहीं "पता" करता है एक साथ क्या करना जटिल मूल्य की तरह 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($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'];
}

के लिए धन्यवाद बिजली मठ के इस रिटर्न एक मूल्य <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, 0या 1

स्पेसशिप ऑपरेटर

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
इसके अलावा यह बहुत साफ शॉर्टहैंड संस्करण देखें और इस तरह के तुलनात्मक फ़ंक्शन को गतिशील रूप से कुंजियों की संख्या के लिए कैसे बनाएं

एक मैनुअल, स्थिर क्रम में छंटनी

यदि आप "फू", "बार", "बाज" जैसे " मैनुअल ऑर्डर" में तत्वों को क्रमबद्ध करना चाहते हैं :

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 के रूप में आप ऑब्जेक्ट की एक सरणी से गुण भी निकाल सकते हैं।


यदि आपके पास अधिक सामान्य मामले हैं, तो इस उत्तर को संपादित करने के लिए स्वतंत्र महसूस करें।


सांख्यिक तुलना फ़ंक्शन फ्लोट मानों के लिए काम नहीं करता है; मुझे यकीन है कि आप जानते हैं कि मेरा क्या मतलब है :)
Ja youck

1
स्थैतिक क्रम के लिए, मैं इसके बजाय array_flip()त्वरित गति लुकअप का उपयोग करने के लिए आवेदन करूंगा , जैसे $order[$a['foo']]कि array_search($a['foo'], $order)
जाके २।

थोड़ा बड़ा संपादन हो सकता है: gist.github.com/Rizier123/24a6248758b53245a63e839d8e08a32b लेकिन अगर आपको लगता है कि यह एक सुधार है और मैंने इसे आवश्यक रूप से शामिल किया है तो मैं इसे लागू कर सकता हूं।
रिज़ियर १२

@ Rizier123 मैं निश्चित रूप से प्रयास की सराहना करता हूं, यह एक बहुत अच्छा राइटअप है; लेकिन मैं इसे पसंद करूंगा यदि आप इसे अलग उत्तर के रूप में पोस्ट करते हैं, भले ही यह बहुत समान हो। आपके पुनर्लेखन में बहुत सारे विवरण होते हैं (संदर्भ, बड़ी तालिका आदि द्वारा पास), लेकिन यह विस्तार तुलनात्मक कार्य, आईएमएचओ के कामकाज के मूल विषय के सुचारू परिचय से विचलित करता है। मैं स्पष्ट रूप से मैनुअल को कई बार उद्देश्य से संदर्भित करता हूं, क्योंकि जहां इस तरह के विवरण को देखा जाना चाहिए; यहाँ इसे दोहराने की आवश्यकता नहीं है और मैं जो मूल विचार बताने की कोशिश कर रहा हूँ उससे विचलित होना चाहिए।
deceze

@ डिसेज़ मुख्य चुनौती है, क्योंकि यह एक संदर्भ क्यू एंड ए है, यह जानकारी को यथासंभव कॉम्पैक्ट और पठनीय के रूप में प्रदर्शित करना है और उपयोगकर्ताओं के लिए उनके छँटाई फ़ंक्शन को खोजना आसान बनाता है। मैंने कुछ बातें बताई: gist.github.com/Rizier123/24a6248758b53245a63e839d8e08a32b लेकिन मुझे अभी भी इसके बारे में सोचना है, अगर यह अलग-अलग उत्तर के रूप में पोस्ट करने के लिए उपयोगी और मूल्यवान है, क्योंकि यह बहुत समान सामग्री है
Rizier123

139

अच्छी तरह से सबसे बुनियादी तरीकों को पहले से ही धोखे से कवर किया गया है मैं अन्य प्रकार के प्रकार को देखने की कोशिश करूंगा

एसपीएल के साथ छंटनी

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

सॉर्ट के अन्य प्रकार

बबल शॅाट

बबल सॉर्ट पर विकिपीडिया लेख से :

बबल सॉर्ट, जिसे कभी-कभी गलत तरीके से सिंकिंग सॉर्ट के रूप में संदर्भित किया जाता है, एक साधारण सॉर्टिंग एल्गोरिथ्म है जो बार-बार लिस्ट के माध्यम से सॉर्ट करने के लिए काम करता है, आसन्न वस्तुओं के प्रत्येक जोड़े की तुलना करता है और गलत क्रम में होने पर उन्हें स्वैप करता है। सूची में पास तब तक दोहराया जाता है जब तक कोई स्वैप की आवश्यकता नहीं होती है, जो इंगित करता है कि सूची क्रमबद्ध है। एल्गोरिथ्म का नाम सूची के शीर्ष पर छोटे तत्वों "बुलबुले" के रास्ते से मिलता है। क्योंकि यह केवल तत्वों पर काम करने के लिए तुलना का उपयोग करता है, यह तुलनात्मक प्रकार है। यद्यपि एल्गोरिथ्म सरल है, अन्य छँटाई वाले अधिकांश एल्गोरिदम बड़ी सूचियों के लिए अधिक कुशल हैं।

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

चयन छांटना

चयन प्रकार पर विकिपीडिया लेख से :

कंप्यूटर विज्ञान में, चयन सॉर्टिंग एक एल्गोरिथ्म है, विशेष रूप से इन-प्लेस तुलना सॉर्ट। इसमें 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;
}

सम्मिलन सॉर्ट

प्रविष्टि सॉर्ट पर विकिपीडिया लेख से :

सम्मिलन सॉर्ट एक सरल सॉर्टिंग एल्गोरिथ्म है जो एक समय में अंतिम सॉर्ट किया गया सरणी (या सूची) बनाता है। यह अधिक उन्नत एल्गोरिदम जैसे क्विकसॉर्ट, हेप्सोर्ट, या मर्ज सॉर्ट की तुलना में बड़ी सूचियों पर बहुत कम कुशल है। हालाँकि, प्रविष्टि सॉर्ट कई फायदे प्रदान करता है:

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

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

कंघी की छँटाई

कंबाइन सॉर्ट पर विकिपीडिया लेख से :

कंबाइन सॉर्ट एक अपेक्षाकृत सरल सॉर्टिंग एल्गोरिथ्म है, जिसे मूल रूप से 1980 में व्लोड्ज़िमिएरज़ डोबोसाइविज़ द्वारा डिजाइन किया गया था। बाद में इसे 1991 में स्टीफन लेसी और रिचर्ड बॉक्स द्वारा फिर से खोजा गया। कॉम्ब सॉर्ट बबल सॉर्ट में सुधार करता है।

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

मर्ज़ सॉर्ट

मर्ज सॉर्ट पर विकिपीडिया लेख से :

कंप्यूटर विज्ञान में, एक मर्ज सॉर्ट (आमतौर पर वर्तनी विलय भी) एक ओ (एन लॉग एन) तुलना-आधारित सॉर्टिंग एल्गोरिदम है। अधिकांश कार्यान्वयन एक स्थिर प्रकार का उत्पादन करते हैं, जिसका अर्थ है कि कार्यान्वयन सॉर्ट किए गए आउटपुट में समान तत्वों के इनपुट ऑर्डर को संरक्षित करता है

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 पर विकिपीडिया लेख:

क्विकॉर्ट, या विभाजन-विनिमय सॉर्ट, टोनी होरे द्वारा विकसित एक सॉर्टिंग एल्गोरिथ्म है, जो औसतन, ओ (एन लॉग एन) की तुलना एन वस्तुओं को सॉर्ट करने के लिए करता है। सबसे खराब स्थिति में, यह 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));
}

क्रमपरिवर्तन क्रम

क्रमबद्धता क्रमांक पर विकिपीडिया लेख से :

क्रमबद्धता क्रमबद्धता, जो क्रमबद्ध किए गए की खोज तक इनपुट सरणी / सूची के संभावित क्रमपरिवर्तन को उत्पन्न करके आगे बढ़ती है।

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

4
@ आप सभी मूल बातों को कवर करें .. मुझे प्रासंगिक होने का एक और तरीका तलाशना था :)
बाबा

5
मैं अधिक शैक्षणिक छँटाई के तरीकों के साथ कुछ भी गलत नहीं देख रहा हूँ :) ज्यादातर अनुप्रयोगों के लिए कम उपयोगी है, लेकिन कभी-कभी वे / के लिए कहा जा सकता है / आवश्यकता विशेष रूप से एक संदर्भ के लिए आसान है क्योंकि मैं समय के साथ इनमें से अधिकांश के बारे में क्षमा चाहता हूँ
डेव

दरअसल, त्वरित प्रकार के लिए तीन मूल्यों के मध्य के रूप में धुरी का चयन करने की सिफारिश की जाती है : पहला, मध्य और अंतिम तत्वयह धुरी विभाजन के लिए मेरा उदाहरण है। यह सबसे खराब स्थिति वाले रिवर्स-सॉर्ट किए गए सरणी से बचने की अनुमति देता है (जो O(n^2)तुलना का कारण बनता है अगर हम धुरी के रूप में पहले तत्व का उपयोग करेंगे)
अल्मा डू

मैंने सुना है कि स्प्ल सामान्य छंटाई की तुलना में तेजी से काम करता है। क्या यह सही है?
जौहरी

मैं डेव से सहमत हूं, आजकल, लगभग एफडब्ल्यू में यह शामिल है कि मुझे शायद ही कभी याद है या इसका उपयोग क्यों करना है।
माइक गुयेन

43

स्थिर प्रकार

मान लीजिए कि आपके पास एक सरणी है:

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

और अब आप पहले अक्षर पर ही छाँटना चाहते हैं:

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

परिणाम यह है:

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

सॉर्ट स्थिर नहीं था!

उत्सुक पर्यवेक्षक ने देखा हो सकता है कि सरणी सॉर्टिंग एल्गोरिथ्म (क्विकसॉर्ट) एक स्थिर परिणाम उत्पन्न नहीं करता है और यह कि पहले अक्षर के शब्दों के बीच मूल क्रम संरक्षित नहीं था। यह मामला तुच्छ है और हमें पूरे स्ट्रिंग की तुलना करनी चाहिए थी, लेकिन मान लें कि आपका उपयोग-मामला अधिक जटिल है, जैसे कि अलग-अलग क्षेत्रों पर लगातार दो प्रकार जो एक दूसरे के काम को रद्द नहीं करना चाहिए।

श्वार्टजियन परिवर्तन

श्वार्ट्जियन ट्रांसफ़ॉर्म , जिसे डेकोरेट-सॉर्ट-अनडकोरेट मुहावर भी कहा जाता है, एक स्थिर सॉर्टिंग एल्गोरिदम के साथ एक स्थिर सॉर्ट को प्रभावित करता है।

सबसे पहले, आप प्रत्येक सरणी तत्व को एक प्राथमिक कुंजी (मान) और एक द्वितीयक कुंजी (इसके सूचकांक या स्थिति) वाले अन्य सरणी के साथ सजाते हैं:

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

देखा! आपका प्राचीन तुलना कोड वापस आ गया है।


आपका वाक्यांश "एक अंतर्निहित अस्थिर छँटाई एल्गोरिथ्म के साथ एक स्थिर प्रभाव" मेरे लिए आह-हा पल था। विकिपीडिया पृष्ठ में स्थिर शब्द का कोई उल्लेख नहीं है, जो मुझे परिवर्तन की सुंदरता लगता है। शर्म की बात है।
टायलर Collier

1
@TylerCollier हाँ, आपको लगता है कि विकिपीडिया संदर्भ की लाइनों के बीच पढ़ने की जरूरत है ... मैं आपको लगता है कि ;-) कर की परेशानी को बचाया
जैक

15

बंद होने के साथ PHP 5.3 के रूप में, अपने सॉर्ट के क्रम को निर्धारित करने के लिए एक क्लोजर का उपयोग करना भी संभव है।

उदाहरण के लिए मान लेना $ सरणी वस्तुओं का एक सरणी है जिसमें एक महीने की संपत्ति होती है।

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

बस याद रखें कि यह किसी भी पिछले रिश्तेदार क्रम को हटा देगा (उदाहरण के लिए, पूर्व-सॉर्ट की गई सूची में पहला "जुलाई" ऑब्जेक्ट छँटाई के बाद जुलाई ऑब्जेक्ट के समूह के अंत में समाप्त हो सकता है)। ऊपर "स्थिर क्रमबद्ध" देखें।
जॉर्ज लैंगली

9

LINQ

.NET में, LINQ का उपयोग अक्सर छँटाई के लिए किया जाता है, जो तुलनात्मक कार्यों पर एक बहुत अच्छा वाक्यविन्यास प्रदान करता है, खासकर जब वस्तुओं को कई क्षेत्रों द्वारा क्रमबद्ध करने की आवश्यकता होती है। LINL के कई पोर्ट हैं, जिसमें YaLinqo लाइब्रेरी * सहित PHP शामिल हैं । इसके साथ, जटिल तुलना कार्यों को लिखे बिना सरणियों को एक पंक्ति के साथ क्रमबद्ध किया जा सकता है।

$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 से प्रेरित कई और तरीके हैं: फ़िल्टरिंग, ग्रुपिंग, जॉइनिंग, एग्रीगेटिंग आदि। यह उन मामलों के लिए सबसे उपयुक्त है जब एरे और ऑब्जेक्ट्स पर जटिल बदलाव डेटाबेस पर भरोसा किए बिना किए जाने की आवश्यकता होती है।

* मेरे द्वारा विकसित, अधिक विवरण और अन्य LINQ बंदरगाहों के साथ तुलना के लिए readme देखें


3

कुंजी मूल्य द्वारा बहुआयामी प्रकार

एक कुंजी मूल्य द्वारा एक बहुआयामी सरणी का प्राकृतिक प्रकार और मूल क्रम भी रखें (मुख्य कुंजियों को फेरबदल न करें):

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,
  ),
)
*/

2

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

आप इन सभी उदाहरणों को यहां देख सकते हैं ।


2

यदि आप कुंजी मूल्य द्वारा ऑर्डर करना चाहते हैं, तो आप इसे एक पंक्ति, सुरुचिपूर्ण और स्पष्ट कर सकते हैं। यह आरोही मूल्य द्वारा आदेश देगा। 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 ) )

1

यह पृष्ठ बहुत व्यापक है, लेकिन मैं स्पेसशिप ऑपरेटर (तीन तरह के तुलना ऑपरेटर) की भयानक उपयोगिता के बारे में थोड़ा और जोड़ना चाहता हूं - 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 (गलत = 0, सही = 1, इसलिए झूठ बोलने से पहले)
    2. फ्लोट ASC

      uasort($multidimArray, function($a, $b) {
          return [$b['boolean'], $a['float']] <=> [$a['boolean'], $b['float']];
      });
  • सॉर्टिंग लॉजिक:

    1. मिश्रित ए.एस.सी.
    2. ऑब्जेक्ट ए.एस.सी.
    3. बूलियन ए.एस.सी.

      uasort($multidimArray, function($a, $b) {
          return [$a['mixed'], $a['object']->prop, $a['boolean']] <=> [$b['mixed'], $b['object']->prop, $b['boolean']];
      });
  • सॉर्टिंग लॉजिक:

    1. ऑब्जेक्ट की संपत्ति गणना ए.एस.सी.
    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 से अपने स्वयं के विवेक पर, आप इन अनाम कार्यों के साथ तीर सिंटैक्स का उपयोग कर सकते हैं। बाण वाक्य रचना के साथ एक ही स्क्रिप्ट


0

यदि कोई सरणियों में हेरफेर करने के लिए एक सरल समाधान चाहता है, तो बस लारवेल कलेक्शन पैकेज का उपयोग करें जिसमें एक कार्यान्वित सॉर्टबाय फ़ंक्शन होता है जो कुंजी द्वारा आपके सॉर्ट को बस देता है।

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

यानी, क्रमबद्ध करने के लिए पहले a, फिर b, c, सही खंड होगा

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

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


-1

किसी सरणी को सॉर्ट करने के कई तरीके हैं। मैं उस कार्य को करने के लिए कुछ तरीकों का उल्लेख करूंगा। सभी के लिए, मैं एक पूर्णांक सरणी दूंगा जिसे '$ संख्या' कहा जाता है।

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

यह एक सरणी बनाने का सामान्य तरीका है। मान लीजिए कि, मैं उस सरणी को आरोही क्रम में क्रमबद्ध करना चाहता हूं। इसके लिए, 'सॉर्ट ()' विधि का उपयोग किया जा सकता है।

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

इसलिए, अब मैं इस सरणी को उनके मान के अनुसार आरोही क्रम में क्रमबद्ध करना चाहता हूं।'ort '(') विधि का उपयोग इसके लिए किया जा सकता है।

<?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 ()' विधि का उपयोग किया जा सकता है। मान लीजिए कि आप उस सरणी को उनके प्रमुख मान के अनुसार क्रमबद्ध करना चाहते हैं। इसमें this 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 में आरोही या अवरोही क्रम में एक छँटाई के लिए कुछ तरीके हैं। मुझे आशा है कि आप एक विचार प्राप्त कर सकते हैं। धन्यवाद!


धोखे से इन अंतर्दृष्टि को पहले से ही कवर नहीं करता है: "उन लोगों के बीच का अंतर केवल यह है कि क्या कुंजी-मूल्य संघों को रखा जाता है (" ए "फ़ंक्शन), चाहे वह निम्न-से-उच्च या रिवर्स (" आर ") की तरह हो, चाहे मान या कुंजी ("k") और यह मानों की तुलना कैसे करता है ("nat" बनाम सामान्य)। " स्वीकृत उत्तर में?
मिकमैकुसा

-2

सबसे सरल है किसी भी लूपिंग के बिना सरणी को सॉर्ट करने के लिए 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;
    });

1
1) उदाहरण और कोड असंगत हैं। 2) यह पहले से ही उपरोक्त उत्तरों में विस्तृत रूप से समझाया गया है। 3) क्या आप संभवतः एक अलग सवाल का जवाब देने की कोशिश कर रहे हैं?
deceze
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.