શફલ 2 એન પૂર્ણાંકો a1-b1-a2-b2-a3-b3 તરીકે - .. વધારાની જગ્યાનો ઉપયોગ કર્યા વિના બી.એન.


મુશ્કેલી સ્તર મધ્યમ
વારંવાર પૂછવામાં આવે છે એડોબ ડીઇ શw એક્સપેડિયા કટ્ટરતા ખરેખર પે
અરે વિભાજીત અને વિજય રિકર્ઝન

સમસ્યા નિવેદન

તમે એક આપવામાં આવે છે એરે of પૂર્ણાંક. સમસ્યા "શફલ 2 એન પૂર્ણાંક તરીકે a1-b1-a2-b2-a3-b3 - .. વધારાની જગ્યાનો ઉપયોગ કર્યા વિના બી.એન." એરેમાં બધી સંખ્યાઓ શફલ કરવાનું કહે છે જેમ કે નંબરો (x0, x1, x2, x3, y0, y1, y2, y3) x0, y0, x1, y1, x2, y2, x3, y3 અને આ રીતે બદલાશે.

ઉદાહરણ

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

સમજૂતી

જો આપણે પ્રથમ ત્રણ નંબરોની તુલના કરીએ તો તે x0, x1, x2 જેવી હશે અને આગળ ત્રણ નંબરો y0, y1, y2 જેવા હશે, અને તે x0, y0, x1, y1, x2, y2 માં ગોઠવવામાં આવશે.

શફલ 2 એન પૂર્ણાંકો a1-b1-a2-b2-a3-b3 તરીકે - .. વધારાની જગ્યાનો ઉપયોગ કર્યા વિના બી.એન.

એલ્ગોરિધમ થી શફલ 2 એન પૂર્ણાંકો a1-b1-a2-b2-a3-b3 તરીકે .. .. વધારાની જગ્યાનો ઉપયોગ કર્યા વિના બી.એન.

1. Find out the middle index of the array.
2. While middleIndex greater than 0, set count and swappingIndex to middleIndex.
  1. While the count is greater than 0, do the following steps.
    1. Swap the values at swappingIndex and swappingIndex +1(value next to swappingIndex).
    2. Increase the value of swapping index by 1.
  2. Decrease the value of middleIndex by 1.
3. Print the array.

સમજૂતી

અમે એક આપ્યો છે એરે of પૂર્ણાંક.  પછી અમને બધા પૂર્ણાંક મૂલ્યોને ખાસ કરીને આપેલ રીતે શફલ કરવાનું કહેવામાં આવે છે. આપણે એરેના અડધા ભાગને જ શોધીશું. અને એલ્ગોરિધમ મુજબ આવતા તમામ કિંમતોને અદલાબદલ કરી રહ્યા છીએ. પ્રથમ, અમે તપાસવા જઈ રહ્યા છીએ કે એરે નલ ન હોવી જોઈએ. જવાબ પણ, એરેની લંબાઈ સમાન હોવી જોઈએ. તેથી જ અમે એ સ્થિતિ તપાસીએ છીએ કે એરેની લંબાઈ વિચિત્ર હોવી જોઈએ નહીં. જો ઉપર જણાવેલ શરતોમાંથી કોઈ પણ ખોટી છે, તો તે આઉટપુટ ઉત્પન્ન કરશે નહીં.

આપણે એરેનું મધ્ય અનુક્રમણિકા શોધીશું અને તે પછી તે અનુક્રમણિકાનું મૂલ્ય અને તેની આગામી અનુક્રમણિકા મૂલ્ય તપાસીશું અને તેને સરળતાથી બદલીશું. તેના માટે, અમે નેસ્ટેડનો ઉપયોગ કરીશું જ્યારે લૂપ લૂપ જ્યારે પ્રથમ. પછી આપણે તેને તે વર્તમાન અનુક્રમણિકાથી 0 પર પસાર કરીશું અને મધ્યમ અનુક્રમણિકાનું મૂલ્ય ઘટાડતા રહીશું. અંદરની અંદર જ્યારે લૂપ, આપણે સ્વેપિંગઇન્ડેક્સમાં વર્તમાન અનુક્રમણિકા જેટલું જ મૂલ્ય સંગ્રહિત કરીશું અને પછી સ્વેપિંગઇન્ડેક્સ મૂલ્ય અને તેના આગલા મૂલ્યને લઈએ છીએ અને તેને સ્વેપ કરીશું. બીજા સ્વેપ માટે, સ્વappપિંગઇન્ડેક્સનું મૂલ્ય વધારવું અને વર્તમાન સ્વappપિંગઇન્ડેક્સ અને તેના પછીના અનુક્રમણિકાના મૂલ્ય માટે સ્વેપિંગ કરવું.

હવે પછીના ટ્રેવર્સલ માટે, અમે મધ્યમ અનુક્રમણિકાના મૂલ્યમાં ઘટાડો કરીશું. જેથી તે એરે ની આગળ થી કિંમતો લઈ શકે. એ જ રીતે, ગણતરી અને સ્વappપિંગઇન્ડેક્સ મધ્યમ અનુક્રમણિકાના મૂલ્ય જેટલું જ હશે જે આપણે એરેના પહેલાના મૂલ્યોને વટાવી નાખવાનું ઘટાડ્યું છે. અમે કરેલા બધા અદલાબદલ પછી, અમે તે એરે છાપવા જઈશું, અને બધી સંખ્યાઓ આપેલ રીતે બદલી શકાશે.

કોડ

સી ++ કોડ માટે એએન-બી 2-એ 1-બી 1-એ 2-બી 2 - 3 બી પૂર્ણાંકો શફલ કરો .. .. વધારાની જગ્યાનો ઉપયોગ કર્યા વિના બી.એન.

#include<iostream>
using namespace std;

void shuffleInt(int arr[], int n)
{
    if (arr == NULL || n % 2 == 1)
        return;

    int middleIndex = (n - 1) / 2;

    while (middleIndex > 0)
    {
        int countIndex = middleIndex, swappingIndex = middleIndex;

        while (countIndex -- > 0)
        {
            int temp = arr[swappingIndex + 1];
            arr[swappingIndex + 1] = arr[swappingIndex];
            arr[swappingIndex] = temp;
            swappingIndex++;
        }
        middleIndex--;
    }
}
int main()
{
    int arr[] = {1, 9, 25, 4, 16, 36};
    int n = sizeof(arr) / sizeof(arr[0]);
    shuffleInt(arr, n);
    for (int i = 0; i < n; i++)
        cout << arr[i]<<" ";
}
1 4 9 16 25 36

જાવા કોડ શફલ 2 એન પૂર્ણાંકો તરીકે a1-b1-a2-b2-a3-b3 - .. બી.એન. વધારાની જગ્યાનો ઉપયોગ કર્યા વિના

class Shuffle2nIntegers
{
    public static void shuffleInt(int[] arr)
    {

        if (arr == null || arr.length % 2 == 1)
            return;

        int middleIndex = (arr.length - 1) / 2;


        while (middleIndex > 0)
        {
            int countIndex = middleIndex, swappingIndex = middleIndex;

            while (countIndex -- > 0)
            {
                int temp = arr[swappingIndex + 1];
                arr[swappingIndex + 1] = arr[swappingIndex];
                arr[swappingIndex] = temp;
                swappingIndex++;
            }
            middleIndex--;
        }
    }

    public static void main(String[] args)
    {
        int arr[] = {1, 9, 25, 4, 16, 36};
        shuffleInt(arr);
        for (int i = 0; i < arr.length; i++)
            System.out.print( arr[i]+" ");
        System.out.println();
    }
}
1 4 9 16 25 36

જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (n ^ 2) જ્યાં “એન” એરેમાં તત્વોની સંખ્યા છે. દરેક વખતે જેમ આપણે એક પછી એક મધ્યમ ઇન્ડેક્સ ઘટાડી રહ્યા છીએ. પરંતુ આંતરિક લૂપ મધ્યમ ઇન્ડેક્સ સંખ્યા માટે ચાલે છે. તમે તેને સરળ બે નેસ્ડ લૂપ્સ તરીકે ગણી શકો છો જ્યાં બાહ્ય લૂપ i = 0 થી n અંદરની લૂપ i + 1 થી ચાલે છે. આમ સમય-જટિલતા બહુપદી છે.

અવકાશ જટિલતા

ઓ (1), કારણ કે અલ્ગોરિધમનો એ સ્થળની અલ્ગોરિધમનો છે. તે બધા ઓપરેશન્સ છે જે પ્રારંભિક એરે એલિમેન્ટ્સને બદલી રહ્યા છે. અને કોઈપણ નવી એરે બનાવવામાં આવતી નથી.