A tömb 50 legnépszerűbb kérdése és válasza (2026)

By: Szerkesztőség Szerkesztőség
Hours korszerűsített

Készülsz egy Array interjúra? Ideje átgondolni, milyen kérdések érhetnek. A {{keyword}} megértése segít a jelölteknek hatékonyan feltárni az analitikus gondolkodást, a logikát és a problémamegoldó képességeket.

A tömbök a programozók technikai és szakmai tapasztalatának alapját képezik. A pályakezdőktől a tapasztalt szakemberekig, elsajátításuk erős technikai szakértelmet és az adatkezelésben szerzett alapszintű tapasztalatot bizonyít. A munkaadók nagyra értékelik ezeket a készségeket a kérdés-felelek során, helpping A jelöltek magabiztos elemzéssel és gyakorlati készségekkel teljesítik a közös, haladó vagy viva fordulókat.

Több mint 85 műszaki vezető, menedzser és szakember meglátásain alapuló gyűjtemény, amely az iparágak különböző perspektíváit öleli fel, biztosítva, hogy minden témakör tükrözze a hiteles felvételi elvárásokat és a valós kódolási értékelési szabványokat.

Interjúkérdések és válaszok Array-n

A legfontosabb Array interjúkérdések és válaszok

1) Magyarázd el, mi a tömb, és miben különbözik más adatszerkezetektől.

A tömb egy összefüggő memóriablokk, amely több, azonos adattípusú elemet tárol. Lehetővé teszi bármely elem konstans idejű elérését az indexe segítségével, így a véletlenszerű hozzáférés egyik leghatékonyabb struktúrája. A láncolt listákkal ellentétben a tömbök fix méretűek, és a mutatók tárolására nincs többletterhelés. A tömböket akkor részesítik előnyben, ha az elemek száma előre ismert, míg a dinamikus struktúrákat, például a listákat vagy a vektorokat, akkor használják, ha gyakori átméretezés várható.

Jellemző Sor Összekapcsolt lista
Memóriakiosztás határos Nem összefüggő
Hozzáférési idő O (1) O (n)
Beszúrás/törlés Drága Hatékony
Memory Overhead Alacsony Magas (mutatók)

👉 Ingyenes PDF letöltés: Array interjúkérdések és válaszok

2) Milyen típusú tömbök léteznek? Adjon példákat.

A tömböket méretük és felhasználásuk alapján kategorizálják. Az elsődleges típusok a következők:

  • Egydimenziós tömb: Az elemeket lineárisan tárolja, pl. int arr[5] = {1,2,3,4,5}.
  • Kétdimenziós tömb: Táblázatos adatokat ábrázol, pl. mátrixokat.
  • Többdimenziós tömb: Magasabb dimenziók, gyakran használják szimulációkban vagy képfeldolgozásban.
  • Dinamikus tömbök: Automatikus átméretezés elemek hozzáadásakor, pl. ArrayList in Java, vector in C++.
típus Szerkezet Példa
1D Lineáris [1, 2, 3]
2D Mátrix [[1, 2], [3, 4]]
Dinamikus Resizable std::vector<int>

3) Hogyan találjuk meg egy tömb legnagyobb és legkisebb elemét?

Ezt a problémát gyakran lineáris bejárással oldják meg. Két változót tartunk karban – egyet a minimumhoz és egyet a maximumhoz –, és frissítjük őket az iteráció során.

Algoritmus:

  1. inicializálása min és a max az első elemmel.
  2. Járjuk be a tömböt, és hasonlítsuk össze az egyes elemeket.
  3. Frissítések min or max Eszerint.

Példa (C++):

int arr[] = {5, 2, 9, 1, 7};
int min = arr[0], max = arr[0];
for (int i : arr) {
    if (i < min) min = i;
    if (i > max) max = i;
}

Idő összetettsége: On).

4) Mik a tömbök előnyei és hátrányai?

A tömbök nagy teljesítményt nyújtanak a véletlenszerű hozzáféréshez, de fix méretűek és költséges átméretezéssel rendelkeznek.

Aspect Előnyök Hátrányok
Teljesítmény Gyors indexelés (O(1)) Lassú beszúrás/törlés (O(n))
Memory design Kompakt tárolás Statikus méretallokáció
Implementáció Egyszerű szintaxis Határok nélküli ellenőrzés bizonyos nyelveken
Használja az ügyet Fix adathalmazokhoz alkalmas Nem hatékony a gyakori módosítások esetén

5) Írd le a statikus és a dinamikus tömbök közötti különbséget.

A statikus tömb fordítási időben meghatározott fix méretű, míg a dinamikus tömb futásidőben növekedhetnek vagy zsugorodhatnak. A statikus tömbök hatékonyak a memóriahasználatban, de merevek, míg a dinamikus tömbök rugalmasságot biztosítanak, de az átméretezés során csekély többletterheléssel járnak.

Jellemző Statikus tömb Dinamikus tömb
Méret Rögzített Változó
Memory design Stack Halom
Példa int arr[5]; std::vector<int>
átméretezése Nem támogatott Támogatott

Példa használati esetre:
Használjon statikus tömböket beágyazott rendszerekben, és dinamikus tömböket kiszámíthatatlan méretű gyűjteményekhez.

6) Hogyan lehet helyben megfordítani egy tömböt?

RevEgy tömb helyben történő létrehozása swap műveletet igényel.ping mindkét végéről az elemek a középpont felé haladnak.

Algoritmus:

  1. Két mutató inicializálása: start = 0 és a end = n - 1.
  2. Elemek cseréje arr[start] és a arr[end].
  3. Növekedés start és csökkentés end amíg nem találkoznak.

Példa (Python):

arr = [1, 2, 3, 4, 5]
arr.reverse()  # Built-in method
# or manually
arr = arr[::-1]

Idő összetettsége: On), Tér összetettsége: O(1).

7) Mi a különbség a szaggatott tömb és a többdimenziós tömb között?

A szaggatott tömb egy tömbökből álló tömb, ahol a belső tömbök különböző hosszúságúak lehetnek, míg a többdimenziós tömb egységes sor- és oszlopméretekkel rendelkezik.

Jellemző Jagged Array Többdimenziós tömb
Szerkezet Szabálytalan (beágyazott tömbök) Téglalap alakú (mátrix)
Memory design Nem összefüggő határos
Nélkül arr[i][j] arr[i][j]
Példa int[][] jagged = {{1,2}, {3,4,5}}; int[,] matrix = {{1,2}, {3,4}};

A szaggatott tömbök memóriahatékonyabbak, ha az adatok egyenetlenek.

Ne hagyd ki:

8) Hogyan találod meg a hiányzó számot egy 1-től n-ig terjedő tömbben?

Ez a feladat a természetes számok matematikai tulajdonságait használja ki.

1. megközelítés (összegképlet):
Az első összege n természetes számok = n*(n+1)/2.

alatttract a tömb elemeinek összege ebből az összegből.

2. megközelítés (XOR):
XOR műveletet alkalmaz az 1-től n-ig terjedő számú elemekre. A fennmaradó érték a hiányzó szám.

Példa:
Minden [1,2,4,5,6] (n=6):

Várható összeg = 21, Tényleges összeg = 18 → Hiányzó = 3.

Idő összetettsége: On), Tér összetettsége: O(1).

9) Milyen különböző módokon lehet eltávolítani a duplikátumokat egy tömbből?

A nyelvtől és a korlátozásoktól függően számos megközelítés létezik:

  • HashSet használata: Csak egyedi elemeket tárolj.
  • Rendezés használata: Rendezd a tömböt, és távolítsd el a szomszédos ismétlődéseket.
  • Frekvenciatérkép használata: Track darabszámú elem.

Példa (Java):

Set<Integer> unique = new HashSet<>(Arrays.asList(arr));
Megközelítés Time Hely
HashSet O (n) O (n)
osztályozás O (n log n) O (1)
Frekvencia O (n) O (n)

10) Hogyan találjuk meg egy tömb második legnagyobb elemét?

A második legnagyobb elemet egyetlen bejárással megtalálhatod, két változó megtartásával.

Algoritmus:

  1. inicializálása first és a second as INT_MIN.
  2. Járja be a tömböt.
  3. Frissítse mindkettőt, ha nagyobb értéket talál.

Példa (C++):

int first = INT_MIN, second = INT_MIN;
for (int x : arr) {
    if (x > first) {
        second = first;
        first = x;
    } else if (x > second && x < first) {
        second = x;
    }
}

Idő összetettsége: On), Tér összetettsége: O(1).

11) Hogyan lehet egy tömböt 'k' pozícióval elforgatni? Magyarázza el a különböző megközelítéseket.

A tömbforgatás ciklikusan eltolja az elemeket. Vannak három fő módszer hogy elérje azt:

  1. Ideiglenes tömb használata: Másold le az első k elemet, és fűzd hozzá őket a végéhez a többi eltolása után.
  2. <p></p> Reversal algoritmus: Reverse a tömb három része – első rész, második rész, majd a teljes tömb.
  3. Zsonglőr algoritmus használata: n és k legnagyobb közös konverziós halmazán alapul (hatékony O(n)-ben).

Példa (2-vel jobbra forgatás):

Input: [1,2,3,4,5]
Output: [4,5,1,2,3]
Módszer Time Hely Leírás
Ideiglenes tömb O (n) Rendben) Egyszerű és intuitív
Reversal O (n) O (1) Helyben elérhető és hatékony
Zsonglőrködés O (n) O (1) GCD ciklusokon alapul

12) Mi az az altömb, és miben különbözik az alsorozattól?

A altömb egy tömb egy összefüggő része, míg a részsorozat fenntartja a rendet, de kihagyhat elemeket.

Ingatlanok Altömb Alsorozat
határos Igen Nem
Megőrzött sorrend Igen Igen
Példa (az [1,2,3]-ból) [1,2] [1,3]

Példa:
Adott tömb [1,2,3], összes altömb = n*(n+1)/2 = 6.

Az alszekvenciák viszont 2ⁿ - 1 = 7 nem üres kombinációk.

13) Hogyan találjuk meg a maximális összegű altömböt?

Az Kadane algoritmusa a leghatékonyabb módja a maximális összegű, összefüggő részhalmaz megtalálásának.

Lépések:

  1. inicializálása max_current = max_global = arr[0].
  2. Iterálj végig az elemeken.
  3. Frissítések max_current = max(arr[i], arr[i] + max_current).
  4. Track a globális maximum.

Példa:
Bemenet: [-2,1,-3,4,-1,2,1,-5,4] → Kimenet: 6 (altömb [4,-1,2,1]).

Bonyolultság:
O(n) idő, O(1) tér.

14) Hogyan lehet két rendezett tömböt egyesíteni anélkül, hogy plusz helyet használnánk?

Két rendezett tömb egyesítése a helyén, az ötlet az, hogy mindkét tömb végétől hasonlítsuk össze.

Megközelítés:

  1. Kezdje mindkét tömb utolsó érvényes elemével.
  2. Hasonlítsd össze és helyezd a nagyobbat az egyesített tér végére.
  3. Ismételd addig, amíg az összes elem össze nem fonódik.

Példa (C++):

int i = m-1, j = n-1, k = m+n-1;
while (i >= 0 && j >= 0) {
    if (A[i] > B[j]) A[k--] = A[i--];
    else A[k--] = B[j--];
}

Idő összetettsége: O(m+n).

15) Milyen különböző módokon lehet egy tömb elemét keresni?

Módszer típus Idő komplexitás Használati példa
Lineáris keresés Rendezés nélkül O (n) Általános keresés
Bináris keresés Rendezés O (log n) Hatékony keresés
hashelés Rendezetlen O(1) átlag Nagy adathalmazok

Példa (Bináris keresés – Python):

def binary_search(arr, x):
    l, r = 0, len(arr)-1
    while l <= r:
        mid = (l+r)//2
        if arr[mid] == x: return mid
        elif arr[mid] < x: l = mid+1
        else: r = mid-1
    return -1

16) Magyarázd el a sekély másolás és a mély másolás közötti különbséget tömbökben.

A sekély másolat az eredeti elemekre való hivatkozásokat másolja, míg a mély másolat az összes adatot új memóriahelyekre másolja.

Másolás típusa Adatfüggetlenség Példa
Sekély Nem arr_copy = arr
Mély Igen arr_copy = arr[:] (Python)

Példa:
Egy sekély másolat módosítása tükröződik az eredeti tömbben; a mély másolaté nem.

17) Hogyan lehet duplikátumokat találni egy tömbben anélkül, hogy extra szóközt használnánk?

1. megközelítés (rendezés): Rendezd és ellenőrizd a szomszédos elemeket.

2. megközelítés (negálási módszer 1–n értékekre): A látogatott indexeket az adott indexnél lévő elem negálásával jelöljük.

3. megközelítés (Floyd-ciklus detektálása): Tekintsünk egy tömböt láncolt listaként, és keressük meg a ciklust (az [1..n] tartományban ismétlődő elemek esetén).

Példa:
Sor [3,1,3,4,2] → Másodpéldány = 3.

Idő: On), Hely: O(1).

18) Mik azok a ritka tömbök és milyen előnyeik vannak?

A ritka tömb többnyire nulla vagy alapértelmezett értékeket tartalmaz. Az összes elem tárolása helyett csak a nem nulla bejegyzéseket tároljuk indexeikkel együtt.

Előnyök:

  • Memóriát takarít meg.
  • Hatékony nagy adathalmazok, például mátrixok vagy dokumentumkifejezés-gyakoriságok esetén.
típus Példa Használja az ügyet
Sűrű tömb [0,1,0,2,3] Kis adatok
Ritka tömb {1:1, 3:2, 4:3} Nagyméretű, ritka adatok

Példa: Gépi tanulási modellekben használják (TF-IDF mátrixok).

19) Hogyan lehet hatékonyan megtalálni két tömb metszetét?

A metszéspontokat hasheléssel vagy rendezési technikákkal lehet megtalálni.

  • HashSet használata: Add össze az első tömb elemeit, majd ellenőrizd a második tagságát.
  • Két mutató használata: Rendezett tömbök esetén működik.

Példa (Python):

intersection = list(set(arr1) & set(arr2))

Bonyolultság:

  • HashSet: O(n)
  • Két mutató: O(n log n) a rendezés miatt.

20) Magyarázd el a sor-fő és oszlop-fő sorrend közötti különbséget tömbökben.

Ezek többdimenziós tömbökhöz használt memória-tárolási sorrendek.

Koncepció Sor-Major (C/)C++) Oszlop-Major (Fortran, MATLAB)
Tárolási sorrend Sorról sorra Oszlopról oszlopra
Címképlet Base + ((i * cols) + j) * size Base + ((j * rows) + i) * size
Előny Gyorsabb sorok bejárása Gyorsabb oszlopbejárás

Példa:
2D tömb esetén A[2][3], soros nagyobb üzletek [A[0][0], A[0][1], A[0][2], A[1][0], ...].

21) Mi az előtagösszegzési technika, és hogyan használják tömbökben?

Az előtag összeg A technika magában foglalja egy tömb kumulatív összegeinek előzetes kiszámítását a tartománylekérdezések hatékony megválaszolásához.

Koncepció:

prefix[i] = prefix[i-1] + arr[i]

Ezután az l-től r-ig terjedő elemek összegének kiszámításához használja a következőt:

sum(l, r) = prefix[r] - prefix[l-1]

Példa:

Tömb = [2, 3, 5, 7, 1]

Előtag = [2, 5, 10, 17, 18]

Összeg(2,4) = prefix[4] - prefix[1] = 15

Alkalmazások:
Altömbösszegző lekérdezésekben, kumulatív gyakorisági táblázatokban és versenyprogramozásban használatos.

Bonyolultság:
Előfeldolgozás: O(n), Lekérdezés: O(1)

22) Hogyan javítja a csúszóablakos technika a tömb teljesítményét?

Az elhúzható ablak A technikát a szomszédos szegmenseket (altömböket) tartalmazó problémák hatékony megoldására használják.

Ötlet: Ahelyett, hogy minden ablakra újraszámolná az összeget vagy a feltételt, frissítse az eredményt a következő elem hozzáadásával és az első eltávolításával.

Példa probléma:
Keresse meg a méret maximális összegű résztömbjét k.

Algoritmus:

  1. Számítsa ki az első összegét k elemek.
  2. Csúsztassa az ablakot elemenként.
  3. Adja hozzá az új elemet, távolítsa el az elsőt, és track a maximum.

Idő összetettsége: O(n) — sokkal gyorsabb, mint a naiv O(n×k) megközelítés.

Alkalmazások:
Olyan problémákban használják, mint a maximális átlagos résztömb, a leghosszabb részkarakterlánc vagy az első negatív szám minden ablakban.

23) Mi a különbség a tömb és a mutató között C nyelven?

Jellemző Sor Mutató
Meghatározás Hasonló adatelemek gyűjteménye Változó memóriacím tárolására
Memóriakiosztás határos Dinamikus vagy önkényes
Méret Rögzített Átméretezhető
Példa int a[5]; int *p;

Főbb különbség:
Egy tömbnév konstans mutatóként működik, de egy mutató dinamikusan bárhová mutathat.

Példa:

int arr[3] = {1,2,3};
int *ptr = arr;  // ptr points to first element

24) Hogyan lehet megtalálni az egyensúlyi indexet egy tömbben?

An egyensúlyi index olyan pozíció, ahol a bal oldali elemek összege megegyezik a jobb oldali elemek összegével.

Algoritmus:

  1. Számítsa ki a tömb teljes összegét.
  2. Bejárás és a bal oldali összeg megtartása.
  3. If (total_sum - left_sum - arr[i]) == left_sum, visszatérési index.

Példa:
Sor: [1, 3, 5, 2, 2] → Index = 2 (mivel bal oldali összeg = jobb oldali összeg = 4)

Bonyolultság: On), Hely: O (1)

25) Mik azok a ritka mátrixok, és hogyan tárolhatók hatékonyan?

A ritka mátrix többnyire nullákat tartalmaz. A memória megtakarítása érdekében csak a nem nulla elemeket és azok indexeit tárolja.

Tárolási módszerek:

  1. Koordináta lista (COO): Tárolja (sor, oszlop, érték).
  2. Tömörített ritka sor (CSR): Három tömb: values, col_index, row_pointer.
  3. Kulcsszótár (DOK): (Sor, oszlop) hash mapja → érték.
Módszer Memória hatékonyság Használati példa
TURBÉKOL Mérsékelt általános tárolás
CSR Magas Numerikus számítások
D.O.K. Rugalmas Dinamikus beszúrás

Széles körben használják gépi tanulás (TF-IDF, gráf szomszédsági mátrixok).

26) Hogyan lehet átrendezni egy tömböt úgy, hogy a páros és páratlan számok váltakozva szerepeljenek?

A cél a páros és páratlan számok összefonása, miközben megtartjuk azok relatív sorrendjét.

Algoritmus:

  1. Páros és páratlan tömbök szétválasztása.
  2. Felváltva egyesítsd őket, páros vagy páratlan számmal kezdve.
  3. Ha egy típus kifogy, illessze be a maradékot.

Példa:

Input: [3, 6, 12, 1, 5, 8]
Output: [6, 3, 12, 1, 8, 5]

Bonyolultság: O (n)

27) Magyarázd el a tömbforgatás és a tömbeltolás közötti különbséget.

OperaCIÓ Forgás ShiftING
Meghatározás Az elemek körkörösen mozognak Elemek mozognak, az üres helyek kitöltődnek (pl. 0-k)
Példa [1,2,3,4] → [3,4,1,2] [1,2,3,4] → [0,1,2,3]
Adatok elvesztek Nem Igen
Használat Ciklikus átrendeződések Várólista megvalósítások

Összefoglalva:
A forgás visszafordítható; az eltolódás jellemzően nem.

28) Hogyan találhatjuk meg a maximális szorzatú résztömböt?

Hasonló Kadane algoritmusához, de te track mind a maximális, mind a minimális szorzatok negatív értékek miatt.

Algoritmus:

  1. inicializálása max_ending_here = min_ending_here = arr[0].
  2. Iteráció és frissítés mindkettőben az aktuális elem alapján.
  3. Track max_so_far.

Példa:
Bemenet: [2,3,-2,4] → Kimenet: 6 (altömb [2,3])

Bonyolultság: On), Hely: O (1)

29) Hogyan lehet hatékonyan megszámolni az adott összegű résztömbök számát?

Megközelítés (előtagösszeg + hash map):

  1. Folyamatos összegzés fenntartása iteráció közben.
  2. Minden előtagösszeg esetében ellenőrizze, hogy (current_sum - target) létezik a hash map-en.
  3. Növelje a számlálót ennek megfelelően.

Példa:

arr = [10,2,-2,-20,10], target = -10
Output = 3 subarrays

Idő összetettsége: O (n)

Tér összetettsége: O (n)

30) Mi a bitmanipuláció tömbfeladatokban, és hol alkalmazzák?

Bitmanipuláció olyan műveletek végrehajtását foglalja magában, mint az ÉS, VAGY, XOR, és eltolódások a problémák hatékony megoldása érdekében.

Általános alkalmazások:

  • Egyetlen nem ismétlődő elem keresése XOR művelettel.
  • Részhalmaz létezésének ellenőrzése bitmaszkolás segítségével.
  • Halmazok ábrázolása bitvektorokként.

Példa:

Keresd meg azt az elemet, amelyik egyszer jelenik meg, míg mások kétszer:

int res = 0;
for (int num : arr) res ^= num;

Előnyök:

  • Állandó tér
  • Gyors logikai számítás

31) Hogyan lehet egy mátrixot spirális sorrendben bejárni?

A spirális bejárás az óramutató járásával megegyező irányban rétegről rétegre látogatja meg az összes mátrixelemet.

Algoritmus:

  1. Határozzon meg négy határt: top, bottom, leftés right.
  2. Balról jobbra, felülről alulra, jobbról balra és alulról felülre haladva.
  3. Minden egyes menet után zsugorítsd a határokat, amíg minden elem le nem fedett.

Példa:

Input:
1 2 3
4 5 6
7 8 9
Output: [1,2,3,6,9,8,7,4,5]

Bonyolultság:
Idő: O(n×m) | Hely: O(1)

32) Milyen különböző módokon lehet tömböket rendezni? Magyarázd el példákkal.

A rendezés egy adott sorrendbe rendezi az elemeket. Az algoritmus megválasztása a következőktől függ: adatméret, eloszlás és memóriakorlátok.

Algoritmus Legjobb eset Átlagos eset Stabil Hely
Bubble Rendezés O (n) O(n²) Igen O (1)
Egyesítés rendezés O (n log n) O (n log n) Igen O (n)
Gyors rendezés O (n log n) O(n²) Nem O (log n)
Halom rendezés O (n log n) O (n log n) Nem O (1)

Példa (Python Gyors rendezés):

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr)//2]
    return quicksort([x for x in arr if x < pivot]) + [x for x in arr if x == pivot] + quicksort([x for x in arr if x > pivot])

33) Magyarázza el a kétmutatós technikát tömbökben.

Az kétpontos technika két indexet használ egy adatstruktúra különböző végekről vagy sebességekről történő bejárására, optimalizálva az időt és a helyet.

Általános felhasználások:

  • Adott összegű párok detektálása rendezett tömbökben.
  • A duplikációk eltávolítása helyben.
  • Reversing tömbök.
  • Intervallumok egyesítése.

Példa (Párosítás Target Összeg):

arr = [1,2,3,4,6], target = 6
left, right = 0, len(arr)-1
while left < right:
    s = arr[left] + arr[right]
    if s == target: print(arr[left], arr[right])
    elif s < target: left += 1
    else: right -= 1

Bonyolultság: O (n)

34) Hogyan találhatjuk meg egy tömb többségi elemét?

A többségi elem többször jelenik meg, mint ⌊n/2⌋ alkalommal.

Boyer–Moore szavazási algoritmus megoldja ezt lineáris időben és konstans térben.

Algoritmus lépései:

  1. inicializálása candidate és a count = 0.
  2. Minden elemhez:
    • Ha a számláló = 0, akkor állítsa be candidate = element.
    • Növelés/csökkentés szám egyenlőség alapján.
  3. Igazolja a jelöltet.

Példa: [3,2,3] → Kimenet: 3

Bonyolultság: O (n)

35) Mi a különbség a bináris és az exponenciális keresés között?

Jellemző Bináris keresés Exponenciális keresés
Követelmény Rendezett tömb Rendezett tömb
Kulcs ötlet Ossza fel a tömböt felére Exponenciálisan keresd meg a tartományt a bináris keresés előtt
Bonyolultság O (log n) O (log n)
Használja az ügyet Ismert méret Ismeretlen vagy végtelen tömbök

Példa:
Nagy adathalmazok vagy nem korlátos tömbök (például lapozott API-k) esetén az exponenciális keresés hatékonyan találja meg a tartományt.

36) Hogyan találhatjuk meg egy tömb k-adik legkisebb vagy legnagyobb elemét?

Megközelít:

  1. Válogatás: Rendezés és hozzáférés k-1index (O(n log n)).
  2. Min/Max halom: Hatékony a gyakori lekérdezések esetén (O(n log k)).
  3. Gyorskiválasztás (Hoare algoritmusa): Átlagos O(n).

Példa (Python heapq használatával):

import heapq
arr = [3,2,1,5,6,4]
k = 2
print(heapq.nlargest(k, arr)[-1])  # 5

Felhasználási eset: Ranglisták, legjobban teljesítő mutatók, percentilis elemzés.

37) Hogyan találjuk meg a hiányzó és ismétlődő számot egy 1-től n-ig terjedő tömbben?

Adott egy 1-től n-ig terjedő számokat tartalmazó tömb, amelyből egy hiányzik és egy ismétlődik:

1. megközelítés (matematikai):
Használd a tényleges és a várható összeg közötti különbséget, valamint a négyzetösszeget.

2. megközelítés (XOR módszer):

  1. XOR műveletet alkalmazunk az összes tömbelemre és 1…n.
  2. Az eredmény XOR műveletet ad a hiányzó és ismétlődő számokra.
  3. Osztás a jobb szélső halmazbittel.

Bonyolultság: On), Hely: O (1)

Példa:

Input: [4,3,6,2,1,1]
Output: Missing = 5, Repeating = 1

38) Mik az inverziós számok egy tömbben, és hogyan kell kiszámítani őket?

An inverzió egy (i, j) pár, amelyre i < j és a arr[i] > arr[j].

Megközelítés:

  • Naiv: Ellenőrizzük az összes párt → O(n²).
  • Optimalizált (egyesítéses rendezés): Inverziók számlálása egyesítés közben → O(n log n).

Példa:

Input: [8, 4, 2, 1]
Inversions = 6 → (8,4), (8,2), (8,1), (4,2), (4,1), (2,1)

Használt mérési tömb rendellenessége és a rangsorolási rendszerek.

39) Hogyan lehet meghatározni két rendezett tömb mediánját?

Optimális megközelítés (bináris keresés):
Ossza fel mindkét tömböt úgy, hogy a bal felek ugyanannyi elemet tartalmazzanak, mint a jobb felek.

Algoritmus:

  1. Használjon bináris keresést kisebb tömbökön.
  2. Hasonlítsa össze a partícióhatárokat.
  3. A partícióértékek alapján adja vissza a mediánt.

Bonyolultság: O(log(perc(n, m)))

Példa:

A = [1,3], B = [2]
Median = 2.0

40) Milyen előnyei vannak a tömbök használatának a láncolt listákkal szemben?

Tényező Sor Összekapcsolt lista
Memory design határos Nem összefüggő
Hozzáférési idő O (1) O (n)
Beszúrás/törlés Drága Hatékony
Gyorsítótár helysége Kiváló szegény
Felső Egyik sem Extra mutatótárhely

Következtetés:
A tömbök optimálisak a véletlenszerű hozzáférést igénylő fix méretű adathalmazokhoz, míg a láncolt listák jobbak a dinamikus beszúráshoz és törléshez.

41) Hogyan lehet megtalálni egy kör alakú résztömb maximális összegét?

egy kör alakú tömb, az elemek a végén körbefutnak.

Megközelítés:

  1. Keresse meg a normális maximális résztömbösszeget a következővel: Kadane algoritmusa.
  2. Keresse meg a minimális résztömbösszeget.
  3. Az eredmény = max(normal_max, total_sum - min_subarray).

Él eset: Ha minden elem negatív, akkor a legnagyobb elemet adja vissza.

Példa:

Input: [5, -2, 3, 4]
Normal Max = 10, Circular Max = 12 → Output = 12

Bonyolultság: O (n)

42) Hogyan keresünk egy elemet egy elforgatott, rendezett tömbben?

Használat módosított bináris keresés a fordulópont megtalálásához és az összehasonlítások korrigálásához.

Algoritmus:

  1. Keresse meg a középső = (alacsony + magas) / 2 értéket.
  2. Ellenőrizze, hogy arr[mid] == target.
  3. Ha a bal oldal rendezett, → balra keres; egyébként jobbra.

Példa:

Input: [4,5,6,7,0,1,2], target = 0
Output: Index = 4

Idő összetettsége: O (log n)

43) Magyarázza el a „Maximális Összegű Növekvő Részsorozat” dinamikus programozási megközelítését.

A cél egy növekvő részsorozat maximális összegének megtalálása.

Algoritmus:

  1. inicializálása dp[i] = arr[i].
  2. Minden egyes i, ellenőrizze az előző elemeket j < i:
    • If arr[j] < arr[i], Akkor dp[i] = max(dp[i], arr[i] + dp[j]).
  3. Adja vissza a maximális értéket dp.

Példa:

Input: [1, 101, 2, 3, 100, 4, 5]
Output: 106 (1 + 2 + 3 + 100)

Idő: O(n²) | Hely: O (n)

44) Mi a „csapda”?ping Az esővíz problémája és hogyan lehet megoldani?

Ez a klasszikus tömbfeladat azt vizsgálja, hogy mennyi víz csapdába eshet a rudak között csapadék után.

Megközelítés (két mutató):

  1. inicializálása left, right, left_max, right_max.
  2. A mutatók befelé mozgatása, a csapdába esett víz frissítése = min(left_max, right_max) - height[i].

Példa:

Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6
Megközelítés Time Hely
Brute Force O(n²) O (1)
Dinamikus programozás O (n) O (n)
Két mutató O (n) O (1)

45) Hogyan találhatod meg a leghosszabb, nulla összegű résztömböt?

Algoritmus (Hash Map):

  1. Inicializáljon egy hash map-et az előtag-összegek tárolásához.
  2. Ha ugyanaz az előtagú összeg ismét megjelenik, akkor az indexek közötti altömb nulla összegű.

Példa:

Input: [15, -2, 2, -8, 1, 7, 10, 23]
Output: Length = 5 (Subarray [-2, 2, -8, 1, 7])

Bonyolultság: O (n)

46) Mi a különbség a többdimenziós tömbök sekély és mély lapítása között?

típus Meghatározás Példa
Sekély ellapítás Csak egy szintet lapít össze [[1,2],[3,[4]]] → [1,2,3,[4]]
Mély lapítás Teljesen kisimítja az összes beágyazott tömböt [[1,2],[3,[4]]] → [1,2,3,4]

Példa (Python):

import itertools
shallow = list(itertools.chain.from_iterable(arr))

Felhasználási eset: Hasznos az adattisztításban és a hierarchikus adatnormalizálásban.

47) Hogyan találjuk meg egy mátrix (2D-s tömb) egyensúlyi elemét?

An egyensúlyi elem egy mátrixban egy olyan elem, amelynek sor- és oszlopösszegek kiegyensúlyozottak.

Algoritmus:

  1. Sor- és oszlopösszegek előzetes kiszámítása.
  2. Minden elem esetében ellenőrizze, hogy row_sum[i] - arr[i][j] == col_sum[j] - arr[i][j].

Példa:

Mátrix:

Matrix:
2 7 5
3 1 1
4 6 8
Output: Element 1 at (1,1)

Bonyolultság: O(n²)

48) Hogyan lehet egy tömböt két egyenlő összegű részhalmazra bontani?

Ez egy részhalmaz-összeg probléma, megoldva a következővel: Dinamikus programozás.

Megközelítés:

  1. Számítsa ki a teljes összeget.
  2. Ha páratlan → hamis értéket ad vissza.
  3. Hozz létre DP táblát annak ellenőrzésére, hogy a részhalmaz rendelkezik-e sum/2 létezik.

Példa:

Input: [1,5,11,5]
Output: True (Subsets: [1,5,5] and [11])

Idő: O(n × összeg/2) | Hely: O(összeg/2)

49) Hogyan lehet egy mátrixot 90 fokkal az óramutató járásával megegyező irányba forgatni?

Algoritmus:

  1. Transzponáld a mátrixot.
  2. Reverse minden sor.

Példa:

Input:
1 2 3
4 5 6
7 8 9
Output:
7 4 1
8 5 2
9 6 3

Bonyolultság: O(n²), Helyben.

Használt képfeldolgozás és a adatvizualizációs transzformációk.

50) Melyek a tömbök leggyakoribb valós alkalmazásai?

A tömbök számos számítási és valós rendszer alapjai.

Alkalmazások:

  • Adatbázis indexelés: Rekordok tárolása és rendezése.
  • Gépi tanulás: Jellemzővektorok, mátrixok és tenzorok.
  • Képfeldolgozás: 2D és 3D pixeladatok.
  • Operating rendszerek: Memória és folyamatok ütemezése.
  • Hálózat: Csomagpufferelés és -útválasztás.
  • Játékok: Játékos állapota trackirály és rácsok.
Domén Tömb szerepkör
AI / ML Tenzor és mátrix reprezentáció
DBMS Indexelés és keresésoptimalizálás
Beágyazott rendszerek Valós idejű szenzoradatok
Cloud Computing Terheléselosztó tömbök

A tömbök biztosítják a gerinchálózat a hatékony adatszervezéshez, számításhoz és skálázhatósághoz.

🔍 A legfontosabb interjúkérdések valós forgatókönyvekkel és stratégiai válaszokkal

1) Mi a tömb, és miben különbözik más adatszerkezetektől?

Elvárások a jelölttől: Az interjúztató fel szeretné mérni a tömbökkel kapcsolatos alapvető ismereteidet, beleértve a céljukat, a szerkezetüket, és azt, hogy miben különböznek más adattípusoktól, például a láncolt listáktól vagy a hash mapektől.

Példa válaszra:
„Egy tömb elemek gyűjteménye, amelyeket összefüggő memóriahelyeken tárolunk, ahol minden elemhez egy index segítségével lehet hozzáférni. A láncolt listákkal ellentétben a tömbök állandó idejű (O(1)) hozzáférést biztosítanak az elemekhez, de a létrehozáskor meghatározott fix méretet igényelnek. Ezáltal hatékonnyá válnak az olvasási műveletekhez, de kevésbé rugalmasak a beszúrások és törlések során.”

2) Hogyan lehet hatékonyan megtalálni egy tömb legnagyobb és legkisebb elemeit?

Elvárások a jelölttől: Az interjúztató az algoritmikus gondolkodásodat és a teljesítmény optimalizálására való képességedet szeretné ellenőrizni.

Példa válaszra:
„Ahhoz, hogy hatékonyan megtaláljam egy tömb legnagyobb és legkisebb elemét is, egyszer végig kellene mennem a tömbön, tartsd meg…”ping track az aktuális maximum és minimum értékének. Ennek a megközelítésnek az időbeli komplexitása O(n) és a térbeli komplexitása O(1), ami optimális erre a problémára.”

3) Írd le, hogyan távolítanád el a duplikátumokat egy rendezetlen tömbből.

Elvárások a jelölttől: Az interjúztató fel szeretné mérni a tömbmanipulációval és az adatszerkezetekkel kapcsolatos ismereteidet, amelyek segíthetnek a feladat elvégzésében.

Példa válaszra:
„Egy hash halmazt használnék az egyedi elemek tárolására, miközben a tömbben végighaladnék. Ha egy elem már szerepel a halmazban, kihagynám; egyébként hozzáadnám. Ez a módszer biztosítja, hogy a duplikátumok hatékonyan eltávolításra kerüljenek O(n) időbonyolultsággal és O(n) térbonyolultsággal.”

4) El tudnád magyarázni, hogyan működik a tömbrendezés, és meg tudnád nevezni néhány gyakori algoritmust?

Elvárások a jelölttől: A kérdező elvárja a különböző rendezési algoritmusok és azok használati eseteinek ismeretét.

Példa válaszra:
„A tömbök szerinti rendezés különféle algoritmusokkal érhető el, például gyors rendezés, összevont rendezés és BubblRendezés. A gyors rendezés hatékony az O(n log n) komplexitású átlagos esetekben, míg az egyesített rendezés nagy adathalmazok esetén előnyösebb, stabil jellege miatt. BubblAz e rendezés, bár egyszerű, ritkán használatos az O(n²) teljesítménye miatt.

5) Mesélj egy olyan alkalomról, amikor optimalizáltál egy olyan programot, ami sokat használt tömböket.

Elvárások a jelölttől: Az interjúztató meg akarja érteni a problémamegoldó megközelítésedet és a teljesítményed javítására való képességedet.

Példa válaszra:
„Előző munkakörömben egy olyan adatfeldolgozó szkriptet optimalizáltam, amely több beágyazott cikluson alapult tömbök felett. A tömbszeletelés megvalósításával és a beépített vektorizált műveletek használatával közel 60 százalékkal csökkentettem a végrehajtási időt, ami jelentősen javította a rendszer válaszidejét.”

6) Hogyan kezelnéd a határon kívüli tömbindex hibát?

Elvárások a jelölttől: A kérdező azt ellenőrzi, hogy érted-e a hibakezelést és a biztonságos kódolási gyakorlatokat.

Példa válaszra:
„Biztosítanám, hogy minden indexhozzáférés validálva legyen a használat előtt, ellenőrizve, hogy a tömb hosszának tartományán belül vannak-e. Ezenkívül try-catch mechanizmusokat vagy azzal egyenértékű hibakezelési módszereket valósítanék meg a váratlan, határon kívüli hibák szabályos kezelésére.”

7) Hogyan lehet megfordítani egy tömböt további memória használata nélkül?

Elvárások a jelölttől: Az interjúztató értékelni szeretné az algoritmikus hatékonyságodat és a helyszíni műveletek megértését.

Példa válaszra:
„Két mutatót használnék: az egyiket a tömb elejéről, a másikat a végéről kezdeném. Swap művelettelping „az elemek ezen a pozíción vannak, és mindkét mutatót a középpont felé mozgatjuk, a tömb helyben megfordítható O(n) időbonyolultsággal és O(1) térbonyolultsággal.”

8) Írjon le egy olyan helyzetet, amelyben egy nagyméretű tömbadatkészletet kellett kezelnie. Hogyan biztosította a teljesítményt és a pontosságot?

Elvárások a jelölttől: Az interjúztató fel akarja mérni a valós adatkezelési és teljesítményoptimalizálási képességeidet.

Példa válaszra:
„Az előző munkahelyemen nagyméretű numerikus tömbökkel dolgoztam pénzügyi adatok elemzéséhez. A teljesítmény fenntartása érdekében hatékony memóriakezelési technikákat és kötegelt feldolgozást alkalmaztam. A NumPy tömböket is kihasználtam vektorizált műveletek végrehajtásához, ami javította mind a pontosságot, mind a végrehajtási sebességet.”

9) Milyen lépéseket tennél egy rendezett tömbben egy adott érték kereséséhez?

Elvárások a jelölttől: Az interjúztató elvárja, hogy ismerd a keresési algoritmusokat.

Példa válaszra:
„Rendezett tömb esetén a bináris keresési algoritmust használnám, amely ismételten felezi a keresési intervallumot. Ez a megközelítés az időbonyolultságot O(log n)-re csökkenti, így sokkal hatékonyabb, mint a nagy adathalmazok lineáris keresése.”

10) Milyen szerepet játszanak a tömbök a szoftverfejlesztés valós problémáinak megoldásában?

Elvárások a jelölttől: Az interjúztató szeretné megérteni, hogyan kapcsolod össze a műszaki ismereteidet a gyakorlati alkalmazásokkal.

Példa válaszra:
„A tömbök alapvető fontosságúak a szoftverfejlesztésben, mivel hatékony adattárolást és -keresést tesznek lehetővé. Például az előző munkakörömben tömböket használtam gyorsítótárazási mechanizmusok és adatrendezés megvalósításához az analitikai irányítópultokon. Ez javította az adatokhoz való hozzáférést és csökkentette a lekérdezések válaszidejét.”

Foglald össze ezt a bejegyzést a következőképpen: