You can sort a list of things using table.sort:

local list = {5, 3, 1, 2, 4}
table.sort(list)
print(list[1], list[2], list[3], list[4], list[5])
-- 1 2 3 4 5

This sorts by comparing elements using <. You can't compare parts using this, of course. That's why table.sort has an optional second parameter which is your own function to replace <:

function shorter(left, right)
    return left.Size.y < right.Size.y
end
table.sort(parts, shorter)

That will do what you want if parts is a list of parts.

Filtering for only parts

If model is a model that contains parts and some other objects, it would probably be best to filter the other objects out. You can either do that by constructing a new table:

local children = model:GetChildren()
local parts = {}
for _, child in pairs(children) do
    if child:IsA("BasePart") then
        table.insert(parts, child)
    end
end

or by removing non-part elements from the list:

local parts = model:GetChildren()
for i = #parts, 1, -1 do
    -- note that it doesn't work going forward
    -- (can you figure out why? There are questions on SH about this already)
    if not child:IsA("BasePart") then
        table.remove(parts, i)
    end
end

Implementing Sorting

It looks like you were trying to implement a sort yourself. In general, this is a bad idea, because it's going to be more confusing and slower than the built-in implementation. Still, it's a interesting problem that is taught in intro CS.

Here's a few ways to sort things¹, but just using < to compare (replace a < b with less(a, b) for custom comparisons)

Selection Sort

IDEA: First thing is smallest. Second thing is smallest (other than the smallest one). Third thing is smallest (other than the 2 smallest). Etc.

Performance: Very slow, always.

Copying implementation

local list = {5, 3, 1, 2, 4}
local sorted = {}
while #list > 0 do
    local mini = 1
    for i = 2, #list do
        if list[i] < list[mini] then
            mini = i
        end
    end
    table.insert(sorted, table.remove(list, mini))
end

In place implementation (Less memory, faster)

for i = 1, #list do
    local minj = i
    for j = i, #list do
        if list[j] < list[minj] then
            minj = j
        end
    end
    list[i], list[minj] = list[minj], list[i]
end

Bubble Sort

IDEA: Move bigger things up one step at a time.

Performance: Very slow, almost always. Sometimes very fast. No extra memory usage.

TODO

Merge Sort

IDEA: Be stupid, and unable to sort lists of more than 2 elements (which we can do because of <). Sort pieces of lists and put them together.

Performance: Fast, always. Requires a lot of extra memory.

Quicksort

IDEA: Pick an element. All the elements less than it can be sorted in their own pile. All the element more than it can be sorted in their own pile.

Performance: Fast, but only usually. No extra memory usage (needed).

Copying implementation -- wastes memory

function quicksort(list)
    from = from or 1
    to = to or #list
    local pivot = list[1] -- ideally this is near the median
    -- (median of medians or linear time median algorithm should be used)
    local less = {}
    local more = {}
    local same = {}
    for i = 1, #list do
        local el = list[i]
        if el < pivot then
            table.insert(less)
        elseif el > pivot then
            table.insert(more, el)
        else
            table.insert(same, el)
        end
    end
    local sorted = {}
    less = quicksort(less)
    for i = 1, #less do
        table.insert(sorted, less[i])
    end
    for i = 1, #same do
        table.insert(soted, same[i])
    end
    more = quicksort(more)
    for i = 1, #more do
        table.insert(sorted, more[i])
    end
    return sorted
end