Learning path

Data Structures and Algorithms in Lua

Q: How do you build a stack and a queue from a Lua table?

A stack is the array part used from one end: table.insert(t, x) pushes and table.remove(t) pops. A queue needs more care, because table.remove(t, 1) shifts every remaining element down one place, so each dequeue is O(n). Keep two indices instead, first and last: add at last + 1, read at first, set that slot to nil and advance, and dequeueing becomes constant time. Step one has you build both.

Q: Why does #t sometimes give the wrong length in Lua?

Because # returns a border of the table: an index n where t[n] is not nil and t[n + 1] is. A proper sequence has exactly one border, its length; put a nil in the middle and there can be several, and # may return any of them. So never store nil in an array you measure with #, and in structures with gaps, such as a queue with two indices, track the size yourself.

Lua has one data structure, the table, so every structure on this path is one you make from it: a stack from its array part, a queue with two indices, a tree from tables that point at tables. This path has you build each one in Lua, then sort, recurse and search graphs with them, and finish on graded interview problems. Free, in your browser, with a certificate on most courses.

START LEARNING(it's free)

377 lessons228 challenges702 quiz questions

Beginner friendly
AI-assisted coding help
Hands-on interactive lessons
Audio narration on every lesson
Quizzes to test your knowledge
23 free certificates along the path

DSA in Lua, step by step

38 courses377 lessons228 challenges702 quiz questions

Each step is a set of existing Coddy courses, and every Start button opens them in Lua. The three courses not taught in Lua yet are listed after the steps.

1
Step 1
Data Structures Series, part one
Start this stepStartStack, queue, binary tree, hash table and linked list, each built from scratch in Lua and then used to solve problems. A Lua table already is a hash table, so this step shows what it does for you, and how to shape it into the other four.Start
5 courses, in order
66 lessons34 challenges
2
Step 2
Data Structures Series, part two
Start this stepStartDoubly linked list, heaps and priority queues, tries, graphs and the self-balancing AVL tree. In Lua a trie node is simply a table keyed by the next character, and a graph a table of neighbor lists, so each structure is only as complicated as its idea.Start
5 courses, in order
72 lessons42 challenges
3
Step 3
Sorting algorithms
Start this stepStartBubble, selection, insertion, merge, quick, heap, counting and radix sort, written in Lua and watched in the visualizer. table.sort is not stable, as the Lua reference manual states; after this step you know why a sort gives stability up, and how a tie-breaking index gets it back.Start
8 courses, in order
74 lessons31 challenges319 questions
4
Step 4
Recursive thinkingDedicated page
Start this stepStartRecursion challenges in Lua, which has proper tail calls: in a call in tail position, return f(x), the called function reuses the caller's stack entry, so a tail-recursive loop never grows the stack. Ordinary deep recursion still ends in a stack overflow. Dynamic programming and bit manipulation are listed after the steps, since they are taught in Python and C++.Start Dedicated page15 lessons15 challenges
5
Step 5
Graph algorithms
Start this stepStartBreadth-first and depth-first search, Dijkstra, Bellman-Ford, topological sort, Kruskal and Prim in Lua, on the graph you built in step two. Lua has no priority queue, so the heap from step two is the one Dijkstra needs, and breadth-first search needs a queue that never calls table.remove(t, 1).Start
7 courses, in order
63 lessons21 challenges383 questions
6
Step 6
Interview practice
Start this stepStartTen interview challenge packs and two coding-problem banks in Lua, graded by test cases: unfamiliar problems, solved without a tutorial, with tables shaped into whatever each problem needs.Start
12 courses, in order
87 lessons85 challenges

What you get

Everything you'll use to learn to code

Learn by Doing

Write real code, query databases, build websites, and master AI prompts. Our interactive lessons cover every skill modern developers need.

playground.js

Code Editor

1const greeting = "Hello, Coddy!"

2function sayHi(name) {

3 return greeting + " " + name

Test #1

Test #2

Test #3

Input

"Alex"

Output

"Hello, Coddy! Alex"

Build Your Coding Streak

Stay consistent and watch your progress grow! Track your daily coding habit, protect your streak with freeze days, and earn rewards for showing up every day.

12 days streak

Return tomorrow to keep your streak!

January 2026

Double or Nothing

Day 5 of 7

Streak Freeze

2 left

Code Anywhere, Anytime

Take your coding journey on the go! No setup, no downloads - just open and start coding. Available on iOS, Android and Web with 4.9 star ratings.

250

Variables

CONTINUE

4.9

Rating

You're Not Alone in This

Compete on global leaderboards, invite friends to earn rewards, and celebrate each other's wins. Coding is better with friends!

Challenger LeagueTop 7 advance

Alex7+ Days

2840

Jordan7+ Days

2650

Sam7+ Days

2420

Casey

2180

Morgan7+ Days

1950

Promotion zone

Every way to learn

Read, listen, test yourself, ask the AI, or look up anything you've already covered. Every lesson meets you where you are.

Intro to Variables

Audio

A variable is a named container that stores a value you can reference later in your program.

In Python, you create one by writing the name, an equals sign, then the value you want to store.

The value can change over time - reassigning the name simply points it to a new value.

1xSarah

Prove Your Skills

Earn certificates for every course you complete. Add them to your LinkedIn profile and resume to showcase your coding expertise to employers.

Certificate of Completion

This certifies thatJohn Doehas successfully completed

Python Fundamentals

DateJan 2026

Add to LinkedIn

Why learn DSA in Lua on Coddy

One structure, every structure. A Lua table is an array part and a hash part in one, and nothing else is built in: no list type, set, queue or heap. In Lua every structure is tables pointing at tables, which is the clearest view you will get of what a linked list or a tree really is.
For Roblox, games and plugins. Lua runs Roblox (as Luau), game scripting, Neovim configuration and Redis scripts, and game code is data-structure code: an inventory is a hash table, a turn order a queue, pathfinding a graph search. Learning the structures in Lua means learning them in the language you already script in.
Nearly the whole path in Lua. Every data structure, sort, graph algorithm, recursion challenge and interview pack is taught in Lua. Three are taught elsewhere and listed after the steps with a link to each: dynamic programming and the Python interview series in Python, and bit manipulation in C++. Everything that stays in Lua is made of tables, from the first stack to the last interview problem.
Graded like an interview. Every lesson ends in a Lua challenge checked by test cases, and when one fails, Bugsy reads your code and nudges you toward the fix without handing over the answer. A free certificate on most courses, each verifiable at its own URL.

Frequently asked questions about DSA in Lua

Is Lua good for data structures and algorithms?

For learning them, surprisingly good: with only tables to build from, every structure is explicit, and the code stays short. The catch is that tables forgive mistakes quietly: arrays start at 1 by convention, a missing key returns nil instead of an error, and the length operator #t is only reliable on a sequence without nil holes. Few interviews are held in Lua, so if one is your goal, the interview packs are also offered in the language you will use there.

How do you build a stack and a queue from a Lua table?

A stack is the array part used from one end: table.insert(t, x) pushes and table.remove(t) pops. A queue needs more care, because table.remove(t, 1) shifts every remaining element down one place, so each dequeue is O(n). Keep two indices instead, first and last: add at last + 1, read at first, set that slot to nil and advance, and dequeueing becomes constant time. Step one has you build both.

Why does `#t` sometimes give the wrong length in Lua?

Because # returns a border of the table: an index n where t[n] is not nil and t[n + 1] is. A proper sequence has exactly one border, its length; put a nil in the middle and there can be several, and # may return any of them. So never store nil in an array you measure with #, and in structures with gaps, such as a queue with two indices, track the size yourself.

Do data structures matter for Roblox scripting?

Yes, once a game grows past a handful of objects. An inventory is a hash table, a spawn or turn order is a queue, a list of cooldowns can be a priority queue, and finding a path across a map is a graph search. Luau, the language Roblox scripts are written in, is derived from Lua 5.1 and keeps its tables, 1-based arrays and # operator, so what you build here carries straight over.

Which courses on this path are not taught in Lua?

Three: dynamic programming and the Python interview series, taught in Python, and bit manipulation, taught in C++. They are listed after the steps, each with a link that opens it in its own language. A memo in Lua is a table; bitwise operators only arrived in Lua 5.3, which has C++'s &, |, << and >> and writes both XOR and NOT as ~.

Do I need to know Lua before starting this path?

Tables, functions, loops and local variables, at least; metatables help if you want structures that behave like objects. If those are new, Coddy's Lua course covers them first, free, and this path picks up where it ends.

Other learning paths

The same courses, arranged for a different role. Progress carries over: a course finished on one path counts on every path that includes it.

All learning paths

Coddy programming languages illustration

Start the Data Structures & Algorithms path for free

Start learning