Lua Academy · Oppitunti

Taulukot listoina

Luokaa ja käsitelkää yksi-indeksoituja taulukoita table.insert- ja table.remove-funktioilla.

Oppitunti 1/412 vaihetta

Taulukot listoina on ilmainen Lua Academy-oppitunti CoddyKitissä. Tämä on oppitunti 1/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Lua Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Lua Academy-kurssilla on yhteensä 4 oppituntia.

Indeksointi alkaen yhdestä

Luan taulukot ovat taulukoita, joiden peräkkäiset kokonaislukuavaimet alkavat arvosta 1. Tämä eroaa useimmista kielistä, joissa aloitusindeksi on 0. Käytäntö on Luassa yleinen — kaikki standardikirjaston funktiot olettavat indeksoinnin alkavan yhdestä. Rajojen ulkopuolisen alkion käyttö palauttaa nil-arvon eikä aiheuta virhettä.

local colors = {"red", "green", "blue"}
print(colors[1])   -- red
print(colors[2])   -- green
print(colors[3])   -- blue
print(colors[0])   -- nil (no index 0)
print(#colors)     -- 3 (length operator)

table.insert ja table.remove

table.insert(t, val) lisää alkion loppuun. table.insert(t, pos, val) lisää alkion tiettyyn kohtaan ja siirtää muita alkioita oikealle. table.remove(t, pos) poistaa alkion kohdasta pos (oletuksena viimeisen), siirtää muita alkioita vasemmalle ja palauttaa poistetun arvon.

local stack = {}
table.insert(stack, "first")
table.insert(stack, "second")
table.insert(stack, "third")
print(#stack)          -- 3

table.insert(stack, 2, "inserted")
print(stack[2])        -- inserted

local removed = table.remove(stack, 1)
print(removed)         -- first
print(stack[1])        -- inserted

Pino taulukoilla

Lua-taulukko sopii täydellisesti pinoksi. Käyttäkää table.insert-funktiota alkion lisäämiseen ja table.remove-funktiota sen poistamiseen. Oletusarvoisesti molemmat toiminnot käsittelevät taulukon loppua, joten niiden jaksotettu aikavaativuus on O(1).

local stack = {}

-- Push
table.insert(stack, 10)
table.insert(stack, 20)
table.insert(stack, 30)

-- Pop
print(table.remove(stack))  -- 30
print(table.remove(stack))  -- 20
print(#stack)               -- 1

Jono taulukoilla

Jono (FIFO) voidaan toteuttaa taulukolla, mutta table.remove(t, 1) on O(n), koska se siirtää kaikki alkiot. Suorituskykyisissä jonoissa käyttäkää kahta osoitinta (alku- ja loppuindeksiä) siirtojen välttämiseksi.

local head, tail = 1, 0
local queue = {}

local function enqueue(v)
  tail = tail + 1
  queue[tail] = v
end

local function dequeue()
  if head > tail then return nil end
  local v = queue[head]
  queue[head] = nil
  head = head + 1
  return v
end

enqueue("a"); enqueue("b"); enqueue("c")
print(dequeue())  -- a
print(dequeue())  -- b

#-pituusoperaattori

#-operaattori palauttaa taulukon "rajan": indeksin i, jolla t[i] ~= nil ja t[i+1] == nil. Aukottomissa sarjoissa tämä vastaa taulukon pituutta. Jos keskellä on aukkoja (nil-arvoja), # tuottaa määrittelemättömiä tuloksia — käyttäkää table.pack-funktiota tai seuratkaa pituutta itse.

local t = {10, 20, 30, 40, 50}
print(#t)   -- 5

-- Safe for dense arrays
for i = #t, 1, -1 do
  io.write(t[i] .. " ")
end
print()  -- 50 40 30 20 10

Taulukoiden osien poimiminen

Luassa ei ole sisäänrakennettua slice-toimintoa, mutta voitte poimia alitaulukon käyttämällä table.move-funktiota (Lua 5.3+) tai itse kirjoitettua silmukkaa. table.move(a1, f, e, t, a2) kopioi alkiot alueelta a1[f..e] taulukkoon a2 alkaen kohdasta t.

local src = {10,20,30,40,50,60}

-- Manual slice
local function slice(t, from, to)
  local result = {}
  for i = from, to do
    result[#result+1] = t[i]
  end
  return result
end

local sub = slice(src, 2, 4)
print(sub[1], sub[2], sub[3])  -- 20  30  40

Taulukon kääntäminen

Kääntäkää taulukko paikallaan vaihtamalla alkioita molemmista päistä kohti keskikohtaa. Tämä on klassinen algoritmi, joka toimii kaikilla Lua-taulukoilla ilman lisämuistia.

local function reverse(t)
  local n = #t
  for i = 1, math.floor(n / 2) do
    t[i], t[n - i + 1] = t[n - i + 1], t[i]
  end
end

local arr = {1, 2, 3, 4, 5}
reverse(arr)
for _, v in ipairs(arr) do
  io.write(v .. " ")
end
print()  -- 5 4 3 2 1

Taulukoiden yhdistäminen

Yhdistääksenne kaksi taulukkoa yhdeksi käykää toinen taulukko silmukassa läpi ja lisätkää sen alkiot loppuun. table.move tekee tämän tehokkaasti Lua 5.3:ssa ja uudemmissa versioissa. Tuloksena on uusi taulukko, joka sisältää molempien taulukoiden kaikki alkiot järjestyksessä.

local function concat(a, b)
  local result = {}
  for _, v in ipairs(a) do result[#result+1] = v end
  for _, v in ipairs(b) do result[#result+1] = v end
  return result
end

local merged = concat({1,2,3}, {4,5,6})
for i, v in ipairs(merged) do
  io.write(v .. " ")
end
print()  -- 1 2 3 4 5 6

Sisäkkäisten taulukoiden litistäminen

Litistäkää sisäkkäinen taulukko rekursiivisesti: jos alkio on taulukko, käsitelkää se rekursiivisesti; muussa tapauksessa lisätkää se tulokseen. Tämä on luonteva tapa soveltaa rekursiivista taulukoiden läpikäyntiä.

local function flatten(t, result)
  result = result or {}
  for _, v in ipairs(t) do
    if type(v) == "table" then
      flatten(v, result)
    else
      result[#result+1] = v
    end
  end
  return result
end

local nested = {1, {2, 3}, {4, {5, 6}}, 7}
local flat = flatten(nested)
print(table.concat(flat, ", "))  -- 1, 2, 3, 4, 5, 6, 7

Taulukko joukkona

Voitte toteuttaa joukon käyttämällä taulukkoa, jossa arvot toimivat avaimina ja arvona on true. Jäsenyyden tarkistuksen aikavaativuus on O(1). Joukon muodostaminen taulukosta poistaa siitä kaksoiskappaleet. Muuntakaa joukko takaisin taulukoksi käymällä se läpi pairs-funktion avulla.

local function toSet(arr)
  local set = {}
  for _, v in ipairs(arr) do set[v] = true end
  return set
end

local nums = {3,1,4,1,5,9,2,6,5,3}
local set = toSet(nums)
local unique = {}
for k in pairs(set) do unique[#unique+1] = k end
table.sort(unique)
print(table.concat(unique, " "))  -- 1 2 3 4 5 6 9

Pikatarkistus

Mitä table.remove(t) tekee, kun sille annetaan vain yksi argumentti?

Vastaa interaktiivisessa oppitunnissa

Kertaus: taulukot taulukkoina

Yhteenveto:

Luan taulukot ovat 1-indeksoituja taulukoita
table.insert/table.remove push- ja pop-toimintoihin
#t antaa pituuden aukottomille sekvensseille
Pino: lisäys ja poisto lopusta (O(1))
Jono: käyttäkää alku- ja loppuosoittimia, jotta O(n)-siirrolta vältytään
Käyttäkää taulukkoa joukkona O(1)-jäsenyystarkistuksiin

Aloita maksutta

Opi Lua tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 40
Oppitunnit: 159

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Taulukot listoina” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Lua Academy-oppimispolun 3 oppituntia, myös oppitunnin “Taulukot listoina”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Lua Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Taulukot listoina”?

Luokaa ja käsitelkää yksi-indeksoituja taulukoita table.insert- ja table.remove-funktioilla. Harjoittelet Lua Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Lua Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Lua Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/4.

Kuinka kauan ”Taulukot listoina”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Lua Academy-oppitunnilla?

Kyllä. Jokainen Lua Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Lua Academy