අනුපිළිවෙලින් පෙළක් නැවත සකස් කරන්න - කුඩාම, විශාලතම, 2 වන කුඩාම, 2 වන විශාලතම  


දුෂ්කරතා මට්ටම මධ්යම
නිතර අසනු ලැබේ ඇමේසන් සිටඩෙල් Expedia GE සෞඛ්යාරක්ෂණය Qualcomm ගුණාත්මකභාවය ට්රිලිලියෝ යත්රා
අරා වර්ග කිරීම

ගැටළු ප්රකාශය  

ඔබට පූර්ණ සංඛ්‍යා අරාවක් ඇතැයි සිතමු. “අරා පිළිවෙලට පිළිවෙලට සකස් කරන්න - කුඩාම, විශාලතම, 2 වන කුඩාම, 2 වන විශාලතම, ..” අරාව නැවත සකස් කිරීමට ඉල්ලා සිටින්නේ කුඩාම සංඛ්‍යාව පළමුව පැමිණෙන අතර පසුව විශාලතම සංඛ්‍යාව, පසුව දෙවන කුඩාම හා දෙවන විශාලතම සහ එසේ ය.

උදාහරණයක්  

arr[] = {1,4,6,2,3,8,9,7}
1 9 2 8 3 7 4 6

පැහැදිලි කිරීම: කුඩාම අංකය 1 වන අතර විශාලතම සංඛ්‍යාව 9, 2 වේnd කුඩාම 2 සහ 2 ලෙසnd විශාලතම 8, 3rd කුඩාම 3 සහ 3 වේrd විශාලතම අගය 7 වන අතර 4 වන කුඩාම 3 වන අතර 4 වන විශාලතම 7 වේ. මේ අනුව ප්‍රති output ල ප්‍රතිදානය ගැටළුවේ සඳහන් ආකාරයටම සකසා ඇත.

අනුපිළිවෙලින් පෙළක් නැවත සකස් කිරීම සඳහා ඇල්ගොරිතම - කුඩාම, විශාලතම, 2 වන කුඩාම, 2 වන විශාලතම  

1. Sort the given array.
2. We have to use a temporary array, so declare one.
3. Set index to 0.
4. Traverse the array from left and from right, with i = 0 and j = n – 1 up the half of the array length.
    1. Store the value of arr[j] to the temporary[index] and increase the value of the index by 1.
    2. Store the value of arr[j] to the temporary[index] and increase the value of the index by 1.
5. Update the original array by storing the value of a temporary array to the original array.
6. At last, the original array should be printed.

පැහැදිලි කිරීම

පෙළක් ලබා දී ඇත නිඛිල. කුඩාම හා විශාලතම සංඛ්‍යාවට අනුව අරා නැවත සකස් කරන ලෙස අපි ඉල්ලා සිටිමු අරාව පිළිවෙලින් පළමු හා දෙවන පැමිණිය යුතුය. එවිට 2nd කුඩාම හා 2md විශාලතම සංඛ්‍යාව පිළිවෙලින් ඊළඟට පැමිණිය යුතුය, පසුව එය දිගටම කරගෙන යයි, 3rd කුඩාම සහ 3rd විශාලතම සංඛ්‍යාව ඊළඟට පැමිණිය යුතුය. මෙම අනුපිළිවෙලෙහි, අපි අරාව නැවත සකස් කළ යුතුය. මෙම අවශ්‍යතාවය සපුරාලීම සඳහා අපි අතිරේක අරාවක් භාවිතා කරමු. ලබා දී ඇති අරාව වර්ග කරන්න, එවිට සෑම එකක්ම අඩු නොවන ආකාරයෙන් පැමිණේ.

මෙයද බලන්න
ප්‍රකාශනයක අසමසම වරහන් හඳුනා ගැනීම සහ සලකුණු කිරීම

අරාව වර්ග කිරීමෙන්, අපට පිළිවෙලින් එක් අර්ධයක කුඩාම අංකය සහ තවත් භාගයක විශාලතම සංඛ්‍යාව අරාව තුළ ඇත. අපට 1 සිට 10 දක්වා අංකයක් අහඹු ලෙස අරාවෙහි ගබඩා වී ඇතැයි සිතමු. ඒවා වර්ග කළහොත් 1 සිට 5 දක්වා පළමු භාගය ද 6 සිට 10 දක්වා දෙවන භාගය ද වේ යැයි සිතමු.

ඒ හා සමානව, අපට දැන් වමේ සිට ගමන් කර අගයන් අප විසින් සාදන ලද අරාව තුළට ගබඩා කළ හැකිය. අපි වමේ සිට ආරම්භ කරන බැවින්, එහි ඇත්තේ කුඩාම මූලද්‍රව්‍යය පමණි, එවිට අපට එම මූලද්‍රව්‍යය තාවකාලික අරාව තුළට ඇතුළු කළ හැකිය. එබැවින් පළමු ස්ථානයේ ඇත්තේ කුඩාම මූලද්රව්යය පමණි. විශාලතම මූලද්‍රව්‍යය තිබිය යුතු පරිදි අරාව වර්ග කර ඇති බැවින් දැන් දකුණේ සිට ඉදිරියට යන්න, එබැවින් දැන් අපි එම මූලද්‍රව්‍යය තාවකාලික අරාව තුළට දමමු. අපගේ පළමු කුඩාම හා විශාලතම වැඩ නිම කර ඇති අතර, දැන් අප මීට පෙර සිදු කළ ආකාරයට තවත් ඉදිරියට ගමන් කළ යුත්තේ වම් ඊලඟ මූලද්‍රව්‍යයෙන් එය තාවකාලික අරාවකට ගබඩා කර පසුව දකුණු පැත්තේ සිට දෙවන විශාලතම මූලද්‍රව්‍යය ගබඩාවක් අරාවකට ගෙන යා යුතුය. , අපට අවශ්‍ය ප්‍රති result ලය ලබා ගත හැකිය. දැන් එම අරාව මුද්‍රණය කරන්න.

අනුපිළිවෙලින් පෙළක් නැවත සකස් කරන්න - කුඩාම, විශාලතම, 2 වන කුඩාම, 2 වන විශාලතමපින්

කේතය  

අනුපිළිවෙලින් පෙළක් නැවත සකස් කිරීම සඳහා C ++ කේතය - කුඩාම, විශාලතම, 2 වන කුඩාම, 2 වන විශාලතම

#include<iostream>
#include<algorithm>

using namespace std;

void rearrangeInOrderSL(int arr[], int n)
{
    sort(arr, arr + n);

    int temporaryArray[n];

    int Index = 0;

    for (int i = 0, j = n-1; i <= n / 2 ||j > n / 2; i++, j--)
    {
        temporaryArray[Index] = arr[i];
        Index++;
        temporaryArray[Index] = arr[j];
        Index++;
    }
    for (int i = 0; i < n; i++)
        arr[i] = temporaryArray[i];

    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
int main()
{
    int arr[] = {1,4,6,2,3,8,9,7};
    int n = sizeof(arr) / sizeof(arr[0]);

    rearrangeInOrderSL(arr, n);

    return 0;
}
1 9 2 8 3 7 4 6

අනුපිළිවෙලින් පෙළක් නැවත සකස් කිරීම සඳහා ජාවා කේතය - කුඩාම, විශාලතම, 2 වන කුඩාම, 2 වන විශාලතම

import java.util.Arrays;
class rearrangeArraySL
{
    public static void rearrangeInOrderSL(int arr[], int n)
    {
        Arrays.sort(arr);

        int[] temporaryArray = new int[n];

        int Index = 0;

        for (int i = 0, j = n-1; i <= n / 2 || j > n / 2; i++, j--)
        {
            if(Index < n)
            {
                temporaryArray[Index] = arr[i];
                Index++;
            }

            if(Index < n)
            {
                temporaryArray[Index] = arr[j];
                Index++;
            }
        }
        for (int i = 0; i < n; i++)
            arr[i] = temporaryArray[i];
    }
    public static void main(String args[])
    {
        int arr[] = {1,4,6,2,3,8,9,7};
        int n = arr.length;
        rearrangeInOrderSL(arr, n);

        for (int i = 0; i < n; i++)
            System.out.print(arr[i]+" ");
    }
}
1 9 2 8 3 7 4 6

සංකීර්ණ විශ්ලේෂණය  

කාල සංකීර්ණත්වය

ඕ (එන් ලොග් එන්) එහිදී “එන්” යනු අරාවෙහි ඇති මූලද්‍රව්‍ය ගණන වේ. මෙම කාල සංකීර්ණත්වය ඇති ආදානය අප විසින් වර්ග කර ඇත.

මෙයද බලන්න
ඉක්මන් වර්ග කිරීම

අභ්‍යවකාශ සංකීර්ණතාව

මත) එහිදී “එන්” යනු අරාවෙහි ඇති මූලද්‍රව්‍ය ගණන වේ. වර්ග කිරීම ඒකාබද්ධ කරන්න O (N) අවකාශය ගනී.