Lua - Shuffling Lists

Previous
Quiz
Next

In Lua, we can shuffle a linked list by first converting it to an array, shuffle the array and then rebuilding the list using the reshuffled array.

We're going to use Fisher-Yates Shuffle Algorithm for the same.

Fisher-Yates Shuffle Algorithm

The Fisher-Yates Shuffle algorithm shuffles a given finite sequence of elements by generating a random permutation where the possibility of every permutation occurring is nearly same. The algorithm is performed by storing the elements of the sequence in a sack and drawing each element randomly from the sack to form the shuffled sequence.

Coined after Ronald Fisher and Frank Yates, for designing the original method of the shuffle, the algorithm is unbiased. It generates all permutations in same conditions so the output achieved is nowhere influenced. However, the modern version of the Fisher-Yates Algorithm is more efficient than that of the original one.

For more details, you can refer to Fisher-Yates Shuffle Algorithm.

Following are the steps used to shuffle an array.

The algorithm to generate the random permutation is as follows−

  • Step 1− Write down all the elements in the finite sequence. Declare a separate list to store the output achieved.

  • Step 2− Choose an element i randomly in the input sequence and add it onto the output list. Mark the element i as visited.

  • Step 3− Repeat Step 2 until all the element in the finite sequence is visited and added onto the output list randomly.

  • Step 4− The output list generated after the process terminates is the random permutation generated.

Get an Array from the List

Iterate through each entry of the list and store each value into the array.

-- convert list to an array
function list:toArray()
   local array = {}

   local current = self.first

   while current do
      table.insert(array, current[1])
      current = current._next
   end

   return array
end

Shuffle the array using function with Fisher-Yates Algorithm

-- get array from the list
local arr = l:toArray()

-- randmoize seed
math.randomseed(os.time()) 

-- function to shuffle the array
function shuffle( array )
   local returnArray = {}
   -- loop over elements of array
   for i = #array, 1, -1 do
      -- get a random index
      local j = math.random(i)
      -- swap the elements of the array
      array[i], array[j] = array[j], array[i]
      -- insert the element in target array
      table.insert(returnArray, array[i])
   end

   -- return the target array
   return returnArray
end

-- shuffle the array
shuffledArray = shuffle(arr)

Rebuild the list using shuffled array

-- create a new list
l = list()

-- push the shuffled entries into the list
for _, v in ipairs(shuffledArray) do
   l:push({v})
end

Complete Example - Shuffling the linked List

In below example, we're sorting the linked list using above steps.

main.lua

-- List Implementation
list = {}
list.__index = list

setmetatable(list, { __call = function(_, ...)
   local t = setmetatable({ length = 0 }, list)
      for _, v in ipairs{...} 
         do t:push(v) 
      end
      return t
   end })

-- push an element to the end of the list
function list:push(t)
   -- move till last node    
   if self.last then
      self.last._next = t
      t._prev = self.last
      self.last = t
   else
      -- set the node as first node
      self.first = t
      self.last = t
   end
   -- increment the length of the list
   self.length = self.length + 1
end

-- iterate through the list
local function iterate(self, current)
   if not current then
      current = self.first
   elseif current then
      current = current._next
   end
  
   return current
end

function list:iterator()
   return iterate, self, nil
end

-- convert list to an array
function list:toArray()
   local array = {}
    
   local current = self.first

   while current do
      table.insert(array, current[1])
      current = current._next
   end
    
   return array
end

-- randmoize seed
math.randomseed(os.time()) 

-- function to shuffle the array
function shuffle( array )
   local returnArray = {}
   -- loop over elements of array
   for i = #array, 1, -1 do
      -- get a random index
      local j = math.random(i)
      -- swap the elements of the array
      array[i], array[j] = array[j], array[i]
      -- insert the element in target array
      table.insert(returnArray, array[i])
   end

   -- return the target array
   return returnArray
end

-- create a new list with values
local l = list({ "A" },{ "B" }, { "C" },{ "D" }, { "E" })

print("Original List")
-- iterate throgh entries
for v in l:iterator() do 
   print(v[1]) 
end

-- get array from the list
local arr = l:toArray()

-- shuffle the array
shuffledArray = shuffle(arr)

-- create a new list
l = list()

-- push the sorted entries into the list
for _, v in ipairs(arr) do
   l:push({v})
end

-- print the shuffled list
print("Shuffled List")
-- iterate throgh entries
for v in l:iterator() do 
   print(v[1]) 
end

Output

When we run the above code, we will get the following output−

Original List
A
B
C
D
E
Shuffled List
C
B
E
D
A
Print Page
Previous
Next
Advertisements