Nisbi Sort Array Leetcode Həlli

Çətinlik səviyyəsi Asan
Tez-tez soruşulur Çiy kərpic Amazon DE Şou eBay google microsoft
alqoritmlər Geyim kodlaşdırma HashMap müsahibə müsahibə hazırlığı LeetCode LeetCodeSolutions çeşidləyiciBaxılıb 95

Sistem dizaynı ilə bağlı müsahibə sualları o qədər açıq ola bilər ki, düzgün hazırlaşmağı bilmək çox çətindir. İndi satın aldıqdan sonra Amazon, Microsoft və Adobe-nin dizayn dövrlərini sındıra bilirəm Bu kitabı. Gündəlik bir yenidən nəzərdən keçirin dizayn sualı və söz verirəm ki, dizayn dövrünü sındıra bilərsiniz.

Bu problemdə bizə ikisi verilir seriallar müsbət tam ədədi. İkinci sıra bütün elementləri fərqlidir və birinci massivdə mövcuddur. Bununla birlikdə, birinci massivdə təkrarlanan elementlər və ya ikinci massivdə olmayan elementlər ola bilər.

Birinci sıranı sıralamalı və elementlərinin nisbi sırasını ikinci massivdəki kimi saxlayaraq qaytarmalıyıq. İkinci massivdə olmayan elementlər massivin sonunda azalmayan bir şəkildə görünməlidir. Massivdəki elementlər 1000-dən çox olmayacaqdır.

misal

Array1 = {4 , 5 , 6 , 4 , 5 , 6 , 7 , 1 , 12 , 99}
Array2 = {5 , 6 , 12}
5 5 6 6 12 1 4 4 7 99

Izahat: İkinci massivdəki elementlərin sırası 5,6 və 12-dir. Beləliklə, nəticə massivində əvvəlcə görünürlər. Digər elementlər 1, 4, 4, 7 və 99-dur ki, azalmayan qaydada sıralanır.

Array1 = {5 , 4 , 3 , 2 , 1}
Array2 = {1 , 2 , 3 , 4 , 5}
1 2 3 4 5

Izahat: Birinci serialı yenə elə sıralayırıq ki, elementləri indi ikinci massivdəki kimi oxşar bir sırada olsun.

Yanaşma (Xüsusi Müqayisələndirici)

Hər hansı bir çeşidləmə metodundan istifadə etdikdə nisbi qaydalarına qərar vermək üçün bir sıra iki dəyəri arasında müqayisə aparırıq. Məsələn, baloncuk sıralamasında, iki kiçik elementi müqayisə etməyə davam edirik ki, daha kiçik element massivdə irəli aparılsın. "Kiçik" tərifi elementlərin böyüklüyündən və ya dəyərindən irəli gəlir. Ümumiyyətlə, '<' operatoru LHS dəyərinin olub olmadığını yoxlayır azdır RHS dəyəri. Proqramlaşdırma Dilləri bu operatorları dəyişdirməyə imkan verir çox yüklənmişdir arzuolunan yollarla. Burada istifadə edəcəyimiz budur. Sifariş verməyə qərar vermək üçün fərqli müqayisə metodlarından istifadə etdiyimiz bu cür proqramlaşdırma üsullarına xüsusi müqayisə deyilir və buna xüsusi müqayisələr istifadə edərək nail oluruq.

Sıralama funksiyasında elementləri istədiyimiz şəkildə müqayisə etməyimizə imkan yaradan başqa bir mübahisədən keçirik. Ümumi fəaliyyətini başa düşmək üçün aşağıdakı kodu yoxlayaq:

vector <int> a = {1 , 2 , 3 , 7 , 4};
sort(a.begin() , a.end() , [&](const int &first , const int &second){
    return first > second;
});

Yuxarıdakı kod parçasında müqayisəçi dəyərin olub olmadığını yoxlayır ilk dəyərdən əvvəl gəlməlidir ikinci bir tam sıra. Müqayisəçi qayıtmalıdır doğru istəsək ilk əvvəl gəlmək ikinci. Əks təqdirdə geri qayıdırıq saxta. Yuxarıdakı kod, serialı azalan sıraya görə sıraladığımız bir illüstrasiyadır. Eynilə, Java-da a Müqayisələndirici () Sinif, ona verilən iki arqumentin sırasına qərar verdi. -3, 1 və 0 qayıdaraq 1 tərəfli müqayisə aparır ilk mübahisə ikinci, qayıdır -1. Birinci arqument ikincidən böyükdürsə, geri qayıdır 1. 0, əks halda.

Alqoritm

  1. Bir hash xəritəsi başlatın mövqe <> ikinci sıradakı elementlərin indekslərini müvafiq indekslərə qarışdırmaq
  2. Birinci sıranı sıralayın, ancaq bir müqayisəçi funksiyanı keçərək (C ++ dilində lambda funksiyasından və ya Java-da müqayisəçi <> interfeysindən istifadə edərək)
  3. Müqayisələndirici iki dəyər üzərində işləyir ilk ikinci aşağıdakı kimi olmuşdur:
    1. If mövqe [birinci]mövqe [ikinci] mövcud deyil:
      1. Əvvəlcə daha kiçik elementin gəlməsini istəyirik, qayıdın ilk <ikinci
    2. If mövqe [birinci] mövcud deyil:
      1. Qayıdırıq saxta as ilk daha sonra serialda gəlməlidir
    3. If mövqe [ikinci] mövcud deyil:
      1. Qayıtmaq doğru
    4. Qayıtmaq mövqe [birinci] <mövqe [ikinci]
  4. Nəticəni çap edin

Nisbi Sort Array Leetcode həllinin tətbiqi

C ++ Proqramı

#include <bits/stdc++.h>
using namespace std;

vector<int> relativeSortArray(vector<int>& Array1 , vector<int>& Array2)
{
    unordered_map <int , int> position;

    for(int i = 0 ; i < Array2.size() ; i++)
        position[Array2[i]] = i;

    sort(Array1.begin() , Array1.end() , [&](const int &first , const int &second)
     {
         if(position.find(first) == position.end() && position.find(second) == position.end())
             return first < second;
         if(position.find(first) == position.end())
             return false;
         if(position.find(second) == position.end())
             return true;
         return position[first] < position[second];
     });

    return Array1;
}

int main()
{
    vector <int> a = {4 , 5 , 6 , 4 , 5 , 6 , 7 , 1 , 12 , 99} , b = {5 , 6 , 12};
    a = relativeSortArray(a , b);
    for(int &element : a)
        cout << element << " ";
    return 0;
}

Java Proqramı

import java.util.*;

class relative_sort
{
    public static void main(String args[])
    {
        int[] a = {4 , 5 , 6 , 4 , 5 , 6 , 7 , 1 , 12 , 99};
        int[] b = {5 , 6 , 12};
        a = relativeSortArray(a , b);
        for(int i = 0 ; i < a.length ; i++)
            System.out.print(a[i] + " ");
    }

    static int[] relativeSortArray(int[] Array1, int[] Array2) {
        Hashtable <Integer , Integer> position = new Hashtable<>();
        for(int i = 0 ; i < Array2.length ; i++)
            position.put(Array2[i] , i);

        Integer[] _Array1 = new Integer[Array1.length];
        for(int i = 0 ; i < _Array1.length ; i++)
            _Array1[i] = Array1[i];

        Arrays.sort(_Array1 , new Comparator<Integer>()
                    {
                        public int compare(Integer first , Integer second)
                        {
                            if(position.get(first) == null && position.get(second) == null)
                                return first - second;
                            if(position.get(first) == null)
                                return 1;
                            if(position.get(second) == null)
                                return -1;
                            return position.get(first) - position.get(second);
                        }
                    });

        for(int i = 0 ; i < Array1.length ; i++)
            Array1[i] = _Array1[i];
        return Array1;
    }
}
5 5 6 6 12 1 4 4 7 99

Nisbi Sort Array Leetcode Solüsyonunun Mürəkkəblik Analizi

Zamanın mürəkkəbliyi

O (maks (NlogN, M)) hara N = birinci massivin ölçüsü və M = ikinci sıra ölçüsü. O (M) vaxt aparan ikinci massivdə tək bir ötürmə aparırıq və müqayisənin daimi vaxtda həyata keçirildiyini fərz edərək O (NlogN) vaxt alan ilk massivi sıralayırıq.

Kosmik Mürəkkəblik

O (M) ikinci sıra elementlərinin indekslərini hash xəritəsində saxladığımız üçün.

Yanaşma (Sıralama sayma)

Array1 = {1, 2, 2, 2} və Array2 = {2, 1} qəbul edək. İkinci sıra keçməyə başlayın. Əvvəlcə 2 ədədi görürük. 3 2-nin olduğunu bilsəydik, bu dəyərləri 1 indeksindən başlayaraq Array0-də asanlıqla yazardıq. Sonra Array1-də tam 2 ədədi var. Yenə də tezliyini bilsəydik, ikiqatlıqdan sonra asanlıqla saxlayardıq. Bənzər bir şəkildə Array1-də bütün elementlərin frekanslarını saxlaya və Array2-də tək bir keçid işlədə bilərik, Array1-dəki elementləri tezliklərinə görə yenidən yaza bilərik.

Ancaq bundan sonra da Array1-də mövcud olan, Array2-də olmayan elementləri görməməzlikdən gəlirik. Beləliklə, bir az tezliyi qalan hər bir element üçün aşağı hüduddan yuxarı hüdudlara bir döngə aparırıq və Array1-ə yazırıq. Alt sərhəddən yuxarıya qalxdığımız üçün bu “əlavə” elementləri azalan qaydada sıralayırıq.

Alqoritm

  1. Bir sıra başladın: tezliyi ölçüdə 1000 Array1 və elementlərin tezliklərini saxlamaq idx Array1-də elementləri yenidən yazma mövqeyini bilmək.
  2. Hər element üçün Array2-də:
    • Isə tezlik [i]> 0:
      • Array1 [idx] = i təyin edin
      • idx ++
      • tezlik [i] -
  3. Hər element üçün i aralığında: [0, 4000]:
    • Isə tezlik [i]> 0:
      • Array1 [idx] = i təyin edin
      • idx ++
      • tezlik [i] -
  4. Nəticəni çap edin

Nisbi Sort Array Leetcode həllinin tətbiqi

C ++ Proqramı

#include <bits/stdc++.h>
using namespace std;

vector <int> relativeSortArray(vector <int> &Array1 , vector <int> &Array2)
{
    vector <int> frequency(1010 , 0);
    for(int &x : Array1)
        frequency[x]++;

    int idx = 0;

    for(int &i : Array2)
    {
        while(frequency[i] > 0)
            Array1[idx++] = i , frequency[i]--;
    }

    for(int i = 0 ; i < 1010 ; i++)
        while(frequency[i] > 0)
            Array1[idx++] = i , frequency[i]--;

    return Array1;
}

int main()
{
    vector <int> a = {4 , 5 , 6 , 4 , 5 , 6 , 7 , 1 , 12 , 99} , b = {5 , 6 , 12};
    a = relativeSortArray(a , b);
    for(int &element : a)
        cout << element << " ";
    return 0;
}

Java Proqramı

import java.util.*;

class relative_sort
{
    public static void main(String args[])
    {
        int[] a = {4 , 5 , 6 , 4 , 5 , 6 , 7 , 1 , 12 , 99};
        int[] b = {5 , 6 , 12};
        a = relativeSortArray(a , b);
        for(int i = 0 ; i < a.length ; i++)
            System.out.print(a[i] + " ");
    }

    static int[] relativeSortArray(int[] Array1 , int[] Array2)
    {
        int[] frequency = new int[1010];
        for(int i = 0 ; i < 1010 ; i++)
            frequency[i] = 0;

        for(int i = 0 ; i < Array1.length ; i++)
            frequency[Array1[i]]++;

        int idx = 0;

        for(int i = 0 ; i < Array2.length ; i++)
        {
            while(frequency[Array2[i]] > 0)
            {
                Array1[idx++] = Array2[i];
                frequency[Array2[i]]--;
            }
        }

        for(int i = 0 ; i < 1010 ; i++)
            while(frequency[i] > 0)
            {
                Array1[idx++] = i;
                frequency[i]--;
            }

        return Array1;
    }
}
5 5 6 6 12 1 4 4 7 99

Nisbi Sort Array Leetcode Solüsyonunun Mürəkkəblik Analizi

Zamanın mürəkkəbliyi

O (maks (N, M, 1000)) ilk sıra elementlərinin tezliyini O (N) vaxt alaraq bir hash xəritəsində saxladığımız üçün. Sonra ikinci massivdəki hər element üçün, tezlikləri 0-a çatana qədər onları birinci cərgədə yazmağa davam edirik. Nəhayət, sol elementi doldurmaq üçün [0, 4000] aralığındakı hər bir elementi yoxlayırıq.

Kosmik Mürəkkəblik

O (1) elementlərin tezliyini saxlamaq üçün bu vəziyyətdə O (1000) -ə bərabər olan daimi yerdən istifadə etdiyimiz üçün.

Crack Sistemi Dizayn Müsahibələri
Translate »