/** Quicksort
*
* Apply generic quicksort algorithm on supplied data,
* using pre-allocated buffers.
*
* @param data Pointer to data to be sorted.
* @param cnt Number of elements to be sorted.
* @param elem_size Size of one element.
* @param cmp Comparator function.
* @param arg 3rd argument passed to cmp.
* @param slot Pointer to scratch memory buffer
* elem_size bytes long.
* @param pivot Pointer to scratch memory buffer
* elem_size bytes long.
*
*/
static void _qsort(void *data, size_t cnt, size_t elem_size, sort_cmp_t cmp,
void *arg, void *slot, void *pivot)
{
if (cnt > 4) {
size_t i = 0;
size_t j = cnt - 1;
memcpy(pivot, data, elem_size);
while (true) {
while ((cmp(INDEX(data, i, elem_size), pivot, arg) < 0) && (i < cnt))
i++;
while ((cmp(INDEX(data, j, elem_size), pivot, arg) >= 0) && (j > 0))
j--;
if (i < j) {
memcpy(slot, INDEX(data, i, elem_size), elem_size);
memcpy(INDEX(data, i, elem_size), INDEX(data, j, elem_size),
elem_size);
memcpy(INDEX(data, j, elem_size), slot, elem_size);
} else
break;
}
_qsort(data, j + 1, elem_size, cmp, arg, slot, pivot);
_qsort(INDEX(data, j + 1, elem_size), cnt - j - 1, elem_size,
cmp, arg, slot, pivot);
} else
_gsort(data, cnt, elem_size, cmp, arg, slot);
}
//QSORT ala Sedgewick
bool _qsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger l, SQInteger r,SQInteger func)
{
SQInteger i, j;
SQArray *a=_array(arr);
SQObjectPtr pivot,t;
if( l < r ){
pivot = a->_values[l];
i = l; j = r+1;
while(1){
SQInteger ret;
do {
++i;
if(i > r) break;
if(!_qsort_compare(v,arr,a->_values[i],pivot,func,ret))
return false;
} while( ret <= 0);
do {
--j;
if ( j < 0 ) {
v->Raise_Error( _SC("Invalid qsort, probably compare function defect") );
return false;
}
if(!_qsort_compare(v,arr,a->_values[j],pivot,func,ret))
return false;
}
while( ret > 0 );
if( i >= j ) break;
t = a->_values[i]; a->_values[i] = a->_values[j]; a->_values[j] = t;
}
t = a->_values[l]; a->_values[l] = a->_values[j]; a->_values[j] = t;
if(!_qsort( v, arr, l, j-1,func)) return false;
if(!_qsort( v, arr, j+1, r,func)) return false;
}
return true;
}
/* sort input lines */
int main(int argc, char *argv[])
{
int nlines; /* number of input lines read */
int numeric = 0; /* 1 if numeric sort */
int reverse = 0; /* 1 if reverset sort */
getop(argc, argv, &numeric, &reverse);
if ((nlines = readlines(lineptr, MAXLINES)) >= 0) {
if (numeric){
if (reverse) {
_qsort((void**) lineptr, 0, nlines - 1, (int (*) (void *, void *)) rnumcmp);
} else {
_qsort((void**) lineptr, 0, nlines - 1, (int (*) (void *, void *)) numcmp);
}
} else {
if (reverse) {
_qsort((void**) lineptr, 0, nlines - 1, (int (*) (void *, void *)) rstrcmp);
} else {
_qsort((void**) lineptr, 0, nlines - 1, (int (*) (void *, void *)) strcmp);
}
}
writelines (lineptr, nlines);
return 0;
} else {
printf ("input too big to sort\n");
return 1;
}
}
void _qsort(int *a, int left, int right) {
if (left<right) {
int pivotIndex = _partition(a, left, right);
_qsort(a, left, pivotIndex-1);
_qsort(a, pivotIndex+1 ,right);
}
}
static void _qsort(void *base,size_t size,fCompare cmp,int left,int right) {
/* TODO someday we should provide a better implementation which uses another sort-algo
* for small arrays, don't uses recursion and so on */
if(left < right) {
int i = divide(base,size,cmp,left,right);
_qsort(base,size,cmp,left,i - 1);
_qsort(base,size,cmp,i + 1,right);
}
}
int _qsort(int li, int ls) {
int p;
if(li < ls) {
p = pivot(li, ls);
_qsort(li, p - 1);
_qsort(p + 1, ls);
}
};
int main(int argc, char *argv[])
{
char *lineptr[LINES]; /* pointers to text lines */
int nlines; /* number of input lines read */
int c, rc = 0;
while (--argc > 0 && (*++argv)[0] == '-') {
while ((c = *++argv[0])) {
switch(c) {
case 'f': /* fold upper and lower cases */
option |= FOLD;
break;
case 'n': /* numeric sort */
option |= NUMERIC;
break;
case 'r': /* sort in decreasing order */
option |= DECR;
break;
default:
printf("sort: illegal option %c\n", c);
argc = 1;
rc = -1;
break;
}
}
}
if (argc) {
printf("Usage: sort -fnr \n");
} else {
if ((nlines = readlines(lineptr, LINES)) > 0) {
if (option & NUMERIC) {
_qsort((void **) lineptr, 0, nlines - 1, (int (*)(void *, void *)) numcmp);
} else if (option & FOLD) {
_qsort((void **) lineptr, 0, nlines - 1, (int (*)(void *, void *)) charcmp);
} else {
_qsort((void **) lineptr, 0, nlines - 1, (int (*)(void *, void *)) strcmp);
}
writelines(lineptr, nlines, option & DECR);
} else {
printf("input too big to sort \n");
rc = -1;
}
}
return rc;
}
void _qsort(int* nums, int left, int right){
// printf("srotArr3..\n");
if(left >= right){
return; //递归终止条件
}
srand((int)time(0));
int randLocIndex = rand() % (right - left) + left; //获得一个随机位置
int tmp;
//交换随机位置和最左边位置的值
tmp = nums[left];
nums[left] = nums[randLocIndex];
nums[randLocIndex] = tmp;
int i,j,key;
key = nums[left]; //分治的比较值
i = left;
j = right;
while(i<j){
while(i<j && nums[j]>=key){ //右边找到一个小于key的索引位置
j--;
}
while(i<j && nums[i]<=key){ //左边找到一个大于key 的索引位置
i++;
}
if(i<j) { //交换两个位置的值
tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
nums[left] = nums[i];
nums[i] = key;
// printf("sort a time, key value is %d", key);
// printfArr(nums,13);
//经过上面一轮循环, 右边的值全部大于左边的值
//然后分两块区域, 继续进行排序
_qsort(nums, left, i - 1);
_qsort(nums, i+1, right);
}
/** Quicksort wrapper
*
* This is only a wrapper that takes care of memory
* allocations for storing the pivot and temporary elements
* for generic quicksort algorithm.
*
* This function can sleep.
*
* @param data Pointer to data to be sorted.
* @param cnt Number of elements to be sorted.
* @param elem_size Size of one element.
* @param cmp Comparator function.
* @param arg 3rd argument passed to cmp.
*
* @return True if sorting succeeded.
*
*/
bool qsort(void *data, size_t cnt, size_t elem_size, sort_cmp_t cmp, void *arg)
{
uint8_t ibuf_slot[IBUF_SIZE];
uint8_t ibuf_pivot[IBUF_SIZE];
void *slot;
void *pivot;
if (elem_size > IBUF_SIZE) {
slot = (void *) malloc(elem_size, 0);
if (!slot)
return false;
pivot = (void *) malloc(elem_size, 0);
if (!pivot) {
free(slot);
return false;
}
} else {
slot = (void *) ibuf_slot;
pivot = (void *) ibuf_pivot;
}
_qsort(data, cnt, elem_size, cmp, arg, slot, pivot);
if (elem_size > IBUF_SIZE) {
free(pivot);
free(slot);
}
return true;
}
/* qsort: sort v[left]...v[right] into increasing order */
void _qsort(void *v[], int left, int right, int (*comp) (void *, void *))
{
int i, last;
void swap(void *v[], int, int);
if (left >= right) /* do nothing if array contains */
return ; /* fewer than two elements */
swap(v, left, (left + right) / 2);
last = left;
for (i = left + 1; i <= right; i++) {
if ((*comp) (v[i], v[left]) < 0)
swap(v, ++last, i);
}
swap(v, left, last);
_qsort(v, left, last - 1, comp);
_qsort(v, last + 1, right, comp);
}
int main(int argc, char *argv[]) {
int nlines;
char c;
int k = 0;
while (--argc > 0 && (*++argv)[k] == '-')
while ((++argv[k]) && (c = *argv[k]))
switch (c) {
case 'd':
dflag = 1;
break;
case 'f':
fflag = 1;
break;
case 'r':
reverse = 1;
break;
case 'n':
numeric = 1;
break;
default:
printf("warning: illegal option %c\n", c);
argc = 0;
break;
}
if ((nlines = readlines(lineptr, MAXLINES)) >= 0) {
if (fflag) {
_qsort((void**) lineptr, 0, nlines - 1,
(int(*)(void*, void*)) (numeric ? numcmp : myStrcmpf));
} else
_qsort((void**) lineptr, 0, nlines - 1,
(int(*)(void*, void*)) (numeric ? numcmp : myStrcmp));
writelines(lineptr, nlines);
destroy((void**) lineptr, nlines);
return 0;
} else {
nlines*=-1;
printf("Error occurs on line %d\n",nlines);
nlines--;
destroy((void**) lineptr, nlines);
return 1;
}
}
/**
* @brief ascending array
* @details recursive array sort, by compare
* elements from head and tail and replace
* if element with smallest index more than element
* with biggest index
*
* @param v is array pointer to char arrays
* @param left head pointer index
* @param right tail pointer index
*/
void _qsort(char *v[], int left, int right){
int i, last;
void swap(char *v[], int i, int j);
if(left >= right){
// nothing to sort, all yet on self places
return;
} else {
swap(v, left, (left+right)/2); // get pivot as a middle
last = left;
printf("left:%d last:%d right:%d\n", last, left, right);
for (i = left+1; i<= right; i++)
if (strcmp(v[i], v[left]) < 0)
swap(v, ++last, i);
swap(v, left, last);
_qsort(v, left, last-1);
_qsort(v, last+1, right);
}
}
void _qsort(int* a,int left,int right) {
if(left<right) {
int i=left+1;
int j=right;
int temp=a[i];
while(i<j) {
// while(i<j&&a[j]>temp)j--;
// if(i<j)a[i++]=a[j];
// while(i<j&&a[i]<temp)i++;
// if(i<j)a[j--]=a[i];
while(i<j&&a[i]<temp)i++;
while(i<j&&a[j]>temp)j--;
if(i<j)Swap(a,i++,j--);
}
// a[i]=temp;
Swap(a,left,i);
_qsort(a,left,i-1);
_qsort(a,i+1,right);
}
}
//void qsort (char *v[], int left, int right) {
void _qsort(void *v[], int left, int right, int (*comp)(void *, void *))
{
int i, last;
void swap(void *v[], int i, int j);
// void swap(char *v[], int i, int j);
if (left >= right)
return;
swap(v, left, (left + right) / 2);
last = left;
for (i = left + 1; i <= right; i++)
// if (strcmp(v[i], v[left]) < 0)
// if ((reverse ? ((*comp)(v[i], v[left]) > 0) : ((*comp)(v[i], v[left]) < 0)))
if ((*comp)(v[i], v[left]) < 0)
swap(v, ++last, i);
swap(v, left, last);
// qsort(v, left, last - 1);
_qsort(v, left, last - 1, comp);
// qsort(v, last + 1, right);
_qsort(v, last + 1, right, comp);
}
void idxSortWrt(struct conv c_list[], int len, FILE *fidx){
int i;
_qsort(c_list, 0, len - 1);
for(i = 0; i < len; i++){
fprintf(fidx, " <TD><A HREF=\"%s\">%s</A></TD><TD> </TD>", c_list[i].file, c_list[i].orig);
if((i+1) % 5 == 0)
fprintf(fidx, "\n</TR>\n<TR>\n");
}
}
void _qsort(int low, int high) {
int i = low,
j = high,
p = arr[ ( low + high ) >> 1 ];
while(i <= j) {
while(arr[ i ] < p) i++;
while(arr[ j ] > p) j--;
if( i <= j ) swap( &arr[ i++ ], &arr[ j-- ]);
}
if(low < j) _qsort(low, j);
if(i < high) _qsort(i, high);
};
/* Text with leading underscore is compared from the next character */
void _qsort(struct conv c_list[], int first, int last){
int i = first, j = last;
char *med;
struct conv swap;
med = c_list[(first + last) / 2].orig;
if(*med == '_'){
med++;
}
do{
while(strcasecmp((*c_list[i].orig == '_' ?
c_list[i].orig + 1 :
c_list[i].orig),
med) < 0){
i++;
}
while(strcasecmp(med,
*c_list[j].orig == '_' ?
c_list[j].orig + 1 :
c_list[j].orig) < 0){
j--;
}
if(i <= j){
swap = c_list[i];
c_list[i++] = c_list[j];
c_list[j--] = swap;
}
}while(i <= j);
if(first < j)
_qsort(c_list, first, j);
if(i < last)
_qsort(c_list, i, last);
}
static SQInteger array_sort(HSQUIRRELVM v)
{
SQInteger func = -1;
SQObjectPtr &o = stack_get(v,1);
SQObject &funcobj = stack_get(v,2);
if(_array(o)->Size() > 1) {
if(type(funcobj) == OT_CLOSURE || type(funcobj) == OT_NATIVECLOSURE) func = 2;
if(!_qsort(v, o, 0, _array(o)->Size()-1, func))
return SQ_ERROR;
}
return 0;
}
static void _qsort(void *array, size_t size, int (*cmp)(void *, void *), int low, int high)
{
if (high > low) {
int pivot_idx = ((low + high) / 2) / size * size;
swap(array + low, array + pivot_idx, size); // place pivot at the beginning
void *pivot = array + low;
int l = low + size; // order from second element to end of partition
int r = high;
while (l < r) {
if (cmp(array + l, pivot) <= 0) {
l += size;
} else {
for (r -= size; l < r && cmp(array + r, pivot) >= 0; r -= size) { }
swap(array + l, array + r, size);
}
}
l -= size;
swap(array + low, array + l, size);
_qsort(array, size, cmp, low, l);
_qsort(array, size, cmp, r, high);
}
}
/**
* @brief read string from stdin
* sort and print
* @details fill pointer array *lineptr with pointers for
* read strings, sort that array and print sorted
* strings with sorted pointers
* @return 0 if sucess otherwise -1 if fail
*/
int main(void){
int nlines; // number of input strings
char buffer[MAXLEN*MAXLINES]; // allocate place for possibly read strings
if ( (nlines = readlines(lineptr, MAXLINES, buffer)) >= 0){
_qsort(lineptr, 0, nlines-1);
writelines(lineptr, nlines);
return 0;
} else {
printf("input too big to sort\n");
return -1;
}
}
int main() {
read();
//freopen(FOUT, "w", stdout);
srand(time(NULL));
_qsort(0, n - 1);
int i;
for(i = 0; i < n; i++) printf("%d ", arr[ i ]);
fclose( stdout );
return(0);
};
void qsort(int* a,int len) {
_qsort(a,0,len-1);
}
void qsort(void *__base, int __nelem, int __size, int (*__cmp)(const void *__e1, const void *__e2)) {
_qsort(__base, __nelem, __size, __cmp);
}
/** string sorting from stdin */
int main (int argc, char *argv[])
{
int nlines;
// int numeric = 0; // 1 -- string of numbers
// int reverse = 0; // 1 -- reverse order
// int caseinsensitive = 0;// 1 -- case insensitive sort
// int directory = 0; // 1 -- directory order sort
/** compare operation */
// int (*comp)(void*,void*) = (int (*)(void*,void*))strcmp;
int z;
if (argc > 1) {
int i,j;
for (i = 1; i < argc; i++) {
// if (argv[i][0] == '-' && argv[i][2] == '\0') {
// if (argv[i][0] == '-' && argv[i][1] != '\0') {
if (argv[i][0] == '-') {
int empty_field = 1;
/** count all possible fields */
if (argv[i][1] == '\0') /** assume option '-\0' = base string sort */
empty_field = 0;
// fields_count++;
for(j=1; argv[i][j] != '\0'; j++) {
switch(argv[i][j]) {
case 'n':
options[field][NUMERIC] = 1;
options[field][CASEINSENSITIVE] = 0;
empty_field = 0;
break;
case 'r':
options[field][REVERSE] = 1;
empty_field = 0;
break;
case 'f':
if (options[field][NUMERIC] == 0) {
options[field][CASEINSENSITIVE] = 1;
empty_field = 0;
}
break;
case 'd':
options[field][DIRECTORY] = 1;
empty_field = 0;
break;
}
}
if (!empty_field) {
fields_count++;
field++;
}
}
}
}
/** we can pass caseinsensitive-value if we sort strings as characters (not numeric) */
// if (numeric)
// caseinsensitive = 0;
if (fields_count == 0) {
printf("error: some options should be specified...\n");
return 1;
}
else {
if ((nlines = readlines(lineptr, MAXLINES)) >= 0) {
/* int numeric = options[0][NUMERIC];
int reverse = options[0][REVERSE];
int caseinsensitive = options[0][CASEINSENSITIVE];
int directory = options[0][DIRECTORY];
*/
// qsort(lineptr, 0, nlines - 1);
// _qsort((void **) lineptr, 0, nlines-1, (int (*)(void*,void*))(numeric ? numcmp : strcmp), reverse);
/*
if (numeric && reverse)
comp = (int (*)(void*,void*))numcmp_reverse;
else if (numeric)
comp = (int (*)(void*,void*))numcmp;
else if (caseinsensitive && reverse)
comp = (int (*)(void*,void*))strcmp_reverse_incase;
else if (reverse)
comp = (int (*)(void*,void*))strcmp_reverse;
else if (caseinsensitive && directory)
comp = (int (*)(void*,void*))dircmp_incase;
else if (directory)
comp = (int (*)(void*,void*))dircmp;
else if (caseinsensitive)
comp = (int (*)(void*,void*))strcmp_incase;
*/
// _qsort((void **) lineptr, 0, nlines-1, comp);
_qsort((void **) lineptr, 0, nlines-1, (int (*)(void*,void*))comp_fielded);
// printf("qsort for %s-input in %s order%s%s\n", numeric ? "numeric" : "character", reverse ? "reverse" : "straight", caseinsensitive ? " [case-insensitive]" : "", directory ? " [directory]" : "");
printf("qsort for input by fields:\n");
for (z = 0; z < fields_count; z++) {
printf("\t [%d]: %s-input in %s order%s%s\n", z, options[z][NUMERIC] ? "numeric" : "character", options[z][REVERSE] ? "reverse" : "straight", options[z][CASEINSENSITIVE] ? " [case-insensitive]" : "", options[z][DIRECTORY] ? " [directory]" : "");
}
writelines(lineptr, nlines);
return 0;
}
else {
printf("error: input too big to sort\n");
return 1;
}
}
// return 0;
}
void sort() {
_qsort(0, N - 1);
};
void qsort(void *array, size_t nitems, size_t size, int (*cmp)(void *, void *))
{
_qsort(array, size, cmp, 0, nitems * size);
}
void qsort(void *base,size_t nmemb,size_t size,fCompare cmp) {
_qsort(base,size,cmp,0,nmemb - 1);
}
void qsort() {
_qsort(0, n - 1);
};
void quickSort(int *a, int n) {
_qsort(a, 0, n-1);
}
/**
* 快速排序
*/
void qsortArr(int* nums, int numsSize){
_qsort(nums, 0, numsSize - 1);
}
