جاوا ۾ ملائي ترتيب ڏيو

هر پروگرامر کي لازمي طور تي مستقبل جي ڪم جي اسڪيم/پلان/آرڪيٽيڪچر ذريعي سوچڻ گهرجي، ٻي صورت ۾ اهو سڀ ڪجهه خرابي ۾ ختم ٿي ويندو، مڪمل انتشار سان. جيئن ڪنهن به پوسٽ سان، توهان کي شروعات ۾ هڪ منصوبي جي ضرورت آهي، اچو ته شروع ڪريون.

• 1) اچو ته ضم ڪرڻ جو موضوع وٺون شروعات ڪندڙن لاءِ.
• 2) اسان هڪ فن تعمير ۽ وڌيڪ ڪم لاء هڪ منصوبو ٺاهينداسين.
• 3) اسان ڪم ڪنداسين ۽ منصوبي جي سڀني حصن کي بيان ڪنداسين.
• 4) اچو ته ڪارڪردگي ۽ معيار جي جانچ ڪريو.

• 2.1) ضم ڪرڻ ڇا آهي.
• 2.2) ممڪن دستخط جي وضاحت.
• 2.3) ھڪڙو مثال ڏيو.
• 2.4) مثال استعمال ڪندي جاوا ۾ عمل درآمد بيان ڪريو.
• 2.5) ڪا به اضافي.

ضم ڪريو - جاوا ۾ ترتيب ڏيو

”ورهايو ۽ فتح ڪريو“ جي اصول جو مطلب آهي. خيال ۽ ان جي معنيٰ ڇا آهي؟

1. ترتيب ڏيڻ.

   اسان صف کي حصن ۾ ورهايو جيستائين اهو 1 عنصر جي برابر نه هجي. هر 1 عنصر ترتيب ڏنل آهي.

2. ملائڻ.

   ترتيب ڏنل عناصر کي ضم ڪرڻ.
   ڪارڊ جي ٻن ڊيڪ جي اصول جي بنياد تي. اسان ٽيبل تي ڪارڊ جا 2 ڊيڪ رکيا آھن انھن جي قيمتن سان گڏ، ۽ اھو ڪارڊ جيڪو گھٽ ۾ گھٽ آھي، ٽين نتيجي ۾ ڪارڊن جي پائل ۾ رکيل آھي. بالآخر، جيڪڏهن اسان هڪ خاص ڊيڪ ۾ ڪارڊ ختم ڪريون ٿا، اسان انهن کي هڪ هڪ ڪري نتيجو ڊيڪ ڏانهن منتقل ڪريون ٿا. نتيجو ٻن ترتيب ڏنل صفن جو ضم ٿي ويندو، ھڪڙو نئون، ترتيب ڏنل صف.

خرچ ٿيل وقت O (n log2 n) آهي. ترتيب ڏيڻ بلڪل تيز سمجهيو ويندو آهي. مختصر طور تي الگورتھم جي پيچيدگي بابت، جيڪڏهن ڪنهن کي ضرورت هجي. توهان اڪثر ڪري سگهو ٿا افعال جهڙوڪ:

Sort(A, p, q);
Merge(A, p, q, r);

اهو ساڳيو شيء بابت آهي، صرف انڊيڪس سان ڳنڍيل آهي. انهن ۾ متغير آهن:

A = Array = Массив
p, q, r = индексы для массива
p - начало первого массива
q - конец первого массива
q + 1 - начало второго массива
r - конец второго массива

جيڪڏهن اهي متغير بيان نه ڪيا وڃن ته پوءِ جيڪو اهڙو ڪم ڪرڻ لاءِ پڇي ٿو اهو پاڻ نه ٿو ڄاڻي ته هو ڇا ٿو چاهي. ۽ توهان کي گوگل کي ڳولڻو پوندو ته اهو ڇا آهي، توهان شايد اهو ڳوليندا، شايد. اچو ته اسان جي ترتيب جو هڪ مثال ڏيو. هتي هڪ صف آهي {6, 1, 3, 5, 2, 4, 7, 8}، جيڪڏهن ان جي ڊيگهه 1 کان وڌيڪ آهي، پوء اسان ان کي 2 حصن ۾ ورهايو ۽ کاٻي {6, 1, 3, 5}۽ ساڄي حصو حاصل ڪريو {2, 4, 7, 8}. اسان 2 حصن ۾ ورهائڻ واري عمل کي جاري رکون ٿا جيستائين ان جي ڊيگهه 1 کان وڌيڪ نه ٿي وڃي. نتيجي طور، اسان کي 1 عنصر جي ڊيگهه سان گڏ صفن جو هڪ گروپ ملي ٿو، يعني: {6} {1} {3} {5} {2} {4} {7} {8}. جاوا ۾ عمل درآمد هن طرح آهي:

public int [] sortArray(int[] arrayA){ // sorting Массива который передается в функцию
        // проверяем не нулевой ли он?
        if (arrayA == null) {
            return null;
        }
        // проверяем не 1 ли элемент в массиве?
        if (arrayA.length < 2) {
            return arrayA; // возврат в рекурсию в строки ниже см комменты.
        }
        // копируем левую часть от начала до середины
        int [] arrayB = new int[arrayA.length / 2];
        System.arraycopy(arrayA, 0, arrayB, 0, arrayA.length / 2);

        // копируем правую часть от середины до конца массива, вычитаем из длины первую часть
        int [] arrayC = new int[arrayA.length - arrayA.length / 2];
        System.arraycopy(arrayA, arrayA.length / 2, arrayC, 0, arrayA.length - arrayA.length / 2);

        // рекурсией закидываем поделенные обе части обратно в наш метод, он будет крутится до тех пор,
        // пока не дойдет до 1 element в массиве, после чего вернется в строку и будет искать второй такой же,
        // точнее правую часть от него и опять вернет его назад
        arrayB = sortArray(arrayB); // левая часть возврат из рекурсии строкой return arrayA;
        arrayC = sortArray(arrayC); // правая часть возврат из рекурсии строкой return arrayA;

        // далее опять рекурсия возврата слияния двух отсортированных массивов
        return mergeArray(arrayB, arrayC);
    }

اڳيون توهان کي انهن صفن کي 1 ۾ ضم ڪرڻ جي ضرورت آهي. اهو ڪيئن ڪجي؟ هر صف مان گھڻا ڀيرا وڃڻ کان بچڻ لاءِ، اچو ته داخل ڪريون پوزيشن انڊيڪس هر صف لاءِ. ان کان پوء اسان هڪ ڀيرو هڪ لوپ ذريعي وڃون ٿا، انهن ٻنهي صفن جي ڊيگهه جي برابر. پهرين صف ۽ ٻيو صف وٺو، ۽ پهريون عنصر وٺو، پهرين صف ۾ عنصر نمبر 1 ۽ ٻئي صف ۾ عنصر نمبر 1 ؟ ننڍڙو ھڪڙو نتيجو واري صف ۾ رکيل آھي. هتي اهو ضروري آهي ته جيڪڏهن اسان پهرين ايري مان هڪ عنصر ورتو آهي، پوء جڏهن لوپ گذري ٿو، ان کي پهرئين سري جي 2nd عنصر ڏانهن ۽ ٻئي سر جي پهرين عنصر ڏانهن اشارو ڪرڻ گهرجي. هن کي ڪرڻ لاءِ، توهان کي ٻي صف جي انڊيڪس کي +1 وڌائڻ جي ضرورت آهي ۽، چيڪ ڪرڻ وقت، ان کي چڪر نمبر مان ڪڍو، ساڳئي طرح پهرين صف لاءِ. ڇا اهو واضح آهي ته اهو ڇو ڪجي؟ يا ڪجهه به واضح ناهي؟ :-) مثال طور، اتي 2 arrays آهن: {1}{4}{8}۽ {3}{6}{7} اتي هڪ لوپ آهي:

for (int i = 0; i < arrayA.length + arrayB.length; i++) {
	if (arrayA[i] < arrayB[i]) {
	arrayC[i] = arrayA[i];
	} else {
	arrayC[i] = arrayB[i];
	}
}

لوپ جي پهرين پاس تي، اهو ظاهر ٿئي ٿو ته arrayC[1] = {1}: اسان هن عنصر کي پهرين صف مان ورتو. ان کان پوء، جڏهن ٻئي لوپ ذريعي وڃون ٿا، اسان کي پهريان کان ئي عنصر جو مقابلو ڪرڻ گهرجي {4}۽ {3}، پر اهو ڪرڻ لاء اسان کي اڪائونٽ انڊيڪس ۽ ٻنهي صفن جي آفسيٽ کي حساب ۾ رکڻو پوندو، ان لاء اسان انهن کي داخل ڪندا آهيون.

int positionA = 0, positionB = 0;
for (int i = 0; i < arrayA.length + arrayB.length; i++) {
	if (arrayA[i - positionA] < arrayB[i - positionB]) {
	arrayC[i] = arrayA[i - positionA];
	positionB++;
	} else {
	arrayC[i] = arrayB[i - positionB];
	positionA++;
	}
}

پر اهو سڀ ڪجهه نه آهي، توهان کي اهو خيال رکڻو پوندو ته ڪجهه صف اڳ ۾ ختم ٿي سگهي ٿي. مثال طور، اتي 3 صفون آھن: {1}{3}{5}۽ {6}{7}{9} پھريون صفون ختم ٿي وينديون ٻيون اچڻ کان اڳ، ان لاء توھان کي چيڪ داخل ڪرڻ جي ضرورت آھي، ۽ اصول ۾، ضم ڪرڻ جو ڪم تيار آھي.

public int [] mergeArray(int [] arrayА, int [] arrayB) {

int [] arrayC = int[arrayA.length + arrayB.length];
int positionA = 0, positionB = 0;

for (int i = 0; i < arrayC.length; i++) {
	if (positionA == arrayA.length){
	arrayC[i] = arrayB[i - positionB];
	positionB++;
	} else if (positionB == arrayB.length) {
	arrayC[i] = arrayA[i - positionA];
	positionA++;
	} else if (arrayA[i - positionA] < arrayB[i - positionB]) {
	arrayC[i] = arrayA[i - positionA];
	positionB++;
	} else {
	arrayC[i] = arrayB[i - positionB];
	positionA++;
	}
}
return arrayC;

هن ترتيب جي باري ۾ سڀ کان مشڪل شيء آهي ورهاست جي منتقلي جو اصول. اهي. اسان کاٻي پاسي کي ورهاست ۾ اڇليندا آهيون جيستائين اهو 2 سان ورهائجي نه وڃي، ۽ پوءِ ان کي واپس هلايو، لفظن ۾ اهو تمام پيچيده ۽ مونجهارو آهي، پر جڏهن توهان تصور ڪرڻ جي ڪوشش ڪريو، جيڪڏهن اهو اڃا واضح ناهي، ته اهو هڪ مڪمل گندگي آهي. اچو ته صفون وٺون: {2}{1}{4}{3}. پهرين ترتيب ڏيڻ واري ورهاست ان کي 2 حصن ۾ ورهائي ويندي ۽ فنڪشن کي ٻيهر عنصرن 2-1 سان هلائيندو ، پوءِ ٻيهر عنصرن 2 ۽ 1 سان ، انهن کي موڙ ۾ موٽايو، پوءِ اهي سڀ کان پهريان مرج فنڪشن ۾ ايندا، ۽ 1-2 ايندا. ٻاهر ، پوءِ ريٽرن واپس موٽندو ۽ 4-3 کي انضمام ۾ اڇلايو ، پوءِ 4 ۽ 3 ، ان کان پوءِ ضم ٿي ويندو 3-4 ، ۽ صرف ان کان پوءِ ريٽرن ٻيهر گھمندو ۽ 1-2 ۽ 3-4 ڪندو. ضم ۾ شامل ڪيو وڃي ، ۽ ترتيب ڏنل صف کي واپس ڪيو ويندو 1-2-3-4 . خير، اهو سڀ ڪجهه آهي، ترتيب ڏيڻ ٻن ڪمن تي مشتمل آهي.

sortArray(array); 			// кладем массив который нужно отсортировать
mergeArray(arrayA, arrayB); 	// кладем 2 массива которые нужно слить в один

جيڪڏهن توهان ڪجهه قسم جا مکيه لکندا آهيو، توهان کي ڪجهه ملندو:

public static void main(String[] args) {
        Merge testMerge = new Merge();
        int [] result = testMerge.sortArray(new int[]{2,3,1,4});

        for (int i = 0; i < result.length ; i++) {
            System.out.print(result[i] + " ");
        }
    }

منهنجي لاءِ، هي ترتيب ڏيڻ هڪ مڪمل ناڪامي هئي، اتي هڪ لک سوال هئا، پر ڪو به جواب نه هو، مون سڄي انٽرنيٽ ذريعي ڳولهيو، ٻيهر پڙهيو، وڊيوز جو هڪ گروپ ڏٺو، پر هميشه وانگر، مون کي صرف پنهنجو پاڻ کي جواب مليو. ۽ صرف جڏهن مون هڪ حل لکڻ شروع ڪيو ان کان مڪمل طور تي مختلف جيڪو هر جڳهه تي چمڪي ٿو) پر آخر ۾ اهو ٻين سڀني وانگر ساڳيو نڪتو))) ترتيب ڏيڻ اصل ۾ آسان آهي، بنيادي شيء اها آهي ته ان کي عمل ۾ مداخلت سان پيش ڪرڻ، ۽ هر شيءِ پنهنجي جاءِ تي اچي وڃي ٿي جيڪڏهن توهان ان کي هٽائي ڇڏيو، مان هڪ وڊيو ٺاهيندس)))) هن وقت تائين، مون وٽ ايترو ئي ڪافي آهي جنهن لاءِ: مرج sort Merge-sort سڀ کان اهم شيءِ هميشه کان هڪ پلان ٺاهڻ آهي. شروعات. اهو بهتر آهي ته ٿورو انتظار ڪريو ۽ سوچڻ کان پهريان توهان ڪجھ به ڪرڻ شروع ڪيو. ان ۾ وڌيڪ وقت لڳي سگهي ٿو، پر هڪ سمجھه ۽ هڪ حل سامهون اچي ويندو بلڪه ان کي ٻه ڀيرا ٻيهر لکڻ ۽ ڪچري سان گڏ اچڻ جي. توهان جي وقت، سٺي قسمت ۽ سٺي مزاج لاء توهان سڀني جي مهرباني. ) پي ايس: تنقيد، سٺي ۽ خراب، گڏوگڏ سوالن جو تمام گهڻو استقبال آهي. )))