hkSort.inl
上传用户:yisoukefu
上传日期:2020-08-09
资源大小:39506k
文件大小:6k
源码类别:

其他游戏

开发平台:

Visual C++

  1. /* 
  2.  * 
  3.  * Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
  4.  * prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
  5.  * Level 2 and Level 3 source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2009 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
  6.  * 
  7.  */
  8. #ifndef HK_SORT_INL
  9. #define HK_SORT_INL
  10. // Heap Sort, O(n log(n)), not recursive
  11. // see http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap.html for explanation
  12. namespace hkAlgorithm
  13. {
  14. template<typename T, typename L>
  15. void HK_CALL downHeap(T *pArr, int k, int n, L cmpLess)
  16. {
  17. // precondition: array pArr[k+1,n] is a heap
  18. // postcondition: array pArr[k,n] is a heap
  19. T temp = pArr[k - 1];
  20. //find them maximum of the new 'parent' and all of its children
  21. while (k <= n/2)
  22. {
  23. int child = 2*k;
  24. //don't process children 'outside' of the array
  25. if ((child < n) && cmpLess(pArr[child - 1], pArr[child]))
  26. {
  27. child++;
  28. }
  29. //take the maximum
  30. if (cmpLess(temp, pArr[child - 1]))
  31. {
  32. pArr[k - 1] = pArr[child - 1];
  33. k = child;
  34. }
  35. else
  36. {
  37. break;
  38. }
  39. }
  40. pArr[k - 1] = temp;
  41. }
  42. template<typename T, typename L>
  43. void HK_CALL heapSort(T *pArr, int iSize, L cmpLess)
  44. {
  45. int k;
  46. int n = iSize;
  47. //create a heap
  48. for (k = n/2; k > 0; k--)
  49. {
  50.     downHeap(pArr, k, n, cmpLess);
  51.     }
  52. // now swap the
  53. while ( n>=1 )
  54. {
  55. //a[0] is now known to be largest, so put it to the end, and downheap 0..n-1
  56. T temp = pArr[0];
  57. pArr[0] = pArr[n - 1];
  58. pArr[n - 1] = temp;
  59. n = n - 1;
  60. downHeap(pArr, 1, n, cmpLess);
  61. }
  62. }
  63. template<typename T, typename L>
  64. void HK_CALL quickSortRecursive(T *pArr, int d, int h, L cmpLess)
  65. {
  66. int i,j;
  67. HK_ALIGN16( T str );
  68. begin:
  69. i = h;
  70. j = d;
  71. str = pArr[(d+h)>>1];
  72. do {
  73. while ( cmpLess( pArr[j], str) ){ j++; }
  74. while ( cmpLess( str, pArr[i]) ){ i--; }
  75. if ( i >= j )
  76. {
  77. if ( i != j )
  78. {
  79. HK_ALIGN16( T zal );
  80. T& pi = pArr[i];
  81. T& pj = pArr[j];
  82. zal = pi; pi = pj, pj = zal;
  83. }
  84. i--;
  85. j++;
  86. }
  87. } while (j <= i);
  88. if (d < i)
  89. {
  90. quickSortRecursive(pArr,d,i, cmpLess);
  91. }
  92. if (j < h)
  93. {
  94. d = j;
  95. goto begin;
  96. }
  97. }
  98. template<typename T, typename L>
  99. void HK_CALL quickSort(T *pArr, int iSize, L cmpLess)
  100. {
  101. if (iSize > 1)
  102. {
  103. int low = 0;
  104. int high = iSize - 1;
  105. quickSortRecursive(pArr,low,high, cmpLess);
  106. }
  107. }
  108. template<typename T, typename L>
  109. void HK_CALL explicitStackQuickSort(T* base, int numMem, L cmpLess)
  110. {
  111.     HK_ALIGN16( T swap );
  112.     HK_ALIGN16( T pivot );
  113.     const int maxDepth = sizeof(base)*8;
  114. if (numMem <=1 ) return;
  115.     T* lbStack[maxDepth],* ubStack[maxDepth];
  116.     lbStack[0] = base;
  117.     ubStack[0] = base+(numMem-1);
  118.     for (int stackPos = 0; stackPos >= 0; stackPos--)
  119.     {
  120.         T* lb = lbStack[stackPos];
  121.         T* ub = ubStack[stackPos];
  122.         while (true)
  123.         {
  124.             T* j = lb;
  125.             T* i = ub;
  126.             pivot = lb[(ub-lb)>>1];
  127.             do
  128.             {
  129.                 while ( cmpLess( *j, pivot) ){ j++; }
  130.                 while ( cmpLess( pivot, *i) ){ i--; }
  131.                 if ( i >= j )
  132.                 {
  133.                     if ( i != j )
  134.                     {
  135.                         swap = *i;
  136.                         *i = *j;
  137.                         *j = swap;
  138.                     }
  139.                     i--;
  140.                     j++;
  141.                 }
  142.             } while (j <= i);
  143.             if (lb < i)
  144.             {
  145.                 if (j < ub)
  146.                 {
  147.                         // Both are sortable
  148.                         // Stack the smaller of the two sub-parts
  149.                     if (ub - j > i-lb)
  150.                     {
  151.                         lbStack[stackPos] = j;
  152.                         ubStack[stackPos++] = ub;
  153.                         //
  154.                         ub = i;
  155.                     }
  156.                     else
  157.                     {
  158.                         // Stack it
  159.                         lbStack[stackPos] = lb;
  160.                         ubStack[stackPos++] = i;
  161.                         //
  162.                         lb = j;
  163.                     }
  164.                     continue;
  165.                 }
  166.                 else
  167.                 {
  168.                     ub = i;
  169.                     continue;
  170.                 }
  171.             }
  172.             else
  173.             {
  174.                 if (j < ub)
  175.                 {
  176.                     lb = j;
  177.                     continue;
  178.                 }
  179.             }
  180.             break;
  181.         }
  182.     }
  183. }
  184. template< typename T, typename L >
  185. void HK_CALL bubbleSort( T *pArr, int iSize, L cmpLess )
  186. {
  187. for ( int i = 1; i < iSize; i++ )
  188. {
  189. for ( int j = 0; j < iSize - i; j++ )
  190. {
  191. if ( cmpLess( pArr[ j + 1 ], pArr[ j ] ) )
  192. {
  193. swap( pArr[ j + 1 ], pArr[ j ] );
  194. }
  195. }
  196. }
  197. }
  198. }  // namespace hkAlgorithm
  199. #endif // HK_SORT_INL
  200. /*
  201. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  202. * Confidential Information of Havok.  (C) Copyright 1999-2009
  203. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  204. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  205. * rights, and intellectual property rights in the Havok software remain in
  206. * Havok and/or its suppliers.
  207. * Use of this software for evaluation purposes is subject to and indicates
  208. * acceptance of the End User licence Agreement for this product. A copy of
  209. * the license is included with this software and is also available at www.havok.com/tryhavok.
  210. */