Как каждый оценивает массив (вид) значением? *Со скручиванием*
В дополнение к «необработанным» инструментам, предоставленным MutationObserver API , существуют «удобные» библиотеки для работы с DOM-мутациями.
Рассмотрим: MutationObserver представляет каждый DOM изменение в терминах поддеревьев. Итак, если вы, например, ожидаете, что какой-то элемент будет вставлен, он может быть глубоко внутри детей mutations.mutation[i].addedNodes[j].
Еще одна проблема заключается в том, что ваш собственный код в ответ на мутации, изменения DOM - вы часто хотите отфильтровать его.
Хорошая библиотека удобства, разрешающая такие проблемы, - mutation-summary (отказ от ответственности: я не автор, просто доволен user), который позволяет вам указывать запросы о том, что вас интересует, и получить именно это.
Пример основного использования из документов:
var observer = new MutationSummary({
callback: updateWidgets,
queries: [{
element: '[data-widget]'
}]
});
function updateWidgets(summaries) {
var widgetSummary = summaries[0];
widgetSummary.added.forEach(buildNewWidget);
widgetSummary.removed.forEach(cleanupExistingWidget);
}
5 ответов
Так как Вы используете C++, я сделал бы это что-то вроде этого. SortIntPointers функция может быть любым алгоритмом сортировки, важная часть - то, что это сортирует массив указателей на основе int то, что они указывают. После того как это сделано, можно пройти массив указателей и присвоить их отсортированный индекс, который закончится в исходном положении в исходном массиве.
int* intArray; // set somewhere else
int arrayLen; // set somewhere else
int** pintArray = new int*[arrayLen];
for(int i = 0; i < arrayLen; ++i)
{
pintArray[i] = &intArray[i];
}
// This function sorts the pointers according to the values they
// point to. In effect, it sorts intArray without losing the positional
// information.
SortIntPointers(pintArray, arrayLen);
// Dereference the pointers and assign their sorted position.
for(int i = 0; i < arrayLen; ++i)
{
*pintArray[i] = i;
}
Надо надеяться, это достаточно ясно.
Хорошо, вот моя попытка в C++
#include <iostream>
#include <algorithm>
struct mycomparison
{
bool operator() (int* lhs, int* rhs) {return (*lhs) < (*rhs);}
};
int main(int argc, char* argv[])
{
int myarray[] = {1, 3, 6, 2, 4, 9, 5, 12, 10};
const size_t size = sizeof(myarray) / sizeof(myarray[0]);
int *arrayofpointers[size];
for(int i = 0; i < size; ++i)
{
arrayofpointers[i] = myarray + i;
}
std::sort(arrayofpointers, arrayofpointers + size, mycomparison());
for(int i = 0; i < size; ++i)
{
*arrayofpointers[i] = i + 1;
}
for(int i = 0; i < size; ++i)
{
std::cout << myarray[i] << " ";
}
std::cout << std::endl;
return 0;
}
создайте новый массив с увеличиванием значений от 0 до n-1 (где n является длиной массива, Вы хотите отсортировать). Затем отсортируйте новый массив на основе значений в старом массиве, индексированном значениями в новом массиве.
Например, при использовании пузырьковой сортировки (легкий объяснить), затем вместо того, чтобы сравнить значения в новом массиве, Вы сравниваете значения в старом массиве в положении, индексированном значением в новом массиве:
function bubbleRank(A){
var B = new Array();
for(var i=0; i<A.length; i++){
B[i] = i;
}
do{
swapped = false;
for(var i=0; i<A.length; i++){
if(A[B[i]] > A[B[i+1]]){
var temp = B[i];
B[i] = B[i+1];
B[i+1] = temp;
swapped = true;
}
}
}while(swapped);
return B;
}
Ну, существует trival n^2 решение.
В Python:
newArray = sorted(oldArray)
blankArray = [0] * len(oldArray)
for i in xrange(len(newArray)):
dex = oldArray.index(newArray[i])
blankArray[dex] = i
В зависимости от того, насколько большой Ваш список, это может работать. Если Ваш список будет очень длинен, то необходимо будет сделать некоторую странную параллельную сортировку массива, которая не похожа на большую забаву и является быстрым способом представить дополнительные ошибки в коде.
Также обратите внимание, что вышеупомянутый код принимает уникальные значения в oldArray. Если это не так необходимо будет сделать некоторую обработку сообщения для решения связанных значений.
Параллельная сортировка вектора с помощью повышения:: лямбда...
std::vector<int> intVector;
std::vector<int> rank;
// set up values according to your example...
intVector.push_back( 1 );
intVector.push_back( 3 );
intVector.push_back( 4 );
intVector.push_back( 9 );
intVector.push_back( 6 );
for( int i = 0; i < intVector.size(); ++i )
{
rank.push_back( i );
}
using namespace boost::lambda;
std::sort(
rank.begin(), rank.end(),
var( intVector )[ _1 ] < var( intVector )[ _2 ]
);
//... and because you wanted to replace the values of the original with
// their rank
intVector = rank;
Примечание: Я использовал векторы вместо массивов, потому что это более ясно/легче, также, я использовал индексацию C-стиля, которая начинает рассчитывать от 0, не 1.