lua各种排序算法

--
--获取系统时间，计算代码执行所花费的时间
--以下代码经过vs2013验证
--socket.gettime()获取的正是时间戳，精确度很高，单位是秒。小数点后面还有很多位，可以通过乘以1000这样的换算，得到微秒（ms）。
--
local socket = require "socket"
local sort = class("sort")

--local start_time = socket.gettime()
--local end_time= socket.gettime()
--local use_time = (end_time - start_time )*1000
--print("start_time: "..start_time .."ms \n")
--print("end_time: "..end_time .."ms \n")
--print("used time: "..use_time .."ms \n")


function sort:init()

    self:init_choose( 7 )

    local yyy = 1
end

function sort:init_choose(iType)
    local cardData = {0x04,0x12,0x07,0x22,0x06,0x43,0x33,0x18,0x09,0x34,0x29}

    local start_time = socket.gettime()
    for i=1, 10000 do       
        cardData = {0x04,0x12,0x07,0x22,0x06,0x43,0x33,0x18,0x09,0x34,0x29}
        if iType == 0 then
            self:test(cardData)              -- 1万次11个数字累加耗时 0.326s     /  1万次11个数字空循环耗时 0.1446s    
        elseif iType == 1 then
            self:mao_pao(cardData)           -- 1万次11个数字冒泡排序耗时 1.66s
        elseif iType == 2 then
            self:xuan_zhe(cardData)          -- 1万次11个数字选择排序耗时 1.88s
        elseif iType == 3 then
            self:cha_ru(cardData)            -- 1万次11个数字插入排序耗时 1.20s
        elseif iType == 4 then
            self:xi_er(cardData)             -- 1万次11个数字希尔排序耗时 1.92s
        elseif iType == 5 then
            self:gui_bing(cardData)          -- 1万次11个数字归并排序耗时 6.095s
        elseif iType == 6 then
            self:quick_sort(cardData, 1, #cardData)     ---- 1万次11个数字快速排序耗时 2.409s
        elseif iType == 7 then
            self:dui_sort(cardData)          -- 1万次11个数字堆排序耗时 
        elseif iType == 8 then

        elseif iType == 9 then

        elseif iType == 10 then

        end
    end
    local end_time = socket.gettime()
    local use_time = end_time - start_time

    local xxx = 1
end

--for循环时间开销
function sort:test( cardData )
    if cardData == nil then return  end
    local cardCount = #cardData
    if cardCount == 0 then return cardData end

    local temp = 0
    for i=1, cardCount do
--        temp = temp + i
    end

    return cardData
end

--冒泡排序
function sort:mao_pao( cardData )
    if cardData == nil then return  end
    local cardCount = #cardData
    if cardCount == 0 then return cardData end

    for i=1, cardCount do
        for j=1, cardCount  - i do
            if cardData[j+1] < cardData[j] then
                local temp = cardData[j+1]
                cardData[j+1] = cardData[j]
                cardData[j] = temp
            end
        end
    end
    return cardData
end

--选择排序
function sort:xuan_zhe( cardData )
    if cardData == nil then return  end
    local cardCount = #cardData
    if cardCount == 0 then return cardData end

    for i=1, cardCount do
        local minIndex = i
        for j=i, cardCount do
            if cardData[j] < cardData[minIndex] then    --找到最小的数
                minIndex = j        --将最小数的索引保存
            end
        end
        local temp = cardData[minIndex]
        cardData[minIndex] = cardData[i]
        cardData[i] = temp
    end
    return cardData
end

--插入排序
function sort:cha_ru( cardData )
    if cardData == nil then return  end
    local cardCount = #cardData
    if cardCount == 0 then return cardData end

    local current = 1
    for i=1, cardCount-1 do
        current = cardData[i+1]
        local preIndex = i
        while(preIndex >= 1 and current < cardData[preIndex])
        do
            cardData[preIndex+1] = cardData[preIndex]
            preIndex = preIndex - 1
        end
        cardData[preIndex+1] = current
    end
    return cardData
end

--希尔排序
function sort:xi_er( cardData )
    if cardData == nil then return  end
    local cardCount = #cardData
    if cardCount == 0 then return cardData end

    local temp = 1
    local gap = math.floor(cardCount/2)
    while (gap > 0)
    do
        for i = gap, cardCount do
            temp = cardData[i]
            local preIndex = i - gap
            while(preIndex >= 1 and cardData[preIndex] > temp)
            do
                cardData[preIndex + gap] = cardData[preIndex]
                preIndex = preIndex - gap
            end
            cardData[preIndex + gap] = temp
        end
        gap = math.floor(gap/2)
    end
    return cardData
end

--归并排序
function sort:gui_bing( cardData )
    if cardData == nil then return  end
    local cardCount = #cardData
    if cardCount == 0 then return cardData end

    if cardCount < 2 then return cardData end
    local temp = {}
    self:gui_bing_sort( cardData,1,cardCount, temp )

end
function sort:gui_bing_sort( arr,left,right, temp )
    if left < right then
        local mid = math.floor((left+right)/2)
        self:gui_bing_sort(arr,left,mid,temp)
        self:gui_bing_sort(arr,mid+1,right,temp)
        self:gui_bing_merge(arr, left,mid, right, temp)
    end
end
function sort:gui_bing_merge( arr, left, mid, right, temp )
    local i = left      --左序列指针
    local j = mid + 1   --右序列指针
    local t = 0         --临时数组指针
    while (i<=mid and j<=right)
    do
        if (arr[i]<=arr[j]) then
            temp[t] = arr[i]
            t = t + 1
            i = i + 1
        else
            temp[t] = arr[j]
            t = t + 1
            j = j + 1
        end
    end

    while (i<=mid)  --将左边剩余元素填充进temp中
    do
        temp[t] = arr[i]
        t = t + 1
        i = i + 1
    end

    while (j<=right)    --将右序列剩余元素填充进temp中
    do
        temp[t] = arr[j]
        t = t + 1
        j = j + 1
    end
    t = 0
    --将temp中的元素全部拷贝到原数组中
    while (left <= right)
    do
        arr[left] = temp[t]
        left = left + 1
        t = t + 1
    end

    return arr
end

--快速排序
function sort:quick_sort( cardData, left, right )
    if left < right then
        local i = left
        local j = right
        local x = cardData[i]
        while (i<j)
        do
            while (i<j and cardData[j]>x)
            do
                j = j - 1       --从右向左找第一个小于x的数
            end
            if i<j then
                cardData[i] = cardData[j]
                i = i + 1
            end
            while (i<j and cardData[i] < x)
            do
                i = i + 1       --从左向右找第一个大于x的数
            end
            if i<j then
                cardData[j] = cardData[i]
                j = j - 1
            end
        end
        cardData[i] = x
        self:quick_sort(cardData, left, i-1)
        self:quick_sort(cardData, i+1, right)
    end
end

--堆排序 (有问题)
function sort:dui_sort( cardData )
    if cardData == nil then return  end
    local cardCount = #cardData
    if cardCount == 0 then return cardData end

    local len = #cardData
    --1.构建要给最大堆
    self:buildMaxHeap(cardData)
    --2.循环将堆首位（最大值）与末位交换，然后再重现调整最大堆
    while ( len > 1 )
    do
        self:dui_sort_swap(cardData, 1, len)
        len = len - 1
        self:dui_sort_adjustHeap(cardData, 1)
    end
    return cardData
end
function sort:buildMaxHeap(array)
    local len = #array
    local temp = math.floor((len-1)/2)
    for i = temp + 1, 1, -1 do
        self:dui_sort_adjustHeap(array, i)
    end
end
function sort:dui_sort_adjustHeap(array, i)
    local maxIndex = i
    local len = #array
    --如果有左子树，且左子树大于父节点，则将最大指针指向左子树
    if (i*2 < len and array[i*2] > array[maxIndex] ) then
        maxIndex = i*2
    end
    --如果有右子树，且右子树大于父节点，则将最大指针指向右子树
    if( i*2+1 < len and array[i*2+1]>array[maxIndex]) then
        maxIndex = i*2 + 1
    end
    --如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置
    if (maxIndex ~= i) then
        self:dui_sort_swap(array, maxIndex, i)
        self:dui_sort_adjustHeap(array, maxIndex)
    end
end
function sort:dui_sort_swap(arr, a, b)
    local temp = arr[a]
    arr[a] = arr[b]
    arr[b] = temp
end

--计数排序
function sort:counting( cardData )
    if cardData == nil then return  end
    local cardCount = #cardData
    if cardCount == 0 then return cardData end


end

return sort