Jump to content
wraithdu

Natural Order String Comparison

Recommended Posts

wraithdu

Update 8/5/2011:

I've updated the _NaturalCompare function. Foremost, it will cope with very long strings of numbers without overflowing. I've also added an implementation of _ArraySort that takes a custom sorting function, and implemented _ArrayNaturalSort in this way.

This is a different algorithm than the other I found on the board. To me, it seems more efficient.

_NaturalCompare

; #FUNCTION# ====================================================================================================================
; Name...........: _NaturalCompare
; Description ...: Compare two strings using Natural (Alphabetical) sorting.
; Syntax.........: _NaturalCompare($s1, $s2[, $iCase = 0])
; Parameters ....: $s1, $s2 - Strings to compare
;                  $iCase   - [Optional] Case sensitive or insensitive comparison
;                  |0 - Case insensitive (default)
;                  |1 - Case sensitive
; Return values .: Success - One of the following:
;                  |0  - Strings are equal
;                  |-1 - $s1 comes before $s2
;                  |1  - $s1 goes after $s2
;                  Failure - Returns -2 and Sets @Error:
;                  |1 - $s1 or $s2 is not a string
;                  |2 - $iCase is invalid
; Author ........: Erik Pilsits
; Modified.......:
; Remarks .......: Original algorithm by Dave Koelle
; Related .......: StringCompare
; Link ..........: http://www.davekoelle.com/alphanum.html
; Example .......: Yes
; ===============================================================================================================================
Func _NaturalCompare($s1, $s2, $iCase = 0)
    ; check params
    If (Not IsString($s1)) Then $s1 = String($s1)
    If (Not IsString($s2)) Then $s2 = String($s2)
    ; check case, set default
    If $iCase <> 0 And $iCase <> 1 Then $iCase = 0

    Local $n = 0
    Local $s1chunk, $s2chunk
    Local $idx, $i1chunk, $i2chunk
    Local $s1temp, $s2temp

    While $n = 0
        ; get next chunk
        ; STRING 1
        $s1chunk = StringRegExp($s1, "^(\d+|\D+)", 1)
        If @error Then
            $s1chunk = ""
        Else
            $s1chunk = $s1chunk[0]
        EndIf
        ; STRING 2
        $s2chunk = StringRegExp($s2, "^(\d+|\D+)", 1)
        If @error Then
            $s2chunk = ""
        Else
            $s2chunk = $s2chunk[0]
        EndIf

        ; ran out of chunks, strings are the same, return 0
        If $s1chunk = "" And $s2chunk = "" Then Return 0

        ; remove chunks from strings
        $s1 = StringMid($s1, StringLen($s1chunk) + 1)
        $s2 = StringMid($s2, StringLen($s2chunk) + 1)

        Select
            ; Case 1: both chunks contain letters
            Case (Not StringIsDigit($s1chunk)) And (Not StringIsDigit($s2chunk))
                $n = StringCompare($s1chunk, $s2chunk, $iCase)
            ; Case 2: both chunks contain numbers
            Case StringIsDigit($s1chunk) And StringIsDigit($s2chunk)
                ; strip leading 0's
                $s1temp = $s1chunk
                $s2temp = $s2chunk
                $s1chunk = StringRegExpReplace($s1chunk, "^0*", "")
                $s2chunk = StringRegExpReplace($s2chunk, "^0*", "")
                ; record number of stripped 0's
                $s1temp = StringLen($s1temp) - StringLen($s1chunk)
                $s2temp = StringLen($s2temp) - StringLen($s2chunk)
                ; first check if one string is longer than the other, meaning a bigger number
                If StringLen($s1chunk) > StringLen($s2chunk) Then
                    Return 1
                ElseIf StringLen($s1chunk) < StringLen($s2chunk) Then
                    Return -1
                EndIf
                ; strings are equal length
                ; compare 8 digits at a time, starting from the left, to avoid overflow
                $idx = 1
                While 1
                    $i1chunk = Int(StringMid($s1chunk, $idx, 8))
                    $i2chunk = Int(StringMid($s2chunk, $idx, 8))
                    ; check for end of string
                    If $i1chunk = "" And $i2chunk = "" Then
                        ; check number of leading 0's removed, if any - windows sorts more leading 0's above fewer leading 0's, ie 00001 < 0001 < 001
                        If $s1temp > $s2temp Then
                            Return -1
                        ElseIf $s1temp < $s2temp Then
                            Return 1
                        Else
                            ; numbers are equal
                            ExitLoop
                        EndIf
                    EndIf
                    ; valid numbers, so compare
                    If $i1chunk > $i2chunk Then
                        Return 1
                    ElseIf $i1chunk < $i2chunk Then
                        Return -1
                    EndIf
                    ; chunks are equal, get next chunk of digits
                    $idx += 8
                WEnd
            ; Case 3: one chunk has letters, the other has numbers; or one is empty
            Case Else
                ; if we get here, this should be the last and deciding test, so return the result
                Return StringCompare($s1chunk, $s2chunk, $iCase)
        EndSelect
    WEnd

    Return $n
EndFunc

Example:

#include "_NaturalCompare.au3"

ConsoleWrite("StringCompare:" & @CRLF)
ConsoleWrite(StringCompare("abC10", "abc2") & @CRLF)
ConsoleWrite(StringCompare("abC10", "abc2", 1) & @CRLF)
ConsoleWrite("_NaturalCompare:" & @CRLF)
ConsoleWrite(_NaturalCompare("abC10", "abc2") & @CRLF)
ConsoleWrite(_NaturalCompare("abC10", "abc2", 1) & @CRLF)

Here's an implementation of array sorting that uses a custom sorting function:

_ArrayNaturalSort

#include-once
#include <_NaturalCompare.au3>
#include <_ArrayCustomSort.au3>

; #FUNCTION# ====================================================================================================================
; Name...........: _ArrayNaturalSort
; Description ...: Sort a 1D or 2D array on a specific index using the quicksort/insertionsort algorithms.
; Syntax.........: _ArrayNaturalSort(ByRef $avArray[, $iDescending = 0[, $iStart = 0[, $iEnd = 0[, $iSubItem = 0]]]])
; Parameters ....: $avArray     - Array to sort
;                  $iDescending - [optional] If set to 1, sort descendingly
;                  $iStart      - [optional] Index of array to start sorting at
;                  $iEnd        - [optional] Index of array to stop sorting at
;                  $iSubItem    - [optional] Sub-index to sort on in 2D arrays
; Return values .: Success - 1
;                  Failure - 0, sets @error:
;                  |1 - $avArray is not an array
;                  |2 - $iStart is greater than $iEnd
;                  |3 - $iSubItem is greater than subitem count
;                  |4 - $avArray has too many dimensions
;                  |5 - Invalid sort function
; Author ........: Erik Pilsits
; Modified.......:
; Remarks .......:
; Related .......:
; Link ..........;
; Example .......; No
; ===============================================================================================================================
Func _ArrayNaturalSort(ByRef $avArray, $iDescending = 0, $iStart = 0, $iEnd = 0, $iSubItem = 0)
    Return _ArrayCustomSort($avArray, "_NaturalCompare", $iDescending, $iStart, $iEnd, $iSubItem)
EndFunc   ;==>_ArrayNaturalSort

And the custom sorting function:

_ArrayCustomSort

#include-once
#include <Array.au3>

; #FUNCTION# ====================================================================================================================
; Name ..........: _ArrayCustomSort
; Description ...: Sort a 1D or 2D array on a specific index using the quicksort/insertionsort algorithms, based on a custom sorting function.
; Syntax ........: _ArrayCustomSort(Byref $avArray, $sSortFunc[, $iDescending = 0[, $iStart = 0[, $iEnd = 0[, $iSubItem = 0]]]])
; Parameters ....: $avArray             - [in/out] Array to sort
;                  $sSortFunc           - Name of custom sorting function. See Remarks for usage.
;                  $iDescending         - [optional] If set to 1, sort descendingly
;                  $iStart              - [optional] Index of array to start sorting at
;                  $iEnd                - [optional] Index of array to stop sorting at
;                  $iSubItem            - [optional] Sub-index to sort on in 2D arrays
; Return values .: Success - 1
;                  Failure - 0, sets @error:
;                  |1 - $avArray is not an array
;                  |2 - $iStart is greater than $iEnd
;                  |3 - $iSubItem is greater than subitem count
;                  |4 - $avArray has too many dimensions
;                  |5 - Invalid sort function
; Author ........: Erik Pilsits
; Modified ......: Erik Pilsits - removed IsNumber testing, LazyCoder - added $iSubItem option, Tylo - implemented stable QuickSort algo, Jos van der Zande - changed logic to correctly Sort arrays with mixed Values and Strings, Ultima - major optimization, code cleanup, removed $i_Dim parameter
; Remarks .......: Sorting function is called with two array elements as arguments. The function should return
;                  0 if they are equal,
;                  -1 if element one comes before element two,
;                  1 if element one comes after element two.
; Related .......:
; Link ..........:
; Example .......: No
; ===============================================================================================================================
Func _ArrayCustomSort(ByRef $avArray, $sSortFunc, $iDescending = 0, $iStart = 0, $iEnd = 0, $iSubItem = 0)
    If Not IsArray($avArray) Then Return SetError(1, 0, 0)
    If Not IsString($sSortFunc) Then Return SetError(5, 0, 0)

    Local $iUBound = UBound($avArray) - 1

    ; Bounds checking
    If $iEnd < 1 Or $iEnd > $iUBound Then $iEnd = $iUBound
    If $iStart < 0 Then $iStart = 0
    If $iStart > $iEnd Then Return SetError(2, 0, 0)

    ; Sort
    Switch UBound($avArray, 0)
        Case 1
            __ArrayCustomQuickSort1D($avArray, $sSortFunc, $iStart, $iEnd)
            If $iDescending Then _ArrayReverse($avArray, $iStart, $iEnd)
        Case 2
            Local $iSubMax = UBound($avArray, 2) - 1
            If $iSubItem > $iSubMax Then Return SetError(3, 0, 0)

            If $iDescending Then
                $iDescending = -1
            Else
                $iDescending = 1
            EndIf

            __ArrayCustomQuickSort2D($avArray, $sSortFunc, $iDescending, $iStart, $iEnd, $iSubItem, $iSubMax)
        Case Else
            Return SetError(4, 0, 0)
    EndSwitch

    Return 1
EndFunc   ;==>_ArrayCustomSort

; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: __ArrayCustomQuickSort1D
; Description ...: Helper function for sorting 1D arrays
; Syntax.........: __ArrayCustomQuickSort1D(ByRef $avArray, ByRef $sSortFunc, ByRef $iStart, ByRef $iEnd)
; Parameters ....: $avArray   - Array to sort
;                  $sSortFunc - Name of sorting function.
;                  $iStart    - Index of array to start sorting at
;                  $iEnd      - Index of array to stop sorting at
; Return values .: None
; Author ........: Jos van der Zande, LazyCoder, Tylo, Ultima
; Modified.......: Erik Pilsits - removed IsNumber testing
; Remarks .......: For Internal Use Only
; Related .......:
; Link ..........;
; Example .......;
; ===============================================================================================================================
Func __ArrayCustomQuickSort1D(ByRef $avArray, ByRef $sSortFunc, ByRef $iStart, ByRef $iEnd)
    If $iEnd <= $iStart Then Return

    Local $vTmp

    ; InsertionSort (faster for smaller segments)
    If ($iEnd - $iStart) < 15 Then
        Local $i, $j
        For $i = $iStart + 1 To $iEnd
            $vTmp = $avArray[$i]
            For $j = $i - 1 To $iStart Step -1
                If (Call($sSortFunc, $vTmp, $avArray[$j]) >= 0) Then ExitLoop
                $avArray[$j + 1] = $avArray[$j]
            Next
            $avArray[$j + 1] = $vTmp
        Next
        Return
    EndIf

    ; QuickSort
    Local $L = $iStart, $R = $iEnd, $vPivot = $avArray[Int(($iStart + $iEnd) / 2)]
    Do
        While (Call($sSortFunc, $avArray[$L], $vPivot) < 0)
            $L += 1
        WEnd
        While (Call($sSortFunc, $avArray[$R], $vPivot) > 0)
            $R -= 1
        WEnd

        ; Swap
        If $L <= $R Then
            $vTmp = $avArray[$L]
            $avArray[$L] = $avArray[$R]
            $avArray[$R] = $vTmp
            $L += 1
            $R -= 1
        EndIf
    Until $L > $R

    __ArrayCustomQuickSort1D($avArray, $sSortFunc, $iStart, $R)
    __ArrayCustomQuickSort1D($avArray, $sSortFunc, $L, $iEnd)
EndFunc   ;==>__ArrayCustomQuickSort1D

; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: __ArrayCustomQuickSort2D
; Description ...: Helper function for sorting 2D arrays
; Syntax.........: __ArrayCustomQuickSort2D(ByRef $avArray, ByRef $sSortFunc, ByRef $iStep, ByRef $iStart, ByRef $iEnd, ByRef $iSubItem, ByRef $iSubMax)
; Parameters ....: $avArray  - Array to sort
;                  $iStep    - Step size (should be 1 to sort ascending, -1 to sort descending!)
;                  $iStart   - Index of array to start sorting at
;                  $iEnd     - Index of array to stop sorting at
;                  $iSubItem - Sub-index to sort on in 2D arrays
;                  $iSubMax  - Maximum sub-index that array has
; Return values .: None
; Author ........: Jos van der Zande, LazyCoder, Tylo, Ultima
; Modified.......: Erik Pilsits - removed IsNumber testing
; Remarks .......: For Internal Use Only
; Related .......:
; Link ..........;
; Example .......;
; ===============================================================================================================================
Func __ArrayCustomQuickSort2D(ByRef $avArray, ByRef $sSortFunc, ByRef $iStep, ByRef $iStart, ByRef $iEnd, ByRef $iSubItem, ByRef $iSubMax)
    If $iEnd <= $iStart Then Return

    ; QuickSort
    Local $i, $vTmp, $L = $iStart, $R = $iEnd, $vPivot = $avArray[Int(($iStart + $iEnd) / 2)][$iSubItem]
    Do
        While ($iStep * Call($sSortFunc, $avArray[$L][$iSubItem], $vPivot) < 0)
            $L += 1
        WEnd
        While ($iStep * Call($sSortFunc, $avArray[$R][$iSubItem], $vPivot) > 0)
            $R -= 1
        WEnd

        ; Swap
        If $L <= $R Then
            For $i = 0 To $iSubMax
                $vTmp = $avArray[$L][$i]
                $avArray[$L][$i] = $avArray[$R][$i]
                $avArray[$R][$i] = $vTmp
            Next
            $L += 1
            $R -= 1
        EndIf
    Until $L > $R

    __ArrayCustomQuickSort2D($avArray, $sSortFunc, $iStep, $iStart, $R, $iSubItem, $iSubMax)
    __ArrayCustomQuickSort2D($avArray, $sSortFunc, $iStep, $L, $iEnd, $iSubItem, $iSubMax)
EndFunc   ;==>__ArrayCustomQuickSort2D

Example:

#include "_ArrayNaturalSort.au3"

Global $a[1], $array[10] = ["image1.jpg", "image2.jpg", "image3.jpg", "image10.jpg", "image11.jpg", _
                            "image12.jpg", "image20.jpg", "image21.jpg", "image22.jpg", "image23.jpg"]
                    
$a = $array
_ArraySort($a)
_ArrayDisplay($a, "_ArraySort")

$a = $array
_ArrayNaturalSort($a)
_ArrayDisplay($a, "_ArrayNaturalSort")
Edited by wraithdu
  • Like 2

Share this post


Link to post
Share on other sites
WeMartiansAreFriendly

Very nice! :mellow:

This is a different algorithm than the other I found on the board. To me, it seems more efficient.

Could you tell me what algorithm that is.


Don't bother, It's inside your monitor!------GUISetOnEvent should behave more like HotKeySet()

Share this post


Link to post
Share on other sites
wraithdu

It was posted over a year ago. The author mentioned a followup, but never did -

http://www.autoitscript.com/forum/index.php?showtopic=45755

He got his algorithm from one of the ones listed on this page -

http://www.codinghorror.com/blog/archives/001018.html

He also mentioned a rewrite to the _ArraySort() function that would take a user-defined comparison algorithm, much like C's qsort. I think this would be a cool idea. I'm not sure if the AutoIt devs would go for it, so I just modified the necessary _ArraySort***() funcs for my example.

Edited by wraithdu

Share this post


Link to post
Share on other sites
wraithdu

Well, performance is sketchy unfortunately. _ArraySort() does a 5000 element array in .55 sec, while the _NaturalCompare() variant takes 16 seconds. I wonder if a plugin would perform better?

Share this post


Link to post
Share on other sites
wraithdu

The plugin works MUCH faster. I implemented the original alphanum algorithm in a plugin. It sorts the same 5000 element array in 1.5 seconds. That's very acceptable :mellow: To test it, use the modified _ArrayNaturalSort function from above, but comment out the '#include "_NaturalCompare.au3"' line.

In your test script include the line '#AutoIt3Wrapper_PlugIn_Funcs=_NaturalCompare', and don't forget

$hDLL = PluginOpen("natcomp.dll")

...

PluginClose($hDLL)

This plugin uses MFC, so if you don't have it installed, you'll need the VC++ 2008 SP1 Redistributable.

natcomp_plugin.zip

Share this post


Link to post
Share on other sites
lee321987

A large chunk of the code from the first post is showing up as garbage for me, e.g. oÝ÷ ØÊøtëk$¨®×î

Does anyone have the original saved?

Share this post


Link to post
Share on other sites
wraithdu

I have it. I'm gonna give it a once over to see if I can make any improvements, then I'll repost it.

Share this post


Link to post
Share on other sites
asdf8

Very nice!

It is possible to speed up the algorithm?

#include "_ArrayNaturalSort.au3"

$aMax=7000
Dim $aRecords[$aMax]
For $i=0 To $aMax-1
    $aRecords[$i]= Chr(Random(65,90,1)) & '_' & Random(1,$aMax,1)
Next

$begin = TimerInit()
_ArraySort($aRecords,0,0)
$dif = TimerDiff($begin)
$dif = Round($dif/1000,2) & ' sec.'
_ArrayDisplay($aRecords, "_ArraySort " & $dif)

$begin = TimerInit()
_ArrayNaturalSort($aRecords,0,0)
$dif = TimerDiff($begin)
$dif = Round($dif/1000,2) & ' sec.'
_ArrayDisplay($aRecords, "_ArrayNaturalSort " & $dif)

Share this post


Link to post
Share on other sites
wraithdu

I had to revisit this for a new project, so I took the opportunity to update it. I've added the custom sorting function I talked about way back when as well.

Share this post


Link to post
Share on other sites
Ward

Hi, wraithdu. This is my machine code version. C Source from Martin Pool.

#Include-once
#Include <Memory.au3>

Global $_NaturalCompare_CodeBufferPtr, $_NaturalCompare_CodeBuffer

Func NaturalCompare_Shutdown()
    _MemVirtualFree($_NaturalCompare_CodeBufferPtr, 0, $MEM_RELEASE)
    $_NaturalCompare_CodeBufferPtr = 0
EndFunc

Func NaturalCompare_Startup()
    If Not $_NaturalCompare_CodeBuffer Then
        Local $Code
        If @AutoItX64 Then
            $Code = Binary("0x41574531D24531C9415641554154555756534883EC184963C14989D3668B2C414963C2668B1C42418D41014898488D0441400FB6FD4188EC83FF207F198D77F783FE04760583FF20750C668B2841FFC14883C002EBDB418D42014C89DA66892C244898498D04430FB6F34188DB83FE207F1B448D6EF74183FD04760583FE20750C668B1841FFC24883C002EBDA450FB6E44183EC304183FC090F8709010000450FB6DB4183EB304183FB090F87F70000006683FB3074066683FD3075634963C24C8D24424963C14C8D1C4166458B2B410FB6C583E83083F80966418B042476140FB6C083E83083F8090F860A010000E9B4000000440FB6F04183EE304183FE090F87F8000000664139C50F82E90000000F87E80000004983C3024983C402EBAB4963C24C8D2C424963C14C8D244131C066458B3424450FB6DE4183EB304183FB0966458B5D007614450FB6DB4183EB304183FB090F869F000000EB48450FB6FB4183EF304183FF090F8790000000664539DE730A85C041BBFFFFFFFFEB0A760E85C041BB01000000410F44C3EB0C664585F67506664585DB740A4983C4024983C502EB8C85C075406685DB75056685ED74344585C0751C8D5F9F8D47E083FB198D5EE00F46F88D469F66893C2483F8190F47DE66391C247220772341FFC141FFC2E930FEFFFF31C04883C4185B5E5F5D415C415D415E415FC383C8FFEBEAB801000000EBE3")
        Else
            $Code = Binary("0x5531C989E531D257565383EC1C8B5D0C8B4508668B1C4B668B045066895DEA8B5D08668945E28D4453028A5DE20FB6F383FE20885DF07F1A8D5EF783FB04760583FE20750D668B184283C00266895DE2EBD8668B45E28B5D0C8955E4668945DE8D444B020FB67DEA89FA0FB6DA83FB207F1A8D53F783FA04760583FB20750D668B184183C00266895DEAEBD80FB645F08B55E483E83083F8090F872301000081E7FF00000083EF3083FF090F871101000066837DEA30740766837DE230756D8B450C8D3C488B45088D04508945F08B45F0668B00668945E40FB645E483E83083F809668B07668945EC76150FB645EC83E83083F8090F8618010000E9C20000000FB645EC83E83083F8090F87080100008B45EC663945E40F82F60000000F87F50000008345F00283C702EBA28B450C8955D88D04488945EC8B45088D04508945E431C08B55E4668B120FB6FA668955E08B55EC83EF3083FF09668B12668955F076150FB67DF08B55D883EF3083FF090F869E000000EB470FB67DF083EF3083FF090F87910000008B55F0663955E0730985C0751D83C8FFEB18760885C07512B001EB0E66837DE000750766837DF000740A8345E4028345EC02EB888B55D885C0754766837DEA00750766837DE2007437837D1000751E8D469F83F819770383EE208D439F83F819668975DE770383EB2066895DEA668B5DEA66395DDE721577184241E906FEFFFF31C083C41C5B5E5F5DC2100083C8FFEBF1B801000000EBEA")
        EndIf

        Local $CodeLen = BinaryLen($Code)
        $_NaturalCompare_CodeBufferPtr = _MemVirtualAlloc(0, $CodeLen, $MEM_COMMIT, $PAGE_EXECUTE_READWRITE)
        $_NaturalCompare_CodeBuffer = DllStructCreate("byte[" & $CodeLen & "]", $_NaturalCompare_CodeBufferPtr)
        DllStructSetData($_NaturalCompare_CodeBuffer, 1, $Code)

        OnAutoItExitRegister("NaturalCompare_Shutdown")
    EndIf
EndFunc

Func NaturalCompareFast($String1, $String2, $Case = 0)
    If Not $_NaturalCompare_CodeBufferPtr Then NaturalCompare_Startup()
    Local $Ret = DllCall("user32.dll", "int", "CallWindowProc", "ptr", $_NaturalCompare_CodeBufferPtr, _
                                                    "wstr", $String1, _
                                                    "wstr", $String2, _
                                                    "int", $Case, _
                                                    "int", 0)
    Return $Ret[0]
EndFunc

Speed test:

ConsoleWrite("_NaturalCompare:" & @CRLF)
$Timer = TimerInit()
For $i = 1 To 10000
    _NaturalCompare("abC10", "abc2")
    _NaturalCompare("abC10", "abc2", 1)
Next
ConsoleWrite(TimerDiff($Timer) & @CRLF)

ConsoleWrite("NaturalCompareFast:" & @CRLF)
$Timer = TimerInit()
For $i = 1 To 10000
    NaturalCompareFast("abC10", "abc2")
    NaturalCompareFast("abC10", "abc2", 1)
Next
ConsoleWrite(TimerDiff($Timer) & @CRLF)

Result on my computre:

_NaturalCompare:
1288.4765591166
NaturalCompareFast:
472.212972604665

I hope this may help you.

  • Like 1

新版 _ArrayAdd 的白痴作者,不管是誰,去死一死好了

 

Share this post


Link to post
Share on other sites
wraithdu

Heh, yeah, it won't win any speed comparisons for sure, I know it's slow. I wrote a plugin version as well above (haven't looked at or updated that in a while though). More to the point was the custom array sorting function, which is what I really wanted for my next project. I just updated this algorithm cause "it was there".

Share this post


Link to post
Share on other sites
Ward

Heh, yeah, it won't win any speed comparisons for sure, I know it's slow. I wrote a plugin version as well above (haven't looked at or updated that in a while though). More to the point was the custom array sorting function, which is what I really wanted for my next project. I just updated this algorithm cause "it was there".

Of course, for education or demonstrating algorithm, your code is best.

I just provide a simple binary code from C source if you really want use this function in program.


新版 _ArrayAdd 的白痴作者,不管是誰,去死一死好了

 

Share this post


Link to post
Share on other sites
xeroTechnologiesLLC

perfect for the project I am currently on - thank you very much for sharing this with us - very well done.

Share this post


Link to post
Share on other sites
Skysnake

I will bookmark this page :)

 


Skysnake

Why is the snake in the sky?

Share this post


Link to post
Share on other sites
Thomymaster

Hi

 

This code is excellent thanks a lot! It helped me in a project where i needed to sort an array and _ArraySort() wasn't behaving correctly :)

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×