Int main(void){

FILE *in=fopen("input.txt","r");

FILE *out=fopen("output.txt","w");

int n,i,cnt;

int *a;

fscanf(in,"%d",&n);

a=(int*) malloc(sizeof(int)*n);

for(i=0;i<n;i++)

fscanf(in,"%d",&a[i]);

cnt=sort(a,0,n-1);

for(i=0;i<n;i++)

fprintf(out,"%d ",a[i]);

fprintf(out,"\n");

fprintf(out,"%d\n",cnt);

fclose(in);

fclose(out);

return 0;

}

№10. #include <stdio.h>

#include <string.h>

#include <stdlib.h>

#define MAXL 50

#define MAXN 10000

const char sep[]=",. ";

int word_cnt(char *s){//подсчет количества слов строчки s

char *t=(char *)malloc(MAXL);//функция strtok изменит строчку s в процессе работы. мы этого не хотим, поэтому скопируем s

char *p;

int cnt=0;

strcpy(t,s);

p=strtok(t,sep);

while(p){

cnt++;

p=strtok(NULL,sep);

}

free(t);

return cnt;

}

void sort(char* a[],int lt,int rt){

int i=lt,j=rt;

char *x=(char*)malloc(MAXL);

char *t;

t=(char *) malloc(MAXL);

strcpy(x,a[(lt+rt)/2]);

do{

while(word_cnt(a[i]) > word_cnt(x)) i++;

while(word_cnt(a[j]) < word_cnt(x)) j--;

if(i<=j){

strcpy(t,a[i]);

strcpy(a[i],a[j]);

strcpy(a[j],t);

//когда встретимся (i==j, а этот момент обязвтельно наступит), то удобно сделать i++ и j-- [ключевое слово: обрезать]

i++;j--;

}

}while(i<=j);

if(lt < j) sort(a,lt,j);//сортируем первую половину

if(i < rt) sort(a,i,rt);//сортируем одну половину

//в двух половинах суммарно уже как минимум на 1 элемент меньше!

}

char *s[MAXN];

char buf[MAXL];

Int main(void){

int n=0,i;

freopen("input.txt","r",stdin);

freopen("output.txt","w",stdout);

while(gets(buf)){//считываем очередную строку из файла, пока не достигнем его конца

s[n]=(char*)malloc(MAXL);//выделяем память для очередной строки

strcpy(s[n],buf);//копируем туда то, что считали

n++;

}

sort(s,0,n-1);

for(i=0;i<n;i++)

printf("%s\n",s[i]);

return 0;

}

№11. #include <stdio.h>

#include <stdlib.h>

void swap(double *a,double *b){

double t=(*a);

(*a)=(*b);

(*b)=t;

}

void sift_up(double a[],int x){//"проталкивание" элемента вверх (нужно при добавлении)

while(x && a[x] < a[x/2]){

swap(&a[x],&a[x/2]);

x/=2;

}

}

void sift_down(double a[],int x,int n){//"проталкивание" эдемента вниз (нужно при удалении)

double min;

//x*2 - левый сын, x*2+1 - правый

while(x*2<=n || x*2+1<=n){

min=a[x];

if(x*2<=n && a[x*2]<min) min=a[x*2];

if(x*2+1<=n && a[x*2+1]<min) min=a[x*2+1];

if(x*2<=n&&min==a[x*2]){

swap(&a[x],&a[x*2]);

x=x*2;

continue;

}

if(x*2+1<=n&&min==a[x*2+1]){

swap(&a[x],&a[x*2+1]);

x=x*2+1;

continue;

}

break;

}

}

void hsort(double a[],int n){

int i;

double *h=(double*)malloc(sizeof(double)*(n+1));

for(i=0;i<n;i++){//последовательно добавляем элементы массива a[] в хип h

h[i+1]=a[i];//ставим очередной элемент последним

sift_up(h,i+1);//проталкивание его вверх, если необходимо

}

for(i=0;i<n;i++){//выбираем самый маленький элемент, самый маленький среди оставшихся, ...

a[i]=h[1];//самый маленький среди оставшихся будет в h[1]

swap(&h[1],&h[n-i]);//удаляем самый маленький из хипа. меняем его местами с последним

sift_down(h,1,n-i-1);//считаем, что в хипе стало на 1 элемент меньше, проталкиваем h[1] вниз

}

}