סאָרט Array By Parity II Leetcode סאַלושאַן


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַמאַזאָן
מענגע סאָרטינג

פּראָבלעם דערקלערונג

אין דעם פּראָבלעם, "סאָרט עריי דורך פּאַריטעט II, "מיר באַקומען אַ פּאַריטעט מענגע ווו אַלע עלעמענטן זענען positive ינטאַדזשערז. די מענגע כּולל אַן אפילו נומער פון עלעמענטן. די מענגע כּולל אַן גלייַך נומער פון גלייך און מאָדנע עלעמענטן.

אונדזער אַרבעט איז צו ריעריינדזש די עלעמענטן פון די מענגע אין אַזאַ אַ וועג אַז פּאַריטעט [איך] כּולל אַן גלייך עלעמענט ווען איך איז אפילו אַנדערש פּאַריטעט [איך] זאָל אַנטהאַלטן אַן מאָדנע עלעמענט און צוריקקומען די נייַע מענגע.

בייַשפּיל

parity=[1,2,3,4]
[2,1,4,3]

דערקלערונג:  אַלע די מעגלעך מענגע וואָס באַפרידיקן די צושטאַנד זענען: [2,1,4,3], [2,3,4,1], [4,1,2,3], [4,3,2,1]. ווער עס יז פון די מענגע איז ריכטיק ענטפֿערן.

צוגאַנג פֿאַר סאָרט עריי דורך פּאַריטעט וו Leetcode סאַלושאַן

דער ערשטער און יקערדיק צוגאַנג צו דעם פּראָבלעם איז צו שאַפֿן אַ נייַע מענגע און אַריבער די אַלט מענגע. ווען מיר טרעפן אַן גלייך עלעמענט, שטעלן עס אין די גלייך שטעלע פון ​​די נייַע מענגע און ווען מיר טרעפן אַן מאָדנע עלעמענט, שטעלן עס אין די מאָדנע שטעלע פון ​​די נייַע מענגע. דער צוגאַנג ניצט עקסטרע פּלאַץ און מיר קענען פֿאַרבעסערן אונדזער לאָגיק מיט אַ אָרט ריעריינדזשמאַנט.

סאָרט Array By Parity II Leetcode סאַלושאַן

דער געדאַנק איז אַז אויב מיר שטעלן אַלע די גלייך עלעמענטן אין אַ גלייך שטעלע, די מאָדנע עלעמענטן וועלן ווערן אויטאָמאַטיש אין אַ מאָדנע שטעלע. אַזוי מיר נאָר דאַרפֿן צו פאָקוס אויף ווי אַזוי צו שטעלן אפילו עלעמענטן אין גלייך שטעלע. מיר וועלן נאָכפאָלגן די סטעפּס:

  1. יניטיאַליזירן די וועריאַבלע i מיט 0 און j מיט 1. דאָ איך וועט אַרומפאָרן נאָר אפילו די פּאָזיציע, אַזוי מיר וועלן ינקרימענט זייַן ווערט מיט 2 יעדער מאָל און j וועט אַרומפאָרן בלויז מאָדנע שטעלע, אַזוי מיר ינקרימאַנז די ווערט פון 2 יעדער מאָל.
  2. אויב פּאַריטעט [i] איז מאָדנע, מיר וועלן געפֿינען aj פֿאַר וואָס פּאַריטעט [j] איז גלייך און מיר וועלן וועקסל עלעמענטן ביי i און j.
  3. מיר וועלן טאָן די סטעפּס ביז די ווערט פון i איז קלענערער ווי די לענג פון די פּאַריטעט מענגע.
  4. צוריקקומען די פּאַריטעט מענגע.

ימפּלעמענטאַטיאָן

C ++ קאָד פֿאַר סאָרט עריי דורך פּאַריטעט וו

#include <bits/stdc++.h> 
using namespace std; 
    vector<int> sortArrayByParityII(vector<int>& A) {
        int n =A.size();
        int j=1;
         for (int i = 0; i < n; i += 2)
            if (A[i] % 2 == 1) {
                while (A[j] % 2 == 1)
                    j += 2;
                swap(A[i],A[j]); 
            }

        return A;
    }
int main() 
{ 
 vector<int> arr = {1,2,3,4}; 
  vector<int>ans=sortArrayByParityII(arr); 
 for(int i=0;i<arr.size();i++)
 cout<<ans[i]<<" ";
 cout<<endl;
 return 0;
}
[2,1,4,3]

Java קאָד פֿאַר סאָרט עריי דורך פּאַריטעט וו

import java.util.Arrays; 
public class Tutorialcup {
    public static int[] sortArrayByParityII(int[] A) {
        int n =A.length;
        int j=1;
         for (int i = 0; i < n; i += 2)
            if (A[i] % 2 == 1) {
                while (A[j] % 2 == 1)
                    j += 2;
               swap(A, i, j);
                }

        return A;
    }
     private static void swap(int[] A, int i, int j) {
        int temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }
  public static void main(String[] args) {
        int [] arr = {1,2,3,4}; 
        int[]ans=sortArrayByParityII(arr); 
        System.out.println(Arrays.toString(ans));
  }
}
[2,1,4,3]

קאַמפּלעקסיטי אַנאַליסיס פון סאָרט עריי דורך פּאַריטעט וו Leetcode סאַלושאַן

צייט קאַמפּלעקסיטי

די צייט קאַמפּלעקסיטי פון די אויבן קאָד איז אָ (N) ווייַל מיר נאָר דורכפאָר די פּאַריטעט מענגע. דאָ n איז די לענג פון די פּאַריטעט מענגע.

אָרט קאַמפּלעקסיטי

די פּלאַץ קאַמפּלעקסיטי פון די אויבן קאָד איז אָ (1) ווייַל מיר נוצן בלויז אַ בייַטעוודיק צו קראָם ענטפֿערס.

רעפֿערענצן