အနှုတ်လက္ခဏာနံပါတ်များကိုအစသို့ပြောင်း။ Positive Extra Space ဖြင့်အဆုံးသတ်ပါမည်


ခက်ခဲအဆင့် လွယ်ကူသော
မကြာခဏမေးတယ် Capgemini ခရီးသွား MAQ o9 ဖြေရှင်းနည်းများ ကိုလန်ဘို
အခင်းအကျင်း sorting

မင်းမှာတစ်ခုရှိတယ်ဆိုပါစို့ အခင်းအကျင်း ကိန်း၏။ ၎င်းတွင်အနုတ်လက္ခဏာနှင့်အပေါင်းနှစ်မျိုးလုံးပါဝင်ပြီးပြstatementနာကြေညာချက်ကအနှုတ်နှင့်အပြုသဘောဆောင်သောအရာများအားလုံးကို array ၏ဘယ်ဘက်နှင့်အပိုနေရာများကိုမသုံးပဲအသီးသီးရွှေ့ပြောင်းရန်တောင်းဆိုသည်။ ၎င်းသည်အနုတ်လက္ခဏာနံပါတ်များကိုအစသို့ပြောင်းခြင်းနှင့်အပိုနေရာတစ်ခုနှင့်အဆုံးသတ်ခြင်းအတွက်အဖြေဖြစ်သည်။

နမူနာ

 input:

arr[]={2,4,-10,13,-7,-60,52,8,-19 }

output:

-10 -7 -60 -19 4 2 52 8 13

ရှင်းလင်းချက်: ကိန်းဂဏန်းအားလုံးကိုဘယ်ဘက်သို့ရွှေ့ပြီးအပေါင်းကိန်းသည်ညာဘက်သို့ရွှေ့သောကြောင့်ဖြစ်သည်။

အနှုတ်လက္ခဏာနံပါတ်များကိုအစသို့ပြောင်း။ Positive Extra Space ဖြင့်အဆုံးသတ်ပါမည်

algorithm

  1. 0 ကို j ကိုသတ်မှတ်ပါ။
  2. 0 မှ n အထိ array ကိုဖြတ်သန်းသွားခြင်း (n သည်ခင်းကျင်း၏အရှည်ဖြစ်သောသီးသန့်ဖြစ်သည်။ )
    1. Array တစ်ခုရဲ့ element က ၀ ထက်နည်းရင်စစ်ပါ။
      1. i သည် j နှင့်မတူပါကိုစစ်ဆေးပါ။
        1. arr [i] နှင့် arr [j] အညွှန်းကိန်းများ၏တန်ဖိုးများကိုလဲလှယ်ပြီး j ၏တန်ဖိုးကိုတိုးမြှင့်ပါ။
  3. ခင်းကျင်းပုံနှိပ်ပါ။

အပျက်သဘောဆောင်သောနံပါတ်များအားလုံးကိုအစသို့ပြောင်းခြင်းသို့ပို့ခြင်းအတွက်ရှင်းလင်းချက်

ကျွန်တော်တို့အားလုံးကိုကိန်းသေတစ်ခုပေးထားတယ်။ အပေါင်းနဲ့အနှုတ်လက္ခဏာပါ ၀ င်တယ်။ အနုတ်လက္ခဏာဆောင်သောအရာအားလုံးကိုဘယ်ဘက်သို့ပြောင်းရန်နှင့်အပြုသဘောဆောင်သောကိန်းဂဏန်းများကိုညာဘက်သို့ပြောင်းရန်ကျွန်ုပ်တို့တောင်းဆိုခဲ့သည် ဒီဟာကငါတို့သွားမယ် ကားဟောင်းများလဲလှယ်ရေး အပေါင်းနှင့်အနှုတ်လက္ခဏာများဖြစ်သောနံပါတ်များအားလုံး။ ပထမဆုံး array ကိုဖြတ်ပြီးအနှုတ်နံပါတ်များကိုစစ်ဆေးပါ။ အကယ်၍ ကိန်းသည်အနုတ်ဖြစ်ပါကတန်ဖိုးများကိုလဲလှယ်ရန်သာသွားပါမည်။

j ၏တန်ဖိုးကို 0 ထားပါ၊ ၎င်းကိုလဲလှယ်ရန်အခြားရွေးချယ်စရာတန်ဖိုးအတွက်အသုံးပြုလိမ့်မည်။ Array [0] သည် 0 ထက်နည်းပါကအစဉ်လိုက်နံပါတ်များကိုတွေ့ရှိခြင်းဖြစ်သည်။ ထို့ကြောင့်အညွှန်းနှစ်ခုလုံးသည်တူညီခြင်းရှိမရှိကိုစစ်ဆေးပါမည်။ အထက်ပါအခြေအနေအားလုံးသည်မှန်ကန်ပါက၊ သို့ဖြစ်လျှင်ကျွန်ုပ်တို့သည်နံပါတ်များကို arr [i] နှင့် arr [j] လဲလှယ်ပြီး j ၏တန်ဖိုးကိုပြောင်းလဲမည်။ ကျွန်ုပ်တို့သည်ဖြစ်နိုင်သမျှတန်ဖိုးများအားလုံးကိုဖြတ်သန်း။ လဲလှယ်ခြင်းနှင့်ပြန်လည်သတ်မှတ်ခြင်းများမပြုလုပ်မချင်းဖြတ်သန်းသွားသည်ကိုဆက်လက်ထိန်းသိမ်းထားမည်။

arr [i] သည်သုညထက်နည်းသောအခြေအနေကိုကျွန်ုပ်တို့စစ်ဆေးပြီးဖြစ်သည်။ ကျွန်ုပ်တို့သည်အနှုတ်နံပါတ်များကိုသာစီစဉ်ခြင်းကြောင့်၊ လဲလှယ်ပြီးသောနောက်အနုတ်လက္ခဏာနံပါတ်များကို array ၏ဘယ်ဘက်တွင်စီစဉ်ထားပြီး၊ အခြားအပြုသဘောဆောင်သောနံပါတ်များကိုညာဘက်သို့အလိုအလျောက်စီစဉ်ပေးလိမ့်မည်။ အဆိုပါခင်းကျင်း၏။ ကျွန်ုပ်တို့ပြီးသည်နှင့်လဲလှယ်ပြီးသောအခါလဲလှယ်ရေးလုပ်ငန်းများလုပ်ဆောင်သည့်ခင်းကျင်းမှုကိုသာပုံနှိပ်ရန်လိုအပ်သည်။

အကောင်အထည်ဖော်ရေး

အပျက်သဘောဆောင်သောနံပါတ်များအားလုံးကိုအစမှအဆုံးသို့ပြောင်းရန်ရွှေ့ပြောင်းရန်အတွက် C ++ အစီအစဉ်

#include<iostream>

using namespace std;

void shiftIntegers(int arr[], int n)
{
    int j = 0;
    for (int i = 0; i < n; i++)
    {
        if (arr[i] < 0)
        {
            if (i != j)
                swap(arr[i], arr[j]);
            j++;
        }
    }
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
}
int main()
{
    int arr[] = { 2,4,-10,13,-7,-60,52,8,-19 };
    int n = sizeof(arr) / sizeof(arr[0]);
    shiftIntegers(arr, n);

    return 0;
}
-10 -7 -60 -19 4 2 52 8 13

အနုတ်လက္ခဏာနံပါတ်များအားလုံးကိုစတင်ခြင်းနှင့်အဆုံးသို့ရွှေ့ပြောင်းခြင်းအတွက် Java program

class rearrangeNegativePositive
{
    public static void shiftIntegers(int arr[], int n)
    {
        int j = 0, temp;
        for (int i = 0; i < n; i++)
        {
            if (arr[i] < 0)
            {
                if (i != j)
                {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
                j++;
            }
        }
    }
    public static void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
    public static void main(String args[])
    {
        int arr[] = { 2,4,-10,13,-7,-60,52,8,-19 };
        int n = arr.length;

        shiftIntegers(arr, n);
        printArray(arr, n);
    }
}
-10 -7 -60 -19 4 2 52 8 13

အပျက်သဘောဆောင်သောနံပါတ်များအားလုံးကိုအစနှင့်အဆုံးသို့ပြောင်းရန်အတွက်ရှုပ်ထွေးမှုဆန်းစစ်ခြင်း

အချိန်ရှုပ်ထွေး

အို (ဎ) ဘယ်မှာ “ n” သည် array အတွင်းရှိ element အရေအတွက်ဖြစ်သည်။

အာကာသရှုပ်ထွေးမှု

အို (၁) အဘယ်သူမျှမပိုအာကာသလိုအပ်သည်အဖြစ်။

ကောက်ချက်

၎င်းသည်အနှုတ်လက္ခဏာနံပါတ်များကိုအစသို့ပြောင်းရန်အပြုသဘောဆောင်သောပရိုဂရမ်တစ်ခုဖြစ်ပြီး Java နှင့် C ++ တွင်အပိုနေရာများ ထပ်မံ၍ အဆုံးသတ်ပါမည်။

အညွှန်း