Сортировки: пузырек, Шелла, быстрая

#include <stdio.h>
#include <malloc.h>
#include <locale.h>
#include <stdlib.h>
#include <time.h>
#include <limits.h>

void rand_mas(int *mas[], int kol)
{
time_t seconds;
time(&seconds);
srand(seconds);
for(int i=0; i<kol; i++)
{
    *mas[i]=rand()%100;
}
}
void copy_mas(int *mas[], int *mas_s[], int kol)
{
for(int i=0; i<kol; i++)
{
    *mas_s[i]=*mas[i];
}
}
void print_mas(int *mas[], int kol)
{
for(int i=0; i<kol; i++)
{
    printf("%d\t",*mas[i]);
}
printf("\n");
}
void bubble_sort(int *mas_bub[], int kol)
{
printf("Исходный массив:\n");
print_mas(mas_bub,kol);
int tek_sr;
for(int i=0; i<kol-1; i++)
{
    for(int j=i+1; j<kol; j++)
    {
    if(*mas_bub[i]>*mas_bub[j])
    {
        tek_sr=*mas_bub[i];
        *mas_bub[i]=*mas_bub[j];
        *mas_bub[j]=tek_sr;
    }
    }
}
printf("\nМассив после пузырьковой сортировки:\n");
print_mas(mas_bub,kol);
}

void sort_of_shell(int *mas_Sh[], int kol)
{
printf("Исходный массив:\n");
print_mas(mas_Sh,kol);
int distance=kol/2;
    while(distance>0)
    {
        for (int i=0; i<(kol-distance); i++)
        {
    for(int j=i; (j>=0) && (*mas_Sh[j]>*mas_Sh[j+distance]); j--)
            {
                int tek=*mas_Sh[j];
                *mas_Sh[j]=*mas_Sh[j+distance];
                *mas_Sh[j+distance]=tek;
             }
        }
        distance=distance/2;
    }
printf("Массив после сортировки Шелла: \n");
print_mas(mas_Sh,kol);

}

void quick_sort(int *mas[], int kol)
{
int key=NULL, num1=0,num2=0;

int **buffer=(int **)calloc(kol,sizeof(int));//создаем буфер
for(int i=0; i<kol; i++){
    buffer[i]=(int *)malloc(sizeof(int));
    *buffer[i]=*mas[i];//копируем массив в буфер
}

for(int i=0; i<kol-1 && key==NULL; i++){    //ищем ключ по которому идет сортировка
    if (*buffer[i]>*buffer[i+1]) key=*buffer[i];
    else if (*buffer[i]<*buffer[i+1])  key=*buffer[i+1];
    else key=NULL;
}

if (key!=NULL){
    for(int i=0; i<kol; i++){
    if(*buffer[i]<key){
        *mas[num1]=*buffer[i];
        num1++;
    }
    else {
        *mas[kol-num2-1]=*buffer[i];
        num2++;
    }
    }
    int **mas1=(int **)calloc(num1,sizeof(int));
    for(int i=0; i<num1; i++){
    mas1[i]=mas[i];
    }
    int **mas2=(int **)calloc(num2,sizeof(int));
    int j=0;
    for(int i=num1; i<kol; i++){
    mas2[j]=mas[i];
    j++;
    }
    if(num1>1) quick_sort(mas1,num1);
    free(mas1);
    if(num2>1) quick_sort(mas2,num2);
    free(mas2);
}
for(int i=0; i<kol; i++){
    free(buffer[i]);
}
free(buffer);
}
int menu(int *mas[],int kol)
{
int **mas_s;
mas_s=(int **)calloc(kol,sizeof(int));
for(int i=0; i<kol; i++)
{
    mas_s[i]=(int *)malloc(sizeof(int));
}
int action;
printf("_________________________________________________\n\n");
printf("Выберите действие: ");
scanf("%d",&action);
printf("\n");
   
switch(action)
{
    case 1: {
    copy_mas(mas,mas_s,kol);
    bubble_sort(mas_s,kol);
    break;
    }
    case 2: {
    copy_mas(mas,mas_s,kol);
    sort_of_shell(mas_s,kol);
    break;
    }
    case 3: {
    copy_mas(mas,mas_s,kol);
    printf("Исходный массив:\n");
    print_mas(mas_s,kol);
    printf("Массив после быстрой сортировки: \n");
    quick_sort(mas_s,kol);
    print_mas(mas_s,kol);   
    break;
    }
    case 4: {
    return 1;
    }
    default: {
    printf("Выбрано неправильное действие!!! Выберите еще раз.\n");
    printf("_________________________________________________\n\n");
    break;
    }
}
free(mas_s);
}
int main()
{
setlocale(LC_ALL,"Rus");
printf("Введите размерность сортируемого массива: ");
int kol;
scanf("%d",&kol);

int **mas;
mas=(int **)calloc(kol,sizeof(int));
for(int i=0; i<kol; i++)
{
    mas[i]=(int *)malloc(sizeof(int));
}
rand_mas(mas,kol);

printf("_________________________________________________\n");
    printf("\nВыберите один из пунктов меню...\n");
    printf("1. Сортировка пузырьком.\n");
    printf("2. Сортировка Шелла.\n");
    printf("3. Быстрая сортировка.\n");
    printf("4. Выход.\n");

while(menu(mas,kol)!=1);
free(mas);

return 0;
}

Ряд фибонначчи рекурсия и итерация

#include "stdio.h"
#define NUM 300
#define LIM 3e+038//Ограничение float(приблизительно)

void fibo1()//Итерация
{
float mas[NUM];
for(int i=0; i<NUM; i++)
{
    if(i==0 || i==1)
    {
    mas[i]=1;
    printf("%.f\n",mas[i]);
    }
    else if(mas[i-2]<LIM/2)
    {
    mas[i]=mas[i-1]+mas[i-2];
    printf("%.f\n",mas[i]);
    }
    else
    {
    printf("\nLimit!\n");
    break;
    }
}
}

float var1;//f(n-2)- предпредыдущее
float fibo2(float n)//Рекурсия
{
if (n==0) //Первые два значения ряда Фибоначчи
{
    var1=0;
    printf("1\n");
    return 1;
}
float var2=fibo2(n-1);//f(n-1)- предыдущее
if(var1<LIM/2)//С учетом типа идентификатора
{
    float num=var2+var1;//f(n)
    var1=var2;//Предпредыдущее значение становится предыдущим =)
    printf("%.f\n",num);
    return num;
}
else return -1;
}

void main()
{
printf("Recursion (r) or iteration (i)?\n");

char i;
scanf("%c", &i);

switch (i)
{
case 'i':
    fibo1();
    break;
case 'r':
    fibo2(NUM);
    printf("\nLimit!\n");
    break;
default:
    printf("Error value");
}

int t;
scanf("%d", &t);
}