void TestShellSort()
{
int arr[] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
int len = sizeof(arr) / sizeof(arr[0]);
ShellSort(arr, len);
PrintArrray(arr, len);
}
void main() {
SqList* l = new SqList;
l->r[0] = { 0 };
l->r[1] = { 9 };
l->r[2] = { 1 };
l->r[3] = { 5 };
l->r[4] = { 8 };
l->r[5] = { 3 };
l->r[6] = { 7 };
l->r[7] = { 4 };
l->r[8] = { 6 };
l->r[9] = { 2 };
l->length = 10;
SqList* L = new SqList;
L->r[0] = {0};
L->r[1] = {5};
L->r[2] = {3};
L->r[3] = {4};
L->r[4] = {6};
L->r[5] = {2};
L->length = 6;
for (int i = 0; i < L->length; i++) {
printf("%d,", L->r[i]);
}
printf("\n");
//InsertSort(L);
ShellSort(L);
for (int i = 0; i < L->length; i++) {
printf("%d,", L->r[i]);
}
getchar();
}
main()
{
SqList L;
int i;
L.length = MAXSIZE-1; //number of data, r[0] as the "temp variable or wathcer"
srand((unsigned int)time(NULL)); //initliaze seeds, or the default seed will cause the same number.
for(i = 1; i <= L.length; i++)
{
L.r[i] = rand()%1000;
}
puts("before sorted:");
for(i = 1; i <= L.length; i++)
{
printf("%d ", L.r[i]);
}
ShellSort(&L);
puts("\nsorted:");
for(i = 1; i <= L.length; i++)
{
printf("%d ", L.r[i]);
}
putchar('\n');
}
void testShellSortWithArray() {
array a;
createArray(a);
printArray(a);
ShellSort(a);
printf("after shell sort:\n");
printArray(a);
}
/* classic Sedgewick ternary sort, tweaked a bit for speed */
INLINE static
void TernarySort(uint16 **lowerb_t,
uint16 **upperb_t,
uint32 depth_t)
{
sint32 sp = 1;
uint32 v, depth;
uint16 **lb, **ub, **i, **j, **lowerb, **upperb;
lowerb = lowerb_t;
upperb = upperb_t;
depth = depth_t;
while (sp > 0)
{
{
sint32 r = upperb - lowerb + 1;
if (r <= MAX_INSERTSORT)
{
if (r >= 2) ShellSort(lowerb, upperb, depth);
POP(lowerb, upperb, depth);
continue;
}
if (r > 64)
{ /* median-of-3 median-of-3 */
uint v1, v2, v3;
r >>= 3;
lb = lowerb;
{
uint v_1, v_2, v_3;
v_1 = KEY(lb); v_2 = KEY(lb+=r); v_3 = KEY(lb+=r);
v1 = MEDIAN(v_1, v_2, v_3);
}
{
uint v_1, v_2, v_3;
v_1 = KEY(lb+=r); v_2 = KEY(lb+=r); v_3 = KEY(lb+=r);
v2 = MEDIAN(v_1, v_2, v_3);
}
{
uint v_1, v_2, v_3;
v_1 = KEY(lb+=r); v_2 = KEY(lb+=r); v_3 = KEY(upperb);
v3 = MEDIAN(v_1, v_2, v_3);
}
v = MEDIAN(v1, v2, v3);
}
else
{ /* median-of-3 */
uint v1, v2, v3;
v1 = KEY(lowerb);
v2 = KEY(lowerb + (r >> 1));
v3 = KEY(upperb);
v = MEDIAN(v1, v2, v3);
}
}
void TestShellSort()
{
int array[] = {2,5,6,9,1,3,4,7,8,0};
ShellSort(array,sizeof(array)/sizeof(array[0]));
for(int i = 0; i<sizeof(array)/sizeof(array[0]); i++)
{
cout<<array[i] <<" " ;
}
cout <<endl;
}
int main(int argc, char const *argv[])
{
int A[6] = {34, 8, 64, 51, 32, 21};
ShellSort(A, 6);
for (int i = 0; i < 6; ++i)
{
printf("%d \n", A[i]);
}
return 0;
}
END_TEST
START_TEST(ShellSortDescendingTest) {
int* _Table = alloca(sizeof(int) * LARGE);
for(int i = 0; i < LARGE; ++i)
_Table[i] = LARGE - i - 1 ;
ShellSort(_Table, LARGE);
for(int i = 0; i < LARGE; ++i)
ck_assert_int_eq(_Table[i], i);
}
int main()
{
int i, a[]={5,2,6,0,3,9,1,7,4,8};
int len=sizeof(a)/sizeof(int);
ShellSort(a, len);
printf("排序后的结果是:\n");
for(i=0; i<len; i++)
{
printf("%d ", a[i]);
}
printf("\n\n");
}
int main()
{
int num[] = {3,1,5,7,2,8,6,4};
int n = sizeof(num)/sizeof(num[0]);
printf("原序列为：");
for (int j=0; j<n; j++)
{
printf("%3d", num[j]);
}
printf("\n");
ShellSort(num,n);
}
int main(){
int a[10];
int delta[3] = {5, 3, 1};
int i;
for (i = 0; i < 10; i++)
scanf("%d",a+i);
//InsertSort(a, 10);
//BinSort(a, 10);
ShellSort(a, 10, delta, 3);
PrintArray(a, 10);
return 0;
}
void main()
{
int a[100];
int h[100];
int n,k;
RandomArray(a,n);
PrintArray(a,n);
GetSteps(h,k,n);
ShellSort(a,n,h,k);
PrintArray(a,n);
getch();
}
void main()
{
int i;
int dlta[max];
SqList l,a,b,c,d,e,f;
CreateSq(&l);
a=b=c=d=e=f=l;
BubbleSort(&a);
SelectSort(&b);
QuickSort(&c);
ShellSort(&d,dlta);
Heapsort(&e);
insertsort(&f);
}
int main(void)
{
SqList l ;
l.data={17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1};
l.length = 17;
printContent(&l);
printf("\n");
ShellSort(&l);
printContent(&l);
printf("\n");
return 0;
}
void XSort(ElementType S[], long N, int X)
{
switch (X)
{
case 0: BubbleSort(S, N); break;
case 1: InsertionSort(S, N); break;
case 2: ShellSort(S, N); break;
case 3: HeapSort(S, N); break;
case 4: MergeSortByRecursiveImpl(S, N); break;
case 5: MergeSortByNonRecursiveImpl(S, N); break;
case 6: QuickSort(S, N); break;
default: BubbleSort(S, N); break;
}
}
int main(int argc, const char* argv[])
{
int i;
SqList *L;
L = (SqList *) malloc(sizeof(SqList));
L->r[0] = 0;
for (int i = 1; i < 11; i++)
L->r[i] = 11 - i;
L->length = 11;
ShellSort(L);
for (int i =1; i < 11; i++)
printf("%d ", L->r[i]);
puts("");
return 0;
}
END_TEST
START_TEST(ShellSortRandomTest) {
int* _Test = alloca(sizeof(int) * LARGE);
srand(time(NULL));
for(int i = 0; i < LARGE; ++i)
_Test[i] = rand();
ShellSort(_Test, LARGE);
for(int i = 1; i < LARGE; ++i) {
for(int k = 0; k < i; ++k) {
ck_assert_int_le(_Test[k], _Test[i]);
}
}
}
int main(int argc, char const *argv[])
{
int i;
int a[10];
printf("需要排序的数组: \n");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
// 排序方法
ShellSort(a, 10);
printf("数组排好序后: \n");
for(i=0;i<10;i++)
printf("%d ", a[i]);
printf("\n");
return 0;
}
void main()
{
int i,k,n=10;
KeyType a[]={9,8,7,6,5,4,3,2,1,0};
RecType R[MAXE];
for (i=0;i<n;i++)
R[i].key=a[i];
printf("\n");
printf(" 初始关键字 "); /*输出初始关键字序列*/
for (k=0;k<n;k++)
printf("%3d",R[k].key);
printf("\n");
ShellSort(R,n);
printf(" 最后结果 "); /*输出初始关键字序列*/
for (k=0;k<n;k++)
printf("%3d",R[k].key);
printf("\n\n");
}
int main(int argc, char* argv[])
{
int i;
int len;
char* method = NULL;
int array[] = {5,10,34,12,4,2,99,1,1024};
int dlta[] = {5,3,1};
method = argv[1];
len = sizeof(array)/sizeof(int);
printf("Algorithm is %s.\n", method);
switch(GetMethod(method))
{
case InsertionSortMethod:
InsertSort(array, len);
break;
case ShellSortMethod:
ShellSort(array, len, dlta, 3);
break;
case BubbleSortMethod:
BubbleSort(array, len);
break;
case QuickSortMethod:
QuickSort(array, 0, len-1);
break;
default:
printf("can't support algorithm %s.\n", method);
}
printf("Algorithm %s result is :", method);
for(i=0; i<len; i++)
printf("%d,", array[i]);
printf("\n");
return 0;
}
int main()
{
int iData[MAX_CNT];
SetData(iData,MAX_CNT);
time_t sTmp = clock();
//선택 정렬
SelectSort(iData,MAX_CNT);
time_t eTmp = clock();
printf("\n%s : %8.3f[%ld]\n","선택 정렬",(eTmp-sTmp)/(double)CLK_TCK,eTmp-sTmp);
PrintData(iData, 10);
SetData(iData, MAX_CNT);
sTmp = clock();
//거품 정렬
BubbleSort(iData, MAX_CNT);
eTmp = clock();
printf("\n%s : %8.3f[%ld]\n", "거품 정렬", (eTmp - sTmp) / (double)CLK_TCK, eTmp - sTmp);
PrintData(iData, 10);
SetData(iData, MAX_CNT);
sTmp = clock();
//삽입 정렬
InsertSort(iData, MAX_CNT);
eTmp = clock();
printf("\n%s : %8.3f[%ld]\n", "삽입 정렬", (eTmp - sTmp) / (double)CLK_TCK, eTmp - sTmp);
PrintData(iData, 10);
SetData(iData, MAX_CNT);
sTmp = clock();
//쉘 정렬
ShellSort(iData, MAX_CNT);
eTmp = clock();
printf("\n%s : %8.3f[%ld]\n", "쉘 정렬", (eTmp - sTmp) / (double)CLK_TCK, eTmp - sTmp);
PrintData(iData, 10);
SetData(iData, MAX_CNT);
sTmp = clock();
//퀵 정렬
QuickSort(iData,0, MAX_CNT-1);
eTmp = clock();
printf("\n%s : %8.3f[%ld]\n", "퀵 정렬", (eTmp - sTmp) / (double)CLK_TCK, eTmp - sTmp);
PrintData(iData, 10);
return 0;
}
int main(int argc, char **argv)
{
int mas[20];
int i;
printf( "Исходный массив: \n" );
for ( i=0; i < 20; i++ ) {
mas[i] = rand() % 20 + 1;
printf( "%d ", mas[i]);
}
ShellSort(mas,20);
printf( "\n Имеем на выходе: \n" );
for ( i=0; i<20; i++ ) {
printf( "%d ", mas[i] );
}
return 0;
}
static void *DoSortList( void *list, unsigned next_offset,
bool (*before)(void *,void *),
unsigned length ) {
/**************************************************************************/
void **array;
void **parray;
void *list2;
unsigned mid;
int i;
if( list == NULL ) return( NULL );
array = CGAlloc( length * sizeof( void * ) );
if( array == NULL ) {
mid = length / 2;
if( mid == 0 ) return( list ); /* FATAL ERROR! */
list2 = list;
for( i = mid; i > 0; --i ) {
list2 = _NEXT( list2, next_offset );
}
list = DoSortList( list, next_offset, before, mid );
list2 = DoSortList( list2, next_offset, before, length - mid );
list = MergeList( list, list2, next_offset, before );
} else {
list2 = list;
parray = array;
for( i = length; i > 0; --i ) {
*parray++ = list2;
list2 = _NEXT( list2, next_offset );
}
ShellSort( array, length, before );
list = BuildList( array, next_offset, length );
CGFree( array );
}
return( list );
}
int main() {
int n = 0;
for (int i = 0, n = 10; i < 5; i++, n = n*10) {
if (n == 100000)
n = 30000;
int Array[n];
int array[n];
srand((unsigned)clock());
for (int i = 0; i < n; i++) {
Array[i] = rand()%n;
}
memcpy(array, Array, n*sizeof(int));
printf("\n");
int low = 0;
int high = 0;
high= sizeof(Array)/sizeof(int);
printf("high = %d\n", high);
high -= 1;
clock_t start, end;
clock_t start1, end1;
start = clock();
printf("QuickSort: ");
for (int j = 0; j < 5; j++) {
memcpy(Array, array, n*sizeof(int));
start1 = clock();
QuickSort(Array, low, high);
end1 = clock();
printf("%f ", (double)(end1-start1));
}
end = clock();
if (n == 10) {
for (int i = 0; i < 10; i++) {
printf("%d ", Array[i]);
}
printf("\n");
}
printf("Average: %f\n", (double)((end-start)/5));
srand((unsigned)time(NULL));
start = clock();
printf("BullbeSort: ");
for (int j = 0; j < 5; j++) {
memcpy(Array, array, n*sizeof(int));
start1 = clock();
BullbeSort(Array, low, high);
end1 = clock();
printf("%f ", (double)(end1-start1));
}
end = clock();
if (n == 10) {
for (int i = 0; i < 10; i++) {
printf("%d ", Array[i]);
}
printf("\n");
}
printf("Average: %f\n", (double)((end-start)/5));
srand((unsigned)time(NULL));
start = clock();
printf("ShellSort: ");
for (int j = 0; j < 5; j++) {
memcpy(Array, array, n*sizeof(int));
start1 = clock();
ShellSort(Array, low, high);
end1 = clock();
printf("%f ", (double)(end1-start1));
}
end = clock();
if (n == 10) {
for (int i = 0; i < 10; i++) {
printf("%d ", Array[i]);
}
printf("\n");
}
printf("Average: %f\n", (double)((end-start)/5));
srand((unsigned)time(NULL));
start = clock();
printf("MergeSort: ");
for (int j = 0; j < 5; j++) {
memcpy(Array, array, n*sizeof(int));
start1 = clock();
MergeSort(Array, low, high);
end1 = clock();
printf("%f ", (double)(end1-start1));
}
end = clock();
if (n == 10) {
for (int i = 0; i < 10; i++) {
printf("%d ", Array[i]);
}
printf("\n");
}
printf("Average: %f\n", (double)((end-start)/5));
srand((unsigned)time(NULL));
start = clock();
printf("InsertSort: ");
for (int j = 0; j < 5; j++) {
memcpy(Array, array, n*sizeof(int));
start1 = clock();
InsertSort(Array, low, high);
end1 = clock();
printf("%f ", (double)(end1-start1));
}
end = clock();
if (n == 10) {
for (int i = 0; i < 10; i++) {
printf("%d ", Array[i]);
}
printf("\n");
}
printf("Average: %f\n", (double)((end-start)/5));
srand((unsigned)time(NULL));
start = clock();
printf("BucketSort: ");
for (int j = 0; j < 5; j++) {
memcpy(Array, array, n*sizeof(int));
start1 = clock();
BucketSort(Array, low, high);
end1 = clock();
printf("%f ", (double)(end1-start1));
}
end = clock();
if (n == 10) {
for (int i = 0; i < 10; i++) {
printf("%d ", Array[i]);
}
printf("\n");
}
printf("Average: %f\n", (double)((end-start)/5));
}
}
int test_algorithm()
{
int len[]={1, 2, 10, 100, 200, 300, 400, 500, 600, 1000};
int num=sizeof(len) / sizeof(int);
int i, j, *number_rand, *number_order, *temp, *number_test;
for(i = 0; i < num; i++)
{
number_rand = calloc(sizeof(int), len[i]);
number_order = calloc(sizeof(int), len[i]);
number_test = calloc(sizeof(int), len[i]);
temp = calloc(sizeof(int), len[i]);
for (j = 0; j<len[i]; j++)
{
*(number_rand + j) = rand() * 1000 + rand();
*(number_order + j) = j;
}
memcpy(number_test, number_rand, sizeof(int) * len[i]);
quickSort(number_test, 0, len[i] - 1);
test_array(number_test, len[i], "quickSort");
memcpy(number_test, number_order, sizeof(int) * len[i]);
quickSort(number_test, 0, len[i] - 1);
test_array(number_test, len[i], "quickSort");
memcpy(number_test, number_rand, sizeof(int) * len[i]);
mergeSort(number_test, 0, len[i]-1, temp);
test_array(number_test, len[i], "mergeSort");
memcpy(number_test, number_order, sizeof(int) * len[i]);
mergeSort(number_test, 0, len[i]-1, temp);
test_array(number_test, len[i], "mergeSort");
memcpy(number_test, number_rand, sizeof(int) * len[i]);
insertSort(number_test, len[i]);
test_array(number_test, len[i], "insertSort");
memcpy(number_test, number_order, sizeof(int) * len[i]);
insertSort(number_test, len[i]);
test_array(number_test, len[i], "insertSort");
memcpy(number_test, number_rand, sizeof(int) * len[i]);
ShellSort(number_test, len[i]);
test_array(number_test, len[i], "ShellSort");
memcpy(number_test, number_order, sizeof(int) * len[i]);
ShellSort(number_test, len[i]);
test_array(number_test, len[i], "ShellSort");
memcpy(number_test, number_rand, sizeof(int) * len[i]);
bubbleSort(number_test, len[i]);
test_array(number_test, len[i], "bubbleSort");
memcpy(number_test, number_order, sizeof(int) * len[i]);
bubbleSort(number_test, len[i]);
test_array(number_test, len[i], "bubbleSort");
memcpy(number_test, number_rand, sizeof(int) * len[i]);
selectSort(number_test, len[i]);
test_array(number_test, len[i], "selectSort");
memcpy(number_test, number_order, sizeof(int) * len[i]);
selectSort(number_test, len[i]);
test_array(number_test, len[i], "selectSort");
memcpy(number_test, number_rand, sizeof(int) * len[i]);
heapSort(number_test, len[i]);
test_array(number_test, len[i], "heapSort");
memcpy(number_test, number_order, sizeof(int) * len[i]);
heapSort(number_test, len[i]);
test_array(number_test, len[i], "heapSort");
memcpy(number_test, number_rand, sizeof(int) * len[i]);
binSort(number_test, len[i]);
test_array(number_test, len[i], "binSort");
memcpy(number_test, number_order, sizeof(int) * len[i]);
binSort(number_test, len[i]);
test_array(number_test, len[i], "binSort");
}
printf("test algorithm finish\n");
free(number_rand);
free(number_order);
free(temp);
free(number_test);
}
void TestShellSort(int arr[], int dwLargeArrLen)
{
// PArr(arr, dwLargeArrLen);
ShellSort(arr, dwLargeArrLen);
// PArr(arr, dwLargeArrLen);
}
int main(){
int arr[]={12, 34 , 2, 11, 5};
ShellSort(arr,5);
for(int i=0; i<5 ;i++)
cout<<arr[i]<<endl;
}
int main(void)
{
datatype data[N];
datatype temp[N];
int i;
srand((unsigned int)time(NULL));
for(i = 0; i < N; i++) {
data[i] = rand() % (NUM_LIMITS + 1);
}
Print(data, N);
Copy(data, temp, N);
printf("InsertionSort: \n");
InsertionSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("BinaryInsertionSort:\n");
BinaryInsertionSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("ShellSort:\n");
ShellSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("SelectionSort:\n");
SelectionSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("BubbleSort:\n");
BubbleSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("QuickSort:\n");
QuickSort(data, 0, N-1);
Print(data, N);
Copy(temp, data, N);
printf("MergeSort:\n");
MergeSort(data, 0, N-1);
Print(data, N);
Copy(temp, data, N);
printf("HeapSort:\n");
HeapSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("PigeonholeSort:\n");
PigeonholeSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("BucketSort:\n");
BucketSort(data, N, NUM_LIMITS);
Print(data, N);
Copy(temp, data, N);
printf("CocktailSort:\n");
CocktailSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("GnomeSort:\n");
GnomeSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("OddEvenSort:\n");
OddEvenSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("PatienceSort:\n");
PatienceSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("BeadSort:\n");
BeadSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("CombSort:\n");
CombSort(data, N);
Print(data, N);
Copy(temp, data, N);
printf("BogoSort(Do you believe fortune?):\n");
// BogoSort(data, N);
// Print(data, N);
return 0;
}
void CPalGroup::SortPal(int nIndex, int nStartIndex, int nSortFlag)
{
if(!rgPalettes[nIndex].bAvail)
{
return; //Most likeley wont happen
}
double * pHSLArray;
int nPalSz = rgPalettes[nIndex].uPalSz;
if(rgPalettes[nIndex].pSortTable)
{
delete [] rgPalettes[nIndex].pSortTable;
}
pHSLArray = new double[nPalSz * 3];
rgPalettes[nIndex].pSortTable = new UINT16[nPalSz];
for(int i = 0; i < nPalSz; i++)
{
rgPalettes[nIndex].pSortTable[i] = (UINT16)i;
RGBtoHLS(rgPalettes[nIndex].pPal[i], &pHSLArray[i], &pHSLArray[i + nPalSz], &pHSLArray[i + (nPalSz*2)]);
//pHSLArray[i] = (double)(rgPalettes[nIndex].pPal[i] & 0x00FFFFFF);
}
//Go through array again
for(int i = 0; i < nPalSz; i++)
{
//pHSLArray[i] = pHSLArray[i] * pHSLArray[i + nPalSz] / pHSLArray[i + (nPalSz*2)];
double fpPage;
double fpPageSz = 20.0f;
double fpPageAmt;
pHSLArray[i] *= 360.0f;
fpPageAmt = (double)((int)(pHSLArray[i] / fpPageSz));
//pHSLArray[i] = fpPageSz * fpPageAmt;
pHSLArray[i] += fpPageSz;//
fpPage = 4096.0 * fpPageAmt;
//pHSLArray[i] /= fabs((pHSLArray[i + nPalSz * 2])-(pHSLArray[i + nPalSz]));
//pHSLArray[i] /= pHSLArray[i + nPalSz] + ((pHSLArray[i + (nPalSz * 2)]) / 3.0);
//pHSLArray[i] /= (double)(rgPalettes[nIndex].pPal[i] & 0x00FFFFFF);
//if(i && pHSLArray[i -1] == pHSLArray[i])
//{
// pHSLArray[i] += pHSLArray[i + nPalSz];
//}
COLORREF crCol = rgPalettes[nIndex].pPal[i];
double nR = (double)GetRValue(rgPalettes[nIndex].pPal[i])/255.0,
nG = (double)GetGValue(rgPalettes[nIndex].pPal[i])/255.0,
nB = (double)GetBValue(rgPalettes[nIndex].pPal[i])/255.0;
double fpX, fpY, fpZ;
ccRGBtoXYZ(nR, nG, nB, &fpX, &fpY, &fpZ);
//pHSLArray[i] /= sqrt(sq(fpX) + sq(fpY) + sq(fpZ));
pHSLArray[i] /= sqrt(sq(nR - 0) + sq(nG - 0) + sq(nB- 0));
//pHSLArray[i] /=
// pHSLArray[i + nPalSz] + ((pHSLArray[i + (nPalSz * 2)]) / 0.5) + sqrt(sq(nR - 0) + sq(nG - 0) + sq(nB- 0)) + fpX*4;
pHSLArray[i] += fpPage;
}
/*
*/
//for(int i = 0; i < nPalSz; i++)
//{
// COLORREF crCol = rgPalettes[nIndex].pPal[i];
// double nR = (double)GetRValue(rgPalettes[nIndex].pPal[i]),
// nG = (double)GetGValue(rgPalettes[nIndex].pPal[i]),
// nB = (double)GetBValue(rgPalettes[nIndex].pPal[i]);
//
// pHSLArray[i] /=
// sqrt(sq(nR*0.3 - 0) + sq(nG*0.6 - 0) + sq(nB*0.1 - 0));
//
//}
//Sort again
if((nSortFlag & SORT_HUE) == SORT_HUE)
{
for(int i = 0; i < 10; i++)
{
ShellSort(
&pHSLArray[nStartIndex],
&pHSLArray[nStartIndex + nPalSz],
&pHSLArray[nStartIndex + (nPalSz * 2)],
(int *)&(rgPalettes[nIndex].pPal)[nStartIndex],
(UINT16 *)&(rgPalettes[nIndex].pSortTable)[nStartIndex],
nPalSz-nStartIndex
);
}
}
delete [] pHSLArray;
}
int main()
{
int a[8]={3,5,7,9,1,2,4,6};
ShellSort(a,8);
return 0;
}
