/* myqsort -- a cheap implementation of Quicksort on integers
-- returns number of swaps */
static int myqsort(int *a, int num)
{
int i, j, tmp, v;
int numswaps;
numswaps = 0;
if ( num <= 1 )
return 0;
i = 0; j = num; v = a[0];
for ( ; ; )
{
while ( a[++i] < v )
;
while ( a[--j] > v )
;
if ( i >= j ) break;
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
numswaps++;
}
tmp = a[0];
a[0] = a[j];
a[j] = tmp;
if ( j != 0 )
numswaps++;
numswaps += myqsort(&a[0],j);
numswaps += myqsort(&a[j+1],num-(j+1));
return numswaps;
}
void myqsort(void const * base, int lo, int hi, int size, _cmpfun cmp) {
int pivot;
if (lo < hi) {
pivot = partition(base, lo, hi, size, cmp);
if (hi - lo > 4) taskDelay(NO_WAIT);
myqsort(base, lo, pivot - 1, size, cmp);
myqsort(base, pivot + 1, hi, size, cmp);
}
}
void myqsort(int A[], int p, int q)
{
if(p < q){
int r;
r = partition(A, p, q);
myqsort(A, p, r);
myqsort(A, r+1, q);
}
}
// quick sort
// s e
// 6 6 3 8 7 4 5 9 0 1 6 2 || 6 6 3 8 7 4 5 9 0 1 6 2 || 6 6 3 2 7 4 5 9 0 1 6 8
// p_i___________________j || p_____i_______________j || p_______i___________j__
// 6 6 3 2 7 4 5 9 0 1 6 8 || 6 6 3 2 1 4 5 9 0 7 6 8 || 6 6 3 2 1 4 5 9 0 7 6 8
// p_______i_________j____ || p_________i_____j______ || p_____________i_j______
// 6 6 3 2 1 4 5 0 9 7 6 8 if j < i we stop, some properties: x at the left side of i are <= p;
// p_____________j_i______ y at the right side of j are >= p;
// since we use a[s] as pivot, after each round, we need to swap p to the middle and do not sort it
// in the next round of two sides(left, right), x<=p, p, p<=y; but swap p with j or i ? both are ok.
// 0 6 3 2 1 4 5 6 9 7 6 8
// ______________j_i______
void myqsort(std::vector<int> &a, int s, int e)
{
if (s >= e || s < 0 || e > a.size())
return;
const int p = a[s]; // use the first one as pivot
int i = s + 1;
int j = e - 1;
if (i > j) // if (i>=j) error, for example {3 2};
return;
bool bRun = true;
while (bRun)
{
// 1. i cannot = e. 2. ==p can at the left side.
while (i < e && a[i] <= p)
++i;
// 1. s is used by pivot, j stop when == s. 2. ==p can at the right side too.
while (j > s && a[j] >= p)
--j;
if (j > i)
{
int t = a[i];
a[i] = a[j];
a[j] = t;
++i;
--j;
}
else if (j < i)
{
a[s] = a[j];
a[j] = p;
bRun = false;
}
else if (j == i)
assert(false); // why not possible in our case (a[s] is pivot and x<=p and y>= p)?
};
if (0)
{
printf("Afater sort array: (p%d, s%d, e%d) \n", p, s, e);
for (int ii = 0; ii < a.size(); ++ii)
{
printf("%d, ", a[ii]);
}
printf("\n");
}
myqsort(a, s, j);
myqsort(a, i, e);
}
int myqsort(int *arry, int low, int high)
{
int pivottag;
if(low >= high)
return 0;
pivottag = partition(arry, low, high);
myqsort(arry, low, pivottag-1);
myqsort(arry, pivottag+1, high);
return 0;
}
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':
option |= FOLD;
break;
case 'n':
option |= NUMERIC;
break;
case 'r':
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)
myqsort((char **)lineptr,0,nlines-1,(int (*)(void *,void *))numcmp);
else if (option & FOLD)
myqsort((char **)lineptr,0,nlines-1,(int (*)(void *,void *))charcmp);
else
myqsort((char **)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;
}
}
int main(int argc, char **argv)
{
// save lines inputed in a pointer array
int lines, revert, fold, directory;
fold = directory = 0;
revert = 1;
// Use dynamic allocation memory: Umm... maybe in the next time.
char alloc[ALLOCSIZE];
char *ptarr[MAXLINES];
// Check argument
while (--argc > 0 && (*++argv)[0] == '-')
{
char *p;
p = argv[0];
if (!setopt(p,&directory, &revert, &fold))
{
youneedhelp();
return EXIT_FAILURE;
}
}
while ((lines = readlines(ptarr, MAXLINES, alloc)) > 0)
{
// any pointer can be cast to void * and back again without loss of information.
int (*comp)(void *, void *, int);
// Is it too long :(
comp = (int (*)(void *, void *, int))(directory ? strdfcmp : strfcmp);
// sorting use quick sort algorithm.
myqsort((void**)ptarr, 0, lines-1, comp, fold, revert);
writelines(ptarr,lines);
}
return EXIT_SUCCESS;
}
int main()
{
clock_t begin, end;
Type *data;
int n, i;
freopen("test_data.txt", "r", stdin);
FILE *fout=fopen("result.txt", "w");
scanf("%d", &n);
data = (Type *)malloc(sizeof(Type)*n);
for(i=0; i<n; i++)
scanf("%f", &data[i]);
begin = clock();
myqsort(data, n);
end = clock();
fprintf(fout, "%d\n", n);
for(i=0; i<n; i++){
if((i%10) == 9)
fprintf(fout, "%10.3f\n", data[i]);
else
fprintf(fout, "%10.3f ", data[i]);
}
free(data);
fclose(fout);
printf("time = %.3f sec\n", (double)(end-begin)/CLOCKS_PER_SEC);
return 0;
}
int main(int argc, char *argv[])
{
int nlines;
int numeric = 0;
int asc = 1;
int i;
while (argc-- > 1) {
if (strcmp(argv[argc], "-n") == 0)
numeric = 1;
else if (strcmp(argv[argc], "-r") == 0)
asc = -1;
}
if (argc > 1 && strcmp(argv[1], "-n") == 0)
numeric = 1;
if ((nlines = readlines(lineptr, MAXLINES)) >= 0) {
myqsort((void **) lineptr, 0, nlines-1,
(int (*)(void*,void*))(numeric ? numcmp : strcmp), asc);
writelines(lineptr, nlines);
return 0;
} else {
printf("input too big to sort\n");
return 1;
}
}
/* myqsort: sort v[left] ... v[right] inot assending order */
static void myqsort( char *v[], int left, int right, int (*comp)( char *a, char *b ) ) {
int i, last;
if ( left >= right ) {
return;
}
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 );
myqsort( v, left, last-1, comp );
myqsort( v, last+1, right, comp );
}
void myqsort(void *v[], int left, int right,
int (*comp)(void*, void*), int asc)
{
int i, last;
void swap(void *v[], int, int);
if (left >= right)
return;
swap(v, left, (left+right)/2);
last = left;
for (i = left+1; i <= right; i++)
if (asc * (*comp)(v[i], v[left]) < 0)
swap(v, ++last, i);
swap(v, left, last);
myqsort(v, left, last-1, comp, asc);
myqsort(v, last+1, right, comp, asc);
}
void myqsort(void *v[], int left, int right,
int (*cmp)(void *, void *), int reverse)
{
int i, last;
void swap(void *v[], int, int);
if (left >= right)
return;
swap(v, left, (left+right)/2);
last = left;
for (i = left+1; i <= right; ++i)
if (reverse * (*cmp)(v[i], v[left]) < 0)
swap(v, ++last, i);
swap(v, left, last);
myqsort(v, left, last-1, cmp, reverse);
myqsort(v, last+1, right, cmp, reverse);
}
void myqsort(void *base, size_t num, size_t size,
int (*comparator)(const void *, const void *))
{
if (size == 1)
return;
int i;
int farside = (num-1);
for (i = 1; farside > i; i++)
{
if ((*comparator)(base, base + i*size) >= 0) {
swap(base + farside*size, base + i*size, size);
farside--;
}
}
myqsort(base, num/2, size, comparator);
myqsort(base + num/2*size, num - num/2, size, comparator);
}
int myqsortEntry(_Vx_usr_arg_t pDa, _Vx_usr_arg_t pCmp) {
DynArray * da = (DynArray *)pDa;
_cmpfun * cmp = (_cmpfun *)pCmp;
myqsort(da->array, 0, da->used - 1, sizeof(char*), cmp);
return 0;
}
static void myqsort(void *v[], int left, int right, int (*comp)(void *, void *)) {
int i;
int last;
if (left >= right)
return;
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);
myqsort(v, left, last - 1, comp);
myqsort(v, last + 1, right, comp);
}
void myqsort(char *v[],int left,int right, int (*comp)(void *,void *))
{
int i,last;
void swap(char *v[],int i,int j);
if(left>=right) /* do nothing if array contains */
return; /*fewer that 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);
myqsort(v,left,last-1, comp);
myqsort(v,last+1,right, comp);
}
void myqsort(DType x[], int l, int u)
{ int i, j;
DType t, temp;
if (u - l < cutoff)
return;
swap(x, l, randint(l, u));
t = x[l];
i = l;
j = u+1;
for (;;) {
do i++; while (i <= u && x[i] < t);
do j--; while (x[j] > t);
if (i > j)
break;
temp = x[i]; x[i] = x[j]; x[j] = temp;
}
swap(x, l, j);
myqsort(x, l, j-1);
myqsort(x, j+1, u);
}
int main()
{
int test[] = {1, 3, 4, 8, 7, 4, 9, 6, 100}, n = 9;
int *y = malloc(sizeof(int) * n);
y = myqsort(test, n);
int i;
for(i=0;i<n;i++) {
printf("%d ", y[i]);
}
printf("\n");
return 0;
}
int *myqsort(int x[], int n)
{
int pivot = x[0], i, j;
int left[n], right[n], lcnt=0, rcnt=0;
int *ltmp, *rtmp, *ans;
//printf("nothing happens!\n");
ans = malloc(sizeof(int) * n);
if(n == 1) {
//printf("here!\n");
return x;
}
for(i=1;i<n;i++) {
if(x[i]<pivot) {
left[lcnt++] = x[i];
} else {
right[rcnt++] = x[i];
}
//printf("%d ", x[i]);
}
if(lcnt > 0) {
ltmp = malloc(sizeof(int) * lcnt);
ltmp = myqsort(left, lcnt);
}
if(rcnt > 0) {
rtmp = malloc(sizeof(int) * rcnt);
rtmp = myqsort(right, rcnt);
}
ans[lcnt] = pivot;
for(i=0;i<n;i++) {
if(i<lcnt) {
ans[i] = ltmp[i];
}
else if(i>lcnt) {
ans[i] = rtmp[i-lcnt-1];
}
//printf("%d ", ans[i]);
}
//printf("\n");
return ans;
}
int px_sign(const PERM *px)
{
int numtransp;
PERM *px2;
if ( px==(PERM *)NULL )
error(E_NULL,"px_sign");
px2 = px_copy(px,PNULL);
numtransp = myqsort((int *)px2->pe,px2->size);
px_free(px2);
return ( numtransp % 2 ) ? -1 : 1;
}
int sort(int numeric)
{
int nlines;
char *lineptr[MAXLINES];
if( (nlines = readlines(lineptr, MAXLINES)) >= 0 ){
myqsort(lineptr, 0, nlines - 1, getcmp() );
writelines( lineptr, nlines );
return 0;
}else{
printf("error: input too big to sort\n");
return 1;
}
}
int main(char **, int)
{
/*
int b[] = {6,6,3,8,7,4,5,9,0,1,6,2 };
std::vector<int> a;
a.insert(a.end(), &b[0], &b[sizeof(b) / sizeof(int)] );
*/
srand( time(0) );
std::vector<int> a(10);
for (int i = 0; i < a.size(); ++i)
{
a[i] = rand();
}
printf("Init array: \n");
for (int i = 0; i < a.size(); ++i)
{
printf("%d, ", a[i]);
}
printf("\n");
myqsort(a, 0, a.size());
printf("Final array: \n");
for (int i = 0; i < a.size(); ++i)
{
printf("%d, ", a[i]);
}
printf("\n");
// to check if the result is right or wrong
bool bSucceed = true;
for (int i = 0; i < a.size() - 1; ++i)
{
if (a[i] > a[i + 1])
{
bSucceed = false;
break;
}
}
if (bSucceed)
printf("myqsort - Succeed!\n");
else
printf("myqsort - Fail!\n");
scanf("%d");
return 1;
}
//sort input lines
int main(int argc, char **argv)
{
int nlines; //number of input lines
int numeric = 0; //1 if numeric sort
int reverse = 1; //-1 if reverse sort
//int fold = 0; //1 if fold upper and lower case together
char c;
while (--argc > 0 && (*++argv)[0] == '-')
while (c = *++argv[0])
switch (c) {
case 'n':
numeric = 1;
break;
case 'r':
reverse = -1;
break;
case 'f':
fold = 1;
break;
case 'd':
directory = 1;
break;
default:
printf("sort: illegal option %c\n", c);
return -1;
break;
}
int (*fp)(void *, void *);
if (numeric)
fp = (int (*)(void *, void *)) numcmp;
else
fp = (int (*)(void *, void *)) strcmpfd;
if ((nlines = readlines(lineptr, MAXLINES)) >=0) {
myqsort((void **) lineptr, 0, nlines-1, fp, reverse);
writelines(lineptr, nlines);
return 0;
}
else {
printf("input too big to sort\n");
return 1;
}
}
int main()
{
int arry[10] = {1,3,5,7,5,2,4,6,8,10};
int i;
for(i = 0; i < 10; i ++)
printf("%2d ", arry[i]);
putchar(10);
// myqsort(arry,10,sizeof(int), compare);
myqsort(arry,0, 10 - 1);
for(i = 0; i < 10; i ++)
printf("%2d ", arry[i]);
putchar(10);
return 0;
}
size_t remove_duplicate_npre(NPredictItem *npre_items, size_t npre_num) {
if (NULL == npre_items || 0 == npre_num)
return 0;
myqsort(npre_items, npre_num, sizeof(NPredictItem), cmp_npre_by_hanzi_score);
size_t remain_num = 1; // The first one is reserved.
for (size_t pos = 1; pos < npre_num; pos++) {
if (utf16_strncmp(npre_items[pos].pre_hzs,
npre_items[remain_num - 1].pre_hzs,
kMaxPredictSize) != 0) {
if (remain_num != pos) {
npre_items[remain_num] = npre_items[pos];
}
remain_num++;
}
}
return remain_num;
}
/* main program */
int main( int argc, char *argv[] ) {
int nlines;
int numeric = 0; /* 1 -- numeric; 0 -- string */
if ( argc > 1 && strcmp( argv[ 1 ], "-n" ) == 0 ) {
numeric = 1;
}
if ( (nlines = readlines( lineptr, MAXLINE )) >= 0 ) {
//printf( "+++++++++++++++++++++before sorting++++++++++++++++=\n" );
//writelines( lineptr, nlines );
myqsort( (char **) lineptr, 0, nlines-1,
(int (*)(char *, char *))(numeric ? ncmp : strcmp) );
printf( "+++++++++++++++++++++after sorting++++++++++++++++=\n" );
writelines( lineptr, nlines );
return 0;
} else {
printf( "input too big to store\n" );
return 0;
}
}
int main(int argc, char *argv[])
{
srand(time(NULL));
int A[max];
int inum, i;
FILE *file;
file = fopen(argv[1], "r");
inum = 0;
while(fscanf(file, "%d", &A[inum]) != EOF){
inum++;
}
fclose(file);
myqsort(A, 0, inum-1);
for(i = 0; i < inum; i++){
printf("%d ", A[i]);
}
printf("\n");
return 0;
}
int main(int argc, char *argv[]) {
int nlines; // Number of input lines to read
bool numeric = false; // 'true' if numeric sort
bool descend = false; // 'true' if descending output
bool fold = false; // 'true' if case insensitive sort
bool dir = false; // 'true' if directory order sort
char c;
// Evaluate arguments
while (--argc > 0 && (*++argv)[0] == '-')
while ((c = *++argv[0]) != '\0')
switch (c) {
case 'n':
numeric = true;
break;
case 'r':
descend = true;
break;
case 'f':
fold = true;
break;
case 'd':
dir = true;
break;
default:
printf("sort: illegal option %c\n", c);
exit(EXIT_FAILURE);
}
if (argc == 0) {
printf("usage: sort -dnfr [FILE]\n");
exit(EXIT_FAILURE);
}
// Read in the lines into memory
if ((nlines = readlines(lineptr, MAXLINES)) < 0) {
printf("Input is too big to sort\n");
exit(EXIT_FAILURE);
}
// Sort
if (numeric)
myqsort(
(void **) lineptr,
0,
nlines - 1,
(int (*)(void*, void*))numcmp
);
else if (fold && dir)
myqsort(
(void **) lineptr,
0,
nlines - 1,
(int (*)(void*, void*))folddircmp
);
else if (fold)
myqsort(
(void **) lineptr,
0,
nlines - 1,
(int (*)(void*, void*))foldcmp
);
else if (dir)
myqsort(
(void **) lineptr,
0,
nlines - 1,
(int (*)(void*, void*))dircmp
);
else
myqsort(
(void **) lineptr,
0,
nlines - 1,
(int (*)(void*, void*))strcmp
);
// Write out the results
writelines(lineptr, nlines, descend);
return 0;
}
int main(int argc, char* argv[])
{
FILE *f; // исходный файл
FILE *f1; // файл для печати
int *n=0, *c=0; // указатель на начало и после конца массива
int *m=0, *d=0; // указатель на начало и после конца отфилтрованного массива
setlocale(0, "russian");
if (argc < 4)
{
printf("Нет достаточного числа аргументов!");
return BADARG;
}
f = fopen(argv[1], "r");
if (f == NULL)
{
printf("Невозможно открыть исходный файл!");
return BADINFILE;
}
if (readarray(f, &n, &c))
{
printf("Невозможно выделить память под исходный массив!");
fclose(f);
return FAILEDINMEM;
}
f1 = fopen(argv[2], "w");
if (f1 == NULL)
{
printf("Невозможно открыть файл результата!");\
fclose(f);
free(n);
return BADOUTFILE;
}
if (strcmp(argv[3], "-flt") == 0)
{
if (fltr(n, c, &m, &d))
{
printf("Невозможно выделить память под отфильтрованный массив!");
fclose(f);
fclose(f1);
free(n);
return FAILEDOUTMEM;
}
myqsort(m, d - m, sizeof(*m), compare_int);
printmass(f1, m, d);
free(n);
free(m);
}
else
{
myqsort(n, c - n, sizeof(*n), compare_int);
printmass(f1, n, c);
free(n);
}
fclose(f);
fclose(f1);
printf("Успешно!");
getch();
return 0;
}
bool NGram::build_unigram(LemmaEntry *lemma_arr, size_t lemma_num,
LemmaIdType next_idx_unused) {
if (NULL == lemma_arr || 0 == lemma_num || next_idx_unused <= 1)
return false;
double total_freq = 0;
double *freqs = new double[next_idx_unused];
if (NULL == freqs)
return false;
freqs[0] = ADD_COUNT;
total_freq += freqs[0];
LemmaIdType idx_now = 0;
for (size_t pos = 0; pos < lemma_num; pos++) {
if (lemma_arr[pos].idx_by_hz == idx_now)
continue;
idx_now++;
assert(lemma_arr[pos].idx_by_hz == idx_now);
freqs[idx_now] = lemma_arr[pos].freq;
if (freqs[idx_now] <= 0)
freqs[idx_now] = 0.3;
total_freq += freqs[idx_now];
}
double max_freq = 0;
idx_num_ = idx_now + 1;
assert(idx_now + 1 == next_idx_unused);
for (size_t pos = 0; pos < idx_num_; pos++) {
freqs[pos] = freqs[pos] / total_freq;
assert(freqs[pos] > 0);
if (freqs[pos] > max_freq)
max_freq = freqs[pos];
}
// calculate the code book
if (NULL == freq_codes_df_)
freq_codes_df_ = new double[kCodeBookSize];
assert(freq_codes_df_);
memset(freq_codes_df_, 0, sizeof(double) * kCodeBookSize);
if (NULL == freq_codes_)
freq_codes_ = new LmaScoreType[kCodeBookSize];
assert(freq_codes_);
memset(freq_codes_, 0, sizeof(LmaScoreType) * kCodeBookSize);
size_t freq_pos = 0;
for (size_t code_pos = 0; code_pos < kCodeBookSize; code_pos++) {
bool found = true;
while (found) {
found = false;
double cand = freqs[freq_pos];
for (size_t i = 0; i < code_pos; i++)
if (freq_codes_df_[i] == cand) {
found = true;
break;
}
if (found)
freq_pos++;
}
freq_codes_df_[code_pos] = freqs[freq_pos];
freq_pos++;
}
myqsort(freq_codes_df_, kCodeBookSize, sizeof(double), comp_double);
if (NULL == lma_freq_idx_)
lma_freq_idx_ = new CODEBOOK_TYPE[idx_num_];
assert(lma_freq_idx_);
iterate_codes(freqs, idx_num_, freq_codes_df_, lma_freq_idx_);
delete [] freqs;
if (kPrintDebug0) {
printf("\n------Language Model Unigram Codebook------\n");
}
for (size_t code_pos = 0; code_pos < kCodeBookSize; code_pos++) {
double log_score = log(freq_codes_df_[code_pos]);
float final_score = convert_psb_to_score(freq_codes_df_[code_pos]);
if (kPrintDebug0) {
printf("code:%ld, probability:%.9f, log score:%.3f, final score: %.3f\n",
code_pos, freq_codes_df_[code_pos], log_score, final_score);
}
freq_codes_[code_pos] = static_cast<LmaScoreType>(final_score);
}
initialized_ = true;
return true;
}
