排序算法总结

--冒泡算法  （交换排序）
--每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

local table = {2,4,5,1,9,6,7,8,3}
for i=1,#table or {} do                  
    print(table[i])
end

function  BubbleSort( table)    
    for i=1,#table or {} do                  --对每一位数的操作
        for j=1,#table - i do                --对当前下标的数进行遍历比较
            if table[j] > table[j+1] then    --比较大小，交换位置
                local temp = table[j+1]
                table[j+1] = table[j]
                table[j] = temp
            end
        end
    end
end

--冒泡排序改进方法1
对冒泡排序常见的改进方法是加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换，
如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。

function BubbleSort1( table )
    local i = #table or 0
    local function mySort( ... )
        local  pos = 0                       --每趟开始时,无记录交换
        for j=1,i-1 do
            if table[j] > table[j+1] then    --比较大小，交换位置
                pos = j
                local temp = table[j+1]
                table[j+1] = table[j]
                table[j] = temp
            end
        end
        i = pos                              --为下一趟排序作准备
        if i > 0 then  
          mySort()
        end
    end
    mySort( )   
end

--冒泡排序改进方法2
2．传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,
我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

function BubbleSort2( table )
    local low  = 1
    local high = #table or 0
    local function mySort( ... )

        for j= low,high-1 do                --正向冒泡,找到最大者（去最大）
            if table[j] > table[j+1] then   
                local temp = table[j+1]
                table[j+1] = table[j]
                table[j] = temp
            end
        end
        high = high -1

        for j = high,low + 1,-1 do              --反向冒泡,找到最大者 （去最小）
            if table[j] < table[j-1] then   
                local temp = table[j]
                table[j] = table[j-1]
                table[j-1] = temp
            end
        end
        low = low + 1
        if high > low then  
          mySort()
        end
    end
    mySort( )   
end


---------------------------------------------------------------------------------------------------------------------

快速排序（交换排序）

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,
2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
3）此时基准元素在其排好序后的正确位置
4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

function quickSort( table,low,high)
   if high > low  then
       local keyIndex = partition(table,low,high )
       quickSort(table,low,keyIndex-1)
       quickSort(table,keyIndex+1,high)
   end
end

function partition( table,low,high )
    local  key = table[low]
    local  flow = low
    local  low = low
    local  high = high
    local keyIndex = Exchange(table,key,low,high,flow) --分割下标
    return keyIndex
end

function findSmallIndex( table,key,low,high)  --找出右边key值小的数 返回下标
    local high = high
    local low = low
    for i = high,low,-1 do
        if key > table[i] then
            return i
        end
    end
    return low
end

function findBigIndex( table,key,low,high)  --找出左边key值大的数 返回下标
    local high = high
    local low = low
    for i = low,high do
        if key < table[i] then
            return i
        end
    end
    return high
end

function Exchange(table,key,low,high,flow)  --以key分割数组  
    local flow = flow
    local high = high
    local low = low
    if high > low then
        local h = findSmallIndex(table,key,low,high)
        local l = findBigIndex(table,key,low,high)
        if h > l then
            local temp = table[h]
            table[h] = table[l]
            table[l] = temp
            Exchange(table,key,l+1,h-1,flow)
        end
    end
    if high <= low then
        if key > high then           --分割的最后一步 对key的处理
            local temp = table[high]
            table[high] = table[flow]
            table[flow] = temp
        end
        return high
    end
end
===========================================================================================
插入排序 --直接插入排序
将数据分为两部分，有序部分与无序部分，一开始有序部分包含第1个元素，依次将无序的元素插入到有序部分

function InsertSort(table)
    for i=2,#table or {} do
        if table[i] < table[i-1] then  --table[i] 以下的都是排好序的了，且table[i]是最大的
            local temp = table[i]
            InsertTemp(table,i-1,temp)
        end
    end
end

function InsertTemp(table , k ,temp) --找到插入的位置
    for j=k,1,-1 do
        if table[j] > temp then    --查找比temp小的位置 ，如果比temp大 则往后移一位
            table[j+1] = table[j]
            table[j] = temp
        else
            table[j+1] = temp
            return
        end
    end
 end

 ---------------------------------------------------------------------------------------------------------------------
 2. 插入排序—希尔排序（Shell`s Sort）
 先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，
 待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

 function ShellInsertSort( table,k )
    for i = k,#table do
        if table[i] < table[i+1-k]then
            local temp = table[i]
            table[i] = table[i+1-k]
            InsertTemp(table,i-1,temp)
        end
    end
    k = math.floor( k/2)
    if k >= 1 then
        ShellInsertSort(table,k)
    end
 end
 function InsertTemp(table , k ,temp) --找到插入的位置
    for j=k,1,-1 do
        if table[j] > temp then    --查找比temp小的位置 ，如果比temp大 则往后移一位
            table[j+1] = table[j]
            table[j] = temp
        else
            table[j+1] = temp
            return
        end
    end
 end

 ==================================================================================================================
 选择排序—简单选择排序
 在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；
 然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，
 直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止

 function selectSort(table)
    for i=1,#table do
        local index = SelectMinKey(table,i)
        if index~= i then
            local temp = table[i]
            table[i] = table[index]
            table[index] = temp
        end
    end
 end

 function SelectMinKey(table,i)
    for k = i+1,#table do
        if table[i] > table[k] then
            i = k
        end
    end
    return i
 end
 ------------------------------------------------------------------------------------------------------
 选择排序—堆排序

二叉堆是完全二叉树或者近似完全二叉树，满足两个特性
1.父结点的键值总是大于或等于(小于或等于)任何一个子节点的键值
2.每个结点的左子树和右子树都是一个二叉堆

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。
当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。一般二叉树简称为堆。

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），
调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，
这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。
依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

--输出堆顶 重新成堆
因此，实现堆排序需解决两个问题：
1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法：
1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），
   堆被破坏，其原因仅是根结点不满足堆的性质。
2）将根结点与左、右子树中较小元素的进行交换。
3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法 （2）.
4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法 （2）.
5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。


 function HeapSort( table )
    -- 初始堆
    BuildingHeap(table)           --先建堆（BuildingHeap）
    for i = #table,1,-1 do
        local temp = table[i]
        table[i] = table[1]
        table[1] = temp
        HeapAdjust(table,1,i-1) --输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。
    end
end

function BuildingHeap( table )
    --最后一个有孩子的节点的位置 index = math.math.floor((#table -1) / 2)  
    local index = math.floor((#table -1) / 2)  
    for i = index,1,-1 do
        HeapAdjust(table,i,#table)   --每一层的节点的排序
    end
end

--k 是待调整的数组元素的位置
--length 待调整的数组长度
function HeapAdjust( table , k ,length)
    for i= k,length do
        local temp = table[i]
        local child = i*2 --左子结点的位置    --child = 2 * i + 1  -- 右子结点的位置 = 2 * 父结点的位置 + 1
        if child > (length-1) then
            break
        end
        if child <=(length-1) and table[child] > table[child+1]then
            child = child + 1                        --找到最小的孩子与父节点对比    
        end
        if child <=(length-1) and table[child] < temp then
                table[i] = table[child]
                table[child] = temp
        end
    end 
end

--输出堆顶 重新成堆
因此，实现堆排序需解决两个问题：
1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

==============================================================================================