Selection Sort is a simple and classic sorting algorithm that has been used for many years to teach the basics of sorting. The idea behind Selection Sort is easy to understand. The algorithm looks for the smallest value in a list, places it in the correct position, and then repeats the same process for the remaining values. Because of this clear step-by-step behavior, Selection Sort is very friendly for beginners who are just starting with algorithms.
In Lua programming, learning Selection Sort is useful because it helps you understand tables, loops, comparisons, and swapping values. Even though Selection Sort is not the fastest option for large data, it is still widely used in learning environments, small programs, and situations where clarity is more important than speed. Once you understand Selection Sort, moving on to more advanced sorting techniques becomes much easier.
Program 1: Basic Selection Sort Using Nested Loops
This program shows the most common and traditional way to implement Selection Sort in Lua. It uses two loops to find the smallest element and place it in the correct position.
local numbers = {64, 25, 12, 22, 11}
for i = 1, #numbers - 1 do
local minIndex = i
for j = i + 1, #numbers do
if numbers[j] < numbers[minIndex] then
minIndex = j
end
end
numbers[i], numbers[minIndex] = numbers[minIndex], numbers[i]
end
for i = 1, #numbers do
print(numbers[i])
endThis code works by selecting the smallest value from the unsorted part of the table and swapping it with the current position. Beginners can easily follow this logic because each step is clear and predictable. It is a great starting point for understanding how Selection Sort works internally.
Program 2: Selection Sort with Early Position Fixing
This program focuses on clearly separating the sorted and unsorted parts of the table. After each pass, one value is placed permanently in its correct position.
local numbers = {29, 10, 14, 37, 13}
for i = 1, #numbers - 1 do
local smallest = i
for j = i + 1, #numbers do
if numbers[j] < numbers[smallest] then
smallest = j
end
end
if smallest ~= i then
numbers[i], numbers[smallest] = numbers[smallest], numbers[i]
end
end
for i = 1, #numbers do
print(numbers[i])
endThe idea here is very similar to the basic version, but the code avoids unnecessary swaps. This teaches beginners how small improvements can make code cleaner. It also shows that the sorted portion grows from the beginning of the table.
Program 3: Selection Sort in Descending Order
Sometimes you want to sort values from largest to smallest instead of the usual order. This program shows how Selection Sort can be adjusted for that purpose.
local numbers = {5, 3, 8, 6, 2}
for i = 1, #numbers - 1 do
local maxIndex = i
for j = i + 1, #numbers do
if numbers[j] > numbers[maxIndex] then
maxIndex = j
end
end
numbers[i], numbers[maxIndex] = numbers[maxIndex], numbers[i]
end
for i = 1, #numbers do
print(numbers[i])
endInstead of looking for the smallest value, this version searches for the largest one. Beginners can see how changing a comparison sign completely changes the result. This approach is useful when ranking scores or arranging values in reverse order.
Program 4: Selection Sort Using While Loops
This program avoids using for loops and relies entirely on while loops. It shows that Selection Sort is about logic, not syntax.
local numbers = {20, 12, 10, 15, 2}
local i = 1
while i <= #numbers - 1 do
local minIndex = i
local j = i + 1
while j <= #numbers do
if numbers[j] < numbers[minIndex] then
minIndex = j
end
j = j + 1
end
numbers[i], numbers[minIndex] = numbers[minIndex], numbers[i]
i = i + 1
end
for k = 1, #numbers do
print(numbers[k])
endThis version is helpful for beginners who want to practice loop control more deeply. It reinforces the idea that algorithms can be written in many styles while still solving the same problem.
Program 5: Recursive Selection Sort in Lua
This program uses recursion instead of loops to perform Selection Sort. It is a bit more advanced but still useful for learning.
local numbers = {4, 3, 5, 1, 2}
local function selectionSort(arr, start)
if start >= #arr then
return
end
local minIndex = start
for i = start + 1, #arr do
if arr[i] < arr[minIndex] then
minIndex = i
end
end
arr[start], arr[minIndex] = arr[minIndex], arr[start]
selectionSort(arr, start + 1)
end
selectionSort(numbers, 1)
for i = 1, #numbers do
print(numbers[i])
endThis recursive approach breaks the problem into smaller parts. Each function call places one value in the correct position. Beginners can use this to understand how recursion works in Lua and how problems can be solved step by step.
Program 6: Selection Sort for String Values
Selection Sort can also be used to sort text data like words. This program sorts strings alphabetically.
local words = {"lua", "java", "python", "c", "ruby"}
for i = 1, #words - 1 do
local minIndex = i
for j = i + 1, #words do
if words[j] < words[minIndex] then
minIndex = j
end
end
words[i], words[minIndex] = words[minIndex], words[i]
end
for i = 1, #words do
print(words[i])
endLua can compare strings directly, so no extra work is needed. This example helps beginners see that the same Selection Sort logic works for different types of data, not just numbers.
Program 7: Selection Sort with Step-by-Step Output
This program prints the table after each main pass so you can see how Selection Sort progresses.
local numbers = {9, 7, 5, 3, 1}
for i = 1, #numbers - 1 do
local minIndex = i
for j = i + 1, #numbers do
if numbers[j] < numbers[minIndex] then
minIndex = j
end
end
numbers[i], numbers[minIndex] = numbers[minIndex], numbers[i]
for k = 1, #numbers do
io.write(numbers[k] .. " ")
end
print()
endWatching the values move after each pass makes learning easier. This traditional teaching style helps beginners clearly understand how the smallest value is selected and placed correctly every time.
Program 8: Selection Sort Inside a Reusable Function
This version places Selection Sort inside a function so it can be reused in different programs.
local function selectionSort(arr)
for i = 1, #arr - 1 do
local minIndex = i
for j = i + 1, #arr do
if arr[j] < arr[minIndex] then
minIndex = j
end
end
arr[i], arr[minIndex] = arr[minIndex], arr[i]
end
end
local numbers = {6, 4, 9, 1, 3}
selectionSort(numbers)
for i = 1, #numbers do
print(numbers[i])
endThis approach teaches good coding habits. Beginners learn how to separate logic from data and reuse code easily. This is very helpful when writing clean and maintainable Lua programs.
Program 9: Selection Sort with Negative and Floating Point Numbers
Selection Sort naturally supports negative and floating point numbers. This program clearly demonstrates that behavior.
local numbers = {3.2, -1.5, 4.8, 0, -6.3}
for i = 1, #numbers - 1 do
local minIndex = i
for j = i + 1, #numbers do
if numbers[j] < numbers[minIndex] then
minIndex = j
end
end
numbers[i], numbers[minIndex] = numbers[minIndex], numbers[i]
end
for i = 1, #numbers do
print(numbers[i])
endLua compares numbers naturally, so Selection Sort works without extra changes. This reassures beginners that the algorithm can handle real-world numeric data, including decimals and negative values.
Frequently Asked Questions (FAQ)
This section answers common beginner questions about Selection Sort in Lua.
Q1. Is Selection Sort faster than Bubble Sort?
Selection Sort usually performs fewer swaps than Bubble Sort, but both are slow for large data. They are mainly used for learning.
Q2. Does Lua provide a built-in sorting function?
Yes, Lua has table.sort, but implementing Selection Sort helps you understand how sorting works internally.
Q3. Can Selection Sort handle duplicate values?
Yes, duplicate values are sorted correctly and stay grouped together.
Q4. Where is Selection Sort used in real life?
Selection Sort is mostly used in education, small tools, and situations where simple and predictable behavior is preferred.
Conclusion
Selection Sort is a simple and reliable sorting algorithm that is perfect for beginners learning Lua. In this article, you explored many Lua programs that implement Selection Sort using loops, recursion, functions, and different data types. You also saw how it works with numbers, strings, negative values, and floating point data.
The best way to understand Selection Sort is to practice writing it yourself and experimenting with the code. Try changing the data, sorting in reverse order, or printing extra steps. With regular practice, your confidence in Lua programming and algorithms will grow steadily.
