Для работы нужно: - в переменной n номер столбца массива - в mass() собственно сам массив для сортировки
Код
Option Base 1
Dim qqq, arr00()
Sub iSort(ByVal n As Byte, ByVal mass As Variant)
Set indcol = CreateObject("Scripting.Dictionary")
If n > UBound(mass, 2) Then n = UBound(mass, 2)
If n < 1 Then n = 1
For a = 1 To UBound(mass, 1)
If mass(a, n) = "" Then mass(a, n) = Chr(1) & Chr(1)
If Not indcol.exists(mass(a, n)) Then
ReDim arr(1 To UBound(mass, 1) + 2)
arr(1) = 1: arr(2) = 3: arr(arr(2)) = a: indcol.Add mass(a, n), arr
Else
arr = indcol.Item(mass(a, n)): arr(1) = arr(1) + 1: arr(2) = arr(2) + 1: arr(arr(2)) = a: indcol.Item(mass(a, n)) = arr
End If
Next a
If indcol.Count = 1 Then n = 0: Exit Sub
arr0 = indcol.keys(): x = 0: xx = 0: qqq = UBound(arr0)
start:
For b = 1 To UBound(arr0)
If arr0(b) < arr0(b - 1) Then aa = arr0(b - 1): arr0(b - 1) = arr0(b): arr0(b) = aa: x = x + 1
Next b
xx = xx + x
If x > 0 Then x = 0: GoTo start
If xx = 0 Then n = 0: Exit Sub
ReDim arr00(1 To UBound(mass, 1), 1 To UBound(mass, 2))
x = 1
For a = 0 To UBound(arr0)
arr = indcol.Item(arr0(a))
For b = 1 To arr(1)
For c = 1 To UBound(arr00, 2)
arr00(x, c) = mass(arr(2 + b), c)
Next c
x = x + 1
Next b
Next a
For a = 1 To UBound(arr00, 1)
If arr00(a, n) = Chr(1) & Chr(1) Then arr00(a, n) = ""
Next a
End Sub
На выходе: - если все прошло хорошо, то в arr00() будет отсортированный входной массив - если n=0 значит массив не требует сортировки (одна строка либо все и так по возрастанию значений выбранного столбца)
Логика: - проверяется значение n на тему выхода за рамки ширины массива - через словарь индексируется содержимое входного массива по выбранному в n столбцу - проходим "пузырьком" по списку уникальных значений - по полученному в пред.пункте списку выгружаем массив по индексам ранее записанным в словаре
П.С.: Конструктивная критика и методы оптимизации приветствуются
oldy7, а смысл в такой громоздкой сортировке? 5 вложенных циклов и ещё 3 невложенных… Сортировка пузырьком, если Вы её хотели реализовать, гораздо проще пишется, чем Ваш код. Быстрая сортировка и то проще пишется, а я не вижу, чтобы Вы n*log n превзошли. Плюс пара моментов: 1) переменные стоит не только объявлять, но и инициализировать. Чему равно входное значение n во второй строке? 0 или Empty, вот в чём вопрос? 2) смысл заменять пустые строки кавычками и обратно? 3) Вы замеряли производительность этого кода в сравнении обычной сортировкой массива пузырьком? А раз мы со словарём работаем, то, возможно, вставки будут быстрее пузырьков? Не говоря о быстрых алгоритмах.
Irregular Expression, пузырьком - два вложенных цикла по строкам + еще один на обработку двух соседних строк с перебором всех элементов массива по условию. Количество операций только по строкам = кол-во строк в массиве в квадрате. Не считая перебора каждой строки. Такая сортировка будет быстрой только на массивах с малым количеством элементов.
А теперь по пунктам: 1. Согласен, но это не обязательно. В описании макроса это написано - защита от 0 или ввода значения более ubound(mass,2), вообще туда надо написать выход из процедуры при таких значениях n 2. А ключи словаря могут иметь значение Empty? 3. Этот код будет эффективен на массивах с большим количеством одинаковых элементов в отдельно взятом столбце массива.
Как все происходит: - с помощью словаря отбираются уникальные значения в столбце n - в качестве итема записывается одномерный массив, где в первых двух ячейках находятся счетчик повторений ключа в просматриваемом столбце массива и позиция для записи индекса (номера строки исходного массива) - сортировка по ключам словаря пузырьком , т.е. по уникальным значениям и по возрастанию с счетчиком сдвигов в массиве (массиве с набором ключей) - переменная x для прохода циклом и глобальный счетчик - xx, именно по нему в дальнейшем определяется нужна ли вообще была сортировка - далее рождается массив, куда по индексам ранее записанным в словаре и по отсортированному списку ключей загружаются строки из первичного массива
Т.е. скорость работы сортировщика зависит от кол-ва уникальных элементов, размера массива (разумеется и в первую очередь по количеству строк) ------- alex1210 , к выше написанному: - в модуле с этим макросом обязательно Option Base 1 - нижняя граница массивов будет 1, а не 0 - объявить входные и выходные переменные как Public
Количество операций только по строкам = кол-во строк в массиве в квадрате. Не считая перебора каждой строки. Такая сортировка будет быстрой только на массивах с малым количеством элементов.
Вот поэтому и непонятно для чего писать сортировку более сложную, чем стандартное решение, если всё равно имеем N в квадрате. Особенно с учётом того, что стандартный метод Range.Sort никто не отменял и на малых (и не очень) массивах он неплохо работает.
Цитата
- объявить входные и выходные переменные как Public
Цитата
1. Согласен, но это не обязательно. В описании макроса это написано - защита от 0 или ввода значения более ubound(mass,2), вообще туда надо написать выход из процедуры при таких значениях n
А не проще добавить в сигнатуру процедуры принимаемые параметры? Не хватает ещё глобальных переменных для реализации сортировки - это даже звучит жутко 0_о... Кроме того, какие ещё "выходные параметры" у процедуры? Тогда уж делайте Function iSort(arr As Variant) As Variant и возвращайте отсортированный массив (или какие ещё параметры должен возвращать код сортировки? Сейчас Ваш код не возвращает ничего, как и положено процедуре).
Цитата
2. А ключи словаря могут иметь значение Empty?
Вы уверены, что Ваш код отработает быстрее, чем это?
Код
Sub BubbleSort(arr As Variant)
Dim swapped As Boolean
Dim tmp As Variant
Dim iCol As Long: iCol = 1 'столбец, по которому сортируем
For i = 1 To Ubound(arr) - 1
swapped = True
For j = 1 To Ubound(arr) - i
If arr(j, iCol) > arr(j + 1, iCol) Then
swapped = False
For k = 1 To UBound(arr, 2)
tmp = arr(j, k)
arr(j, k) = arr(j + 1, k)
arr(j + 1, k) = tmp
Next k
End If
Next j
If swapped Then Exit For
Next i
End Sub
Если нет, то... в чём преимущество использования словаря?
Цитата
3. Этот код будет эффективен на массивах с большим количеством одинаковых элементов в отдельно взятом столбце массива.
Тест на скорость выполнения проводили или это предположение? Если проводили, то какие результаты тестов? Если нет, то это вилами по воде писано. Возьмите Ваш код, стандартную реализацию сортировки пузырьком (например, которую я написал выше), а также стандартный вызов Range.Sort и засеките Timer'ом время выполнения макроса для одинаковых диапазонов с большим количеством ячеек в каждом из 3 случаев.
Irregular Expression, - это уже не критика, а разнос :-) Но не без оснований :-)
Цитата
oldy7 написал: 3. Этот код будет эффективен на массивах с большим количеством одинаковых элементов в отдельно взятом столбце массива.
Вот по этому встречал куски кода в свое время, которые сперва анализировали что нужно сортировать , а потом применяли тот мили иной метод. Например сортировка методом Хора проиграет пузырьку на малом массиве.
Вот поэтому и непонятно для чего писать сортировку более сложную, чем стандартное решение, если всё равно имеем N в квадрате.
Т.е. я зря Вам навязывал свой вариант?) Здесь меньше, чем N в квадрате. Второй раз расписывать не вижу смысла.
Цитата
А не проще добавить в сигнатуру процедуры принимаемые параметры?
Да, так будет правильнее.
Цитата
Сейчас Ваш код не возвращает ничего, как и положено процедуре).
Возвращает при глобализации трех переменных или объявлении их в модуле, где будет использоваться процедура.
Цитата
Вы уверены, что Ваш код отработает быстрее, чем это?
Как время будет, то обязательно проверю оба варианта с таймерами. Но по логике вещей должен работать быстрее даже на массиве с малой шириной (если для них уместно такое слово). Потому-что гладиолус - сортировка идет в одномерном массиве уникальных значений + проход по вертикали при загрузке словаря + такой-же с заменой двойных пробелов на пустоты + выгрузка по списку уников. Ни разу ни N в квадрате.
Все-таки расписал...
Цитата
БМВ написал: Вот по этому встречал куски кода в свое время, которые сперва анализировали что нужно сортировать , а потом применяли тот мили иной метод.
К уже существующему прикрутить проверку на целесообразность (оценить ширину и кол-во уникальных элементов) не так уж и трудно) Спасибо за дельную мысль.
П.С.: Не ожидал такого напора)) Ну да ладно... Сам напросился:) П.П.С.: В рабочем файле хренова туча листов и макросов их обрабатывающих. Все это дело постоянно совершенствуется. Почти в каждом есть необходимость сортировки. Максимальный размер сортируемого массива 90000х15. Всяческие пузырьки, и тем более стандартный метод через сортинг на листе (даже с отключенным не только обновлением экрана, но и авто пересчетом формул) не устраивают. Поэтому ищу другие варианты. Завтра переведу основную часть макросов на предмет споров, заодно протестирую по полной.
Option Base 1
Dim qqq, arr00(), qwerty()
Sub TestDrive()
ReDim arr01(1 To 20, 1 To 10): x = 1
For aaa = 1 To 6
ReDim qwerty(1 To 5000, 1 To 10)
For a = 1 To UBound(qwerty, 1)
For b = 1 To UBound(qwerty, 2)
For c = 1 To aaa
qwerty(a, b) = qwerty(a, b) & Chr(65 + (Rnd * 25))
Next c
Next b: Next a
arr01(x, 1) = UBound(qwerty, 1) & "x" & UBound(qwerty, 2): arr01(x, 3) = Time
ii = Timer: qqq = 0
Call iSort(aaa, qwerty)
iii = Timer
arr01(x, 2) = qqq: arr01(x, 4) = Time: arr01(x, 5) = iii - ii
ActiveSheet.Range("L2").Resize(12, 5) = arr01
ActiveSheet.Range("A1").Resize(UBound(arr00, 1), UBound(arr00, 2)) = arr00
x = x + 1
arr01(x, 1) = UBound(qwerty, 1) & "x" & UBound(qwerty, 2): arr01(x, 3) = Time
ii = Timer: qqq = 0
Call BubbleSort(aaa, qwerty)
iii = Timer
arr01(x, 2) = "-": arr01(x, 4) = Time: arr01(x, 5) = iii - ii
ActiveSheet.Range("L2").Resize(12, 5) = arr01
ActiveSheet.Range("A1").Resize(UBound(qwerty, 1), UBound(qwerty, 2)) = qwerty
x = x + 1
Next aaa
qq = 0
End Sub
Sub iSort(ByVal n As Byte, ByVal mass As Variant)
Set indcol = CreateObject("Scripting.Dictionary")
If n > UBound(mass, 2) Then n = UBound(mass, 2)
If n < 1 Then n = 1
For a = 1 To UBound(mass, 1)
If mass(a, n) = "" Then mass(a, n) = Chr(1) & Chr(1)
If Not indcol.exists(mass(a, n)) Then
ReDim arr(1 To UBound(mass, 1) + 2)
arr(1) = 1: arr(2) = 3: arr(arr(2)) = a: indcol.Add mass(a, n), arr
Else
arr = indcol.Item(mass(a, n)): arr(1) = arr(1) + 1: arr(2) = arr(2) + 1: arr(arr(2)) = a: indcol.Item(mass(a, n)) = arr
End If
Next a
If indcol.Count = 1 Then n = 0: Exit Sub
arr0 = indcol.keys(): x = 0: xx = 0: qqq = UBound(arr0) 'unic's
start: For b = 1 To UBound(arr0)
If arr0(b) < arr0(b - 1) Then aaa = arr0(b - 1): arr0(b - 1) = arr0(b): arr0(b) = aaa: x = x + 1
Next b
xx = xx + x
If x > 0 Then x = 0: GoTo start
If xx = 0 Then n = 0: arr00 = Empty: Exit Sub
ReDim arr00(1 To UBound(mass, 1), 1 To UBound(mass, 2))
x = 1
For a = 0 To UBound(arr0)
arr = indcol.Item(arr0(a))
For b = 1 To arr(1)
For c = 1 To UBound(arr00, 2)
arr00(x, c) = mass(arr(2 + b), c)
Next c
x = x + 1
Next b
Next a
For a = 1 To UBound(arr00, 1)
If arr00(a, n) = Chr(1) & Chr(1) Then arr00(a, n) = ""
Next a
Erase mass
End Sub
Sub BubbleSort(ByVal iCol As Byte, ByVal qwerty As Variant)
Dim swapped As Boolean
Dim tmp As Variant
For i = 1 To UBound(qwerty, 1) - 1
swapped = True
For j = 1 To UBound(qwerty, 1) - i
If qwerty(j, iCol) > qwerty(j + 1, iCol) Then
swapped = False
For k = 1 To UBound(qwerty, 2)
tmp = qwerty(j, k)
qwerty(j, k) = qwerty(j + 1, k)
qwerty(j + 1, k) = tmp
Next k
End If
Next j
If swapped Then Exit For
Next i
End Sub
Irregular Expression написал: oldy7 , снимаю шляпу - пузырёк обогнали хорошо . Сделаю на днях ещё пару тестов и отпишу результаты. Заинтересовали.
Пузырёк еще подвешивает Excel и есть шанс, что макрос с этим пузырьком будет работать не стабильно. Т.к. здесь создается несколько промежуточных массивов, то на больших входных массивах есть риск словить Out of memory. Практически 5000 строк для приведенного макроса - потолок. Позже выложу более оптимизированную версию.
П.С.: В любом случае для огромных массивов встроенный в Excel сортировщик, и без промежуточной выгрузки в массив.
Добавил еще необязательный аргумент для процедуры - направление сортировки. По-умолчанию его значение - False, т.е. сортировка по возрастающей. Макрос заметно потолстел:
Код
Sub iSort(ByVal n As Byte, ByVal mass As Variant, Optional ByVal d As Boolean)
Dim indcol, sp%, pp$, a&, b%, mm, arr(), arr0(), x&, xx&, c%
Set indcol = CreateObject("Scripting.Dictionary")
sp = 0
If d = False Then
pp = Chr(255) & Chr(255) & Chr(255) & Chr(255)
Else
pp = Chr(1) & Chr(1) & Chr(1) & Chr(1)
End If
If n > UBound(mass, 2) Then n = UBound(mass, 2)
If n < 1 Then n = 1
With indcol
For a = 1 To UBound(mass, 1)
If mass(a, n) = "" Then mass(a, n) = pp: sp = sp + 1
If Not .Exists(mass(a, n)) Then
.Add mass(a, n), 1
Else
mm = .Item(mass(a, n)): .Item(mass(a, n)) = mm + 1
End If
Next a: ww = .Count
For a = 1 To UBound(mass, 1)
mm = .Item(mass(a, n))
If Not IsArray(mm) Then
ReDim arr(1 To mm + 2)
arr(1) = mm: arr(2) = 3: arr(arr(2)) = a
.Item(mass(a, n)) = arr
Else
arr = .Item(mass(a, n)): arr(2) = arr(2) + 1
arr(arr(2)) = a: .Item(mass(a, n)) = arr
End If
Next a
'If .Count = 1 Then n = 0: Exit Sub
arr0 = .Keys(): x = 0: xx = 0
start:
For b = 1 To UBound(arr0)
If d = False Then
If arr0(b) < arr0(b - 1) Then aaa = arr0(b - 1): arr0(b - 1) = arr0(b): arr0(b) = aaa: x = x + 1
Else
If arr0(b) > arr0(b - 1) Then aaa = arr0(b - 1): arr0(b - 1) = arr0(b): arr0(b) = aaa: x = x + 1
End If
Next b
xx = xx + x
If x > 0 Then x = 0: GoTo start
ReDim sArray(1 To UBound(mass, 1), 1 To UBound(mass, 2))
x = 1
For a = 0 To UBound(arr0)
arr = .Item(arr0(a))
For b = 1 To arr(1)
For c = 1 To UBound(sArray, 2)
sArray(x, c) = mass(arr(2 + b), c)
Next c
x = x + 1
Next b
Next a
End With
If sp = 0 Then n = 1: Exit Sub
For a = 1 To UBound(sArray, 1)
If sArray(a, n) = pp Then sArray(a, n) = ""
Next a
n = 1
End Sub
bedvit написал: А теперь попробуйте стандартный Range..Sort. Интересен результат.
Как-нибудь в другой раз) Ещё до написания первого своего "пузырька" варианты с выгрузкой на лист, сортировкой стандартными средствами, и загрузкой обратно в массив (а еще ведь и лист нужно почистить) меня сильно подбешивали. Если у кого есть желание поупражняться - вэлком)
Вы сами выложили алгоритм на обсуждение, возможно ваш алгоритм хорош, и многие возьмут его на вооружениее, для этого нужно сравнить со стандартными, уже существующими методами. Зачем новый велик? И зачем так сложно - загружать на лист, удалять - просто создайте обьект Range и работайте с ним.
На самом деле я искал решение оптимальной сортировки промежуточных итогов в массивах. Вариант с индексацией мне понравился) Ну и заодно поделился этим решением с другими. Может кому пригодится. Не сомневаюсь, что на этом форуме много специалистов и они справились бы с этим решением быстрее и изящнее)
Вероятные варианты развития этого кода: - доп.агрумент в виде массива на фильтрацию с сортировкой или выносом заданных значений вверх массива - поиск элементов в массиве по маске с заменой или без - удаление дубликатов - "нарезка" из столбцов
То, что вы делитесь решением с другими это хорошо, кому-то пригодится, и скажут вам спасибо. Вот недавно была тема про удаление дубликатов, почитайте интересные были алгоритмы.
Да, я там полистал немного еще до написания своего сортировщика. Видимо недостаточно) Сейчас стал на скользкую дорожку оптимизации алгоритма сортировки. Заменил однопроходный "пузырёк" двупроходным. Разница незначительная. Тестирую вариант с Мин-Максом. и терзают меня смутные сомнения, что по скорости выигрыша не будет.
Идея и реализация такова: - цикл по кол-ву ун.значений - при каждом проходе по нему определяются минимальное и максимальное значение. они заносятся в другой одномерный массив. Минимальные растут снизу, максимальные соотв.сверху вниз. - после каждой проходки убиваются элементы (найденные мин-макс) в первичном словаре, добавляются во второй - пересоздается массив с ключами первого словаря - если первоначальный словарь не опустел, то повтор цикла -------------------------------- Примерно на четверть новый вариант шустрее. В верхней части таблицы двупроходный пузырек, снизу мин-макс. В колонке "Operations" кол-во сдвигов в массиве по первому варианту и кол-во опред.мин-макса (их может быть много даже за один проход) в рамках прохода по циклу.
Оптимизирован алгоритм: Цель: - уменьшение кол-ва итераций внутри цикла определения мин-макс значений - достигнута
Алгоритм: - устанавливаются первичные проверочные условия для опред.мин-макса. мин="яяя" 4*(Chr(255) &), макс=Empty (при сортинге по возрастающей наоборот) - при каждом прохождении цикла поиск мин-макс значений, каждое из них падает в свою переменную (мин, макс) - с полюсов массива-источника еще не определившиеся значения падают в его центр при условии, что определенный мин-макс не с одного из этих полюсов - полюса эмптятся (присваивается значение Empty) - добытые мин-максы падают на соотв.полюса массива-получателя - инверсия по условиям опред.мин-максов - нижняя граница массива +1, верхняя - 1 - если разница между границами больше или равно 0, то шоу продолжается - все выше перечисленное повторяется, кроме первичных мин-максов Результат тестов:
П.С.: Возможно позже прикручу один из бороздящих просторы инета вариант QuickSort'а.
В поисках священного Грааля сваял забавный вариант сортировки: - после индексации через словарь в один массив выгружаются ключи - перед запуском сортировки ключей рождается второй массив - в этот массив, сверху вниз, загружаются ключи из первого массива с поиском места для конкретного элемента со смещением всех попавших на пути
Сортирует относительно шустро. Под спойлером картинка после проведения тестов и сам макрос.
Скрытый текст
-----------
-----------
Код
Sub iCrayfishSort(ByVal n As Byte, ByVal mass As Variant, Optional ByVal d As Boolean, Optional ByVal ff As Boolean)
'--- "потаскун" или "рак" - протаскивает каждый взятый элемент из родительского массива через второй в попытке определеить его (элемента) место
'--- номер столбца, массив, направление сортировки, группируем или нет
Dim indcol, sp%, pp$, a&, b&, mm, arr(), arr0(), x&, c%
Set indcol = CreateObject("Scripting.Dictionary")
sp = 0
If d = False Then
pp = Chr(255) & Chr(255) & Chr(255) & Chr(255)
Else
pp = -999999999
End If
If n > UBound(mass, 2) Then n = UBound(mass, 2)
If n < 1 Then n = 1
With indcol
For a = 1 To UBound(mass, 1)
If mass(a, n) = "" Then mass(a, n) = pp: sp = sp + 1
If Not .Exists(mass(a, n)) Then
.Add mass(a, n), 1
Else
mm = .Item(mass(a, n)): .Item(mass(a, n)) = mm + 1
End If
Next a: ww = .Count
For a = 1 To UBound(mass, 1)
mm = .Item(mass(a, n))
If Not IsArray(mm) Then
ReDim arr(1 To mm + 2)
arr(1) = mm: arr(2) = 3: arr(arr(2)) = a
.Item(mass(a, n)) = arr
Else
arr = .Item(mass(a, n)): arr(2) = arr(2) + 1
arr(arr(2)) = a: .Item(mass(a, n)) = arr
End If
Next a
If ff = True Then arr0 = .Keys(): GoTo end1
arr = .Keys(): ReDim arr0(0 To UBound(arr))
arr0(0) = arr(0)
If d = False Then
For a = 1 To UBound(arr)
mm = arr(a)
For b = a To 1 Step -1
If mm < arr0(b - 1) Then arr0(b) = arr0(b - 1) Else arr0(b) = mm: GoTo loop0
Next b
arr0(b) = mm
loop0: Next a
Else
For a = 1 To UBound(arr)
mm = arr(a)
For b = a To 1 Step -1
If mm > arr0(b - 1) Then arr0(b) = arr0(b - 1) Else arr0(b) = mm: GoTo loop1
Next b
arr0(b) = mm
loop1: Next a
End If
end1: ReDim sArray(1 To UBound(mass, 1), 1 To UBound(mass, 2))
x = 1
For a = 0 To UBound(arr0)
arr = .Item(arr0(a))
For b = 1 To arr(1)
For c = 1 To UBound(sArray, 2)
sArray(x, c) = mass(arr(2 + b), c)
Next c
x = x + 1
Next b
Next a
End With
If sp = 0 Then Exit Sub
For a = 1 To UBound(sArray, 1)
If sArray(a, n) = pp Then sArray(a, n) = Empty
Next a
End Sub
oldy7 написал: Под спойлером картинка после проведения тестов
Почему картинка? Разве нельзя в файле положить, ведь размер катастрофисски меньше получается, тем более файл приложен... Или просто в текстовом виде... В тегах CODE шрифт моноширный и можно любую табличку сделать и скопировать можно, а в картинке какой смысл?
И еще вопросик по существу: По сути, сортировка двумерного массива отличается от одномерного количеством сортируемых столбцов, где отсортированные индексы передаются к процедуре сортировки след. столбца. Поэтому тест достаточен для одного столбца, тем более в разных столбцах могут быть данные разного типа и время может существенно отличаться, в зависимости от алгоритма сортировки, а переписывается массив только один раз и это время от алгоритма не зависит. По сему вопрос: зачем проводить полный тест каждый раз или я что-то не так понял?
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
Да, но хочется оценить полную производительность. Переливка массива по индексам тоже занимает время. Видимо следующий вопрос будет о том, что зачем выгружать каждый раз массив на лист? В любом случае для желающих всегда есть возможность оставить и один столбец , и отключить выгрузку на лист. Файл то прилагается.
Пока самое узкое место - сам сортировщик ключей. Как можно заметить в тестовом файле ниже последнего из представленных субсортировщиков есть наметки на сортировщик с элементами аналитики. Т.е. в зависимости от типа входного массива будут задействованы разные подходы и алгоритмы. В основном для текста, т.к. его сортировка занимает больше всего времени. -------- Jack Famous, не пробовал. Добытая по сети версия офиса на 32 битную систему, хотя сама ось на 64. В теории - раз Dictionary компонент системы, а не Office, то менять ничего не нужно.
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
Решение дал (как часто бывает) гугл))) добавил PtrSafe после Declare и всё работает
Во всех делах очень полезно периодически ставить знак вопроса к тому, что вы с давних пор считали не требующим доказательств (Бертран Рассел) ►Благодарности сюда◄
oldy7 написал: Да, но хочется оценить полную производительность. Переливка массива по индексам тоже занимает время.
Да, хочется, но в процессе разработки алгоритма, вряд ли стоит мешать такие вещи, ведь переписка массива легко определяется стандартным циклом и ни как не связана с алгоритмом, поэтому на мой взгляд, стоит время чистой сортировки измерять отдельно, а перезапись массива отдельно (тем более, что на сортировку N столбцов приходится всего одна перезапись массива). Кроме того существует еще куча ньюансов, такие как, бинарная и текстовая сортировки, и если такие вещи не измерять отдельно, то картина будет весьма размытой... Кроме того, при необходимости получения текстовой сортировки нет смысла использовать этот принцип, пока не произойдет сортировка и только после ее окончания следует его использовать, ведь он значительно медленней бинарного. Лучше потратить время на одну итерацию, чем нести с собой этот тормоз через все итерации. Но мое мнение может быть применимо в случае определенного алгоритма. Вот тогда Ваша табличка будет представлять собой реальные измерения. Честно говоря, я утонул в Вашем коде, но если б мухи отдельно, а борщ отдельно, то было бы проще воспринять, а если нет, то показатели были б достовернее...