本文整理汇总了C++中SortArray类的典型用法代码示例。如果您正苦于以下问题:C++ SortArray类的具体用法?C++ SortArray怎么用?C++ SortArray使用的例子?那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了SortArray类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: BinaryInsertionSort
// swaps every time (keeps all values visible)
void BinaryInsertionSort(SortArray& A)
{
for (size_t i = 1; i < A.size(); ++i)
{
value_type key = A[i];
A.mark(i);
int lo = 0, hi = i;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (key <= A[mid])
hi = mid;
else
lo = mid + 1;
}
// item has to go into position lo
ssize_t j = i - 1;
while (j >= lo)
{
A.swap(j, j+1);
j--;
}
A.unmark(i);
}
}
示例2: profiling_end
void ScriptDebuggerLocal::profiling_end() {
int ofs = 0;
for (int i = 0; i < ScriptServer::get_language_count(); i++) {
ofs += ScriptServer::get_language(i)->profiling_get_accumulated_data(&pinfo[ofs], pinfo.size() - ofs);
}
SortArray<ScriptLanguage::ProfilingInfo, _ScriptDebuggerLocalProfileInfoSort> sort;
sort.sort(pinfo.ptr(), ofs);
uint64_t total_us = 0;
for (int i = 0; i < ofs; i++) {
total_us += pinfo[i].self_time;
}
float total_time = total_us / 1000000.0;
for (int i = 0; i < ofs; i++) {
print_line(itos(i) + ":" + pinfo[i].signature);
float tt = USEC_TO_SEC(pinfo[i].total_time);
float st = USEC_TO_SEC(pinfo[i].self_time);
print_line("\ttotal_ms: " + rtos(tt) + "\tself_ms: " + rtos(st) + "total%: " + itos(tt * 100 / total_time) + "\tself%: " + itos(st * 100 / total_time) + "\tcalls: " + itos(pinfo[i].call_count));
}
for (int i = 0; i < ScriptServer::get_language_count(); i++) {
ScriptServer::get_language(i)->profiling_stop();
}
profiling = false;
}
示例3: CombSort
void CombSort(SortArray& A)
{
const double shrink = 1.3;
bool swapped = false;
size_t gap = A.size();
while ((gap > 1) || swapped)
{
if (gap > 1) {
gap = (size_t)((float)gap / shrink);
}
swapped = false;
for (size_t i = 0; gap + i < A.size(); ++i)
{
if (A[i] > A[i + gap])
{
A.swap(i, i+gap);
swapped = true;
}
}
}
}
示例4: OddEvenSort
void OddEvenSort(SortArray& A)
{
bool sorted = false;
while (!sorted)
{
sorted = true;
for (size_t i = 1; i < A.size()-1; i += 2)
{
if(A[i] > A[i+1])
{
A.swap(i, i+1);
sorted = false;
}
}
for (size_t i = 0; i < A.size()-1; i += 2)
{
if(A[i] > A[i+1])
{
A.swap(i, i+1);
sorted = false;
}
}
}
}
示例5: CocktailShakerSort
void CocktailShakerSort(SortArray& A)
{
size_t lo = 0, hi = A.size()-1, mov = lo;
while (lo < hi)
{
for (size_t i = hi; i > lo; --i)
{
if (A[i-1] > A[i])
{
A.swap(i-1, i);
mov = i;
}
}
lo = mov;
for (size_t i = lo; i < hi; ++i)
{
if (A[i] > A[i+1])
{
A.swap(i, i+1);
mov = i;
}
}
hi = mov;
}
}
示例6: ERR_FAIL_NULL
void Array::sort_custom(Object *p_obj,const StringName& p_function){
ERR_FAIL_NULL(p_obj);
SortArray<Variant,_ArrayVariantSortCustom> avs;
avs.compare.obj=p_obj;
avs.compare.func=p_function;
avs.sort(_p->array.ptr(),_p->array.size());
}
示例7: ERR_FAIL_NULL_V
Array &Array::sort_custom(Object *p_obj, const StringName &p_function) {
ERR_FAIL_NULL_V(p_obj, *this);
SortArray<Variant, _ArrayVariantSortCustom, true> avs;
avs.compare.obj = p_obj;
avs.compare.func = p_function;
avs.sort(_p->array.ptrw(), _p->array.size());
return *this;
}
示例8: if
void VoxelMeshUpdater::thread_sync(int queue_index, Stats stats) {
if (!_input.blocks.empty()) {
// Cleanup input vector
if (queue_index >= _input.blocks.size()) {
_input.blocks.clear();
} else if (queue_index > 0) {
// Shift up remaining items since we use a Vector
shift_up(_input.blocks, queue_index);
}
}
stats.remaining_blocks = _input.blocks.size();
bool needs_sort;
{
// Get input
MutexLock lock(_input_mutex);
_input.blocks.append_array(_shared_input.blocks);
_input.priority_position = _shared_input.priority_position;
_shared_input.blocks.clear();
_block_indexes.clear();
needs_sort = _needs_sort;
_needs_sort = false;
}
if(!_output.blocks.empty()) {
// print_line(String("VoxelMeshUpdater: posting {0} blocks, {1} remaining ; cost [{2}..{3}] usec")
// .format(varray(_output.blocks.size(), _input.blocks.size(), stats.min_time, stats.max_time)));
// Post output
MutexLock lock(_output_mutex);
_shared_output.blocks.append_array(_output.blocks);
_shared_output.stats = stats;
_output.blocks.clear();
}
if (!_input.blocks.empty() && needs_sort) {
// Re-sort priority
SortArray<VoxelMeshUpdater::InputBlock, BlockUpdateComparator> sorter;
sorter.compare.center = _input.priority_position;
sorter.sort(_input.blocks.ptrw(), _input.blocks.size());
}
}
示例9: BubbleSort
void BubbleSort(SortArray& A)
{
for (size_t i = 0; i < A.size()-1; ++i)
{
for (size_t j = 0; j < A.size()-1 - i; ++j)
{
if (A[j] > A[j + 1])
{
A.swap(j, j+1);
}
}
}
}
示例10: SelectionSort
void SelectionSort(SortArray& A)
{
volatile ssize_t jMin = 0;
A.watch(&jMin, 3);
for (size_t i = 0; i < A.size()-1; ++i)
{
jMin = i;
for (size_t j = i+1; j < A.size(); ++j)
{
if (A[j] < A[jMin]) {
A.mark_swap(j, jMin);
jMin = j;
}
}
A.swap(i, jMin);
// mark the last good element
if (i > 0) A.unmark(i-1);
A.mark(i);
}
A.unwatch_all();
}
示例11: GnomeSort
void GnomeSort(SortArray& A)
{
for (size_t i = 1; i < A.size(); )
{
if (A[i] >= A[i-1])
{
++i;
}
else
{
A.swap(i, i-1);
if (i > 1) --i;
}
}
}
示例12: if
void VoxelProviderThread::thread_sync(int emerge_index, Stats stats) {
if (!_input.blocks_to_emerge.empty()) {
// Cleanup emerge vector
if (emerge_index >= _input.blocks_to_emerge.size()) {
_input.blocks_to_emerge.clear();
} else if (emerge_index > 0) {
// Shift up remaining items since we use a Vector
shift_up(_input.blocks_to_emerge, emerge_index);
}
}
{
// Get input
MutexLock lock(_input_mutex);
_input.blocks_to_emerge.append_array(_shared_input.blocks_to_emerge);
_input.blocks_to_immerge.append_array(_shared_input.blocks_to_immerge);
_input.priority_block_position = _shared_input.priority_block_position;
_shared_input.blocks_to_emerge.clear();
_shared_input.blocks_to_immerge.clear();
}
stats.remaining_blocks = _input.blocks_to_emerge.size();
// print_line(String("VoxelProviderThread: posting {0} blocks, {1} remaining ; cost [{2}..{3}] usec")
// .format(varray(_output.size(), _input.blocks_to_emerge.size(), stats.min_time, stats.max_time)));
{
// Post output
MutexLock lock(_output_mutex);
_shared_output.append_array(_output);
_shared_stats = stats;
_output.clear();
}
if (!_input.blocks_to_emerge.empty()) {
// Re-sort priority
SortArray<Vector3i, BlockPositionComparator> sorter;
sorter.compare.center = _input.priority_block_position;
sorter.sort(_input.blocks_to_emerge.ptrw(), _input.blocks_to_emerge.size());
}
}
示例13: _generate_contacts_edge_edge
static void _generate_contacts_edge_edge(const Vector3 *p_points_A, int p_point_count_A, const Vector3 *p_points_B, int p_point_count_B, _CollectorCallback *p_callback) {
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(p_point_count_A != 2);
ERR_FAIL_COND(p_point_count_B != 2); // circle is actually a 4x3 matrix
#endif
Vector3 rel_A = p_points_A[1] - p_points_A[0];
Vector3 rel_B = p_points_B[1] - p_points_B[0];
Vector3 c = rel_A.cross(rel_B).cross(rel_B);
//if ( Math::abs(rel_A.dot(c) )<_EDGE_IS_VALID_SUPPORT_TRESHOLD ) {
if (Math::abs(rel_A.dot(c)) < CMP_EPSILON) {
// should handle somehow..
//ERR_PRINT("TODO FIX");
//return;
Vector3 axis = rel_A.normalized(); //make an axis
Vector3 base_A = p_points_A[0] - axis * axis.dot(p_points_A[0]);
Vector3 base_B = p_points_B[0] - axis * axis.dot(p_points_B[0]);
//sort all 4 points in axis
real_t dvec[4] = { axis.dot(p_points_A[0]), axis.dot(p_points_A[1]), axis.dot(p_points_B[0]), axis.dot(p_points_B[1]) };
SortArray<real_t> sa;
sa.sort(dvec, 4);
//use the middle ones as contacts
p_callback->call(base_A + axis * dvec[1], base_B + axis * dvec[1]);
p_callback->call(base_A + axis * dvec[2], base_B + axis * dvec[2]);
return;
}
real_t d = (c.dot(p_points_B[0]) - p_points_A[0].dot(c)) / rel_A.dot(c);
if (d < 0.0)
d = 0.0;
else if (d > 1.0)
d = 1.0;
Vector3 closest_A = p_points_A[0] + rel_A * d;
Vector3 closest_B = Geometry::get_closest_point_to_segment_uncapped(closest_A, p_points_B);
p_callback->call(closest_A, closest_B);
}
示例14: InsertionSort
// swaps every time (keeps all values visible)
void InsertionSort(SortArray& A)
{
for (size_t i = 1; i < A.size(); ++i)
{
value_type key = A[i];
A.mark(i);
ssize_t j = i - 1;
while (j >= 0 && A[j] > key)
{
A.swap(j, j+1);
j--;
}
A.unmark(i);
}
}
示例15: PartitionLL
size_t PartitionLL(SortArray& A, size_t lo, size_t hi)
{
// pick pivot and move to back
size_t p = QuickSortSelectPivot(A, lo, hi);
value_type pivot = A[p];
A.swap(p, hi-1);
A.mark(hi-1);
volatile ssize_t i = lo;
A.watch(&i, 3);
for (size_t j = lo; j < hi-1; ++j)
{
if (A[j] <= pivot) {
A.swap(i, j);
++i;
}
}
A.swap(i, hi-1);
A.unmark(hi-1);
A.unwatch_all();
return i;
}