Сортировка структурных данных на языке turbo С

struct str tmp;
for (i = 0; i < n-1; i++)
{min = i;  
for (j = i+1; j < n; j++)

{double oper_1 = pow(st1[min].y,st1[min].x) / float(st1[min].s);  
double oper_2 = pow(st1[j].y,st1[j].x) / float(st1[j].s);

if (oper_1 > oper_2)
{min = j;}  
}  
 tmp = stl;
  stl = stl[min];  
 stl[min] = tmp;
}

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<conio.h>
int i,k ,m=100;

struct str {int x; double y; unsigned char s;} st1;
//bool operator <(Thingy a, Thingy b) { return pow(a.x+0.0, a.y)/a.z < pow(b.x+0.0, b.y)/b.z; }
zapoLNeNie()

{
st1.x=rand()%10;
st1.y=(rand()%10)*1.130666;
st1.s=rand();

return 0;}
main()
{clrscr();

/* vvedite kolichestvo structur i na*mite ** enter ** */
printf("Enter quantity and structures and press ** enter ** --> ");
scanf("%d",&m);
printf("\n");
k=0;

FILE *data;
if((data=fopen("data.txt","w"))==NULL)
printf("error");
else printf("Structures: \n");
printf("\n");
for(k=0;k<m;k++)
{
zapoLNeNie();


printf("%f " ,st1.y);
printf(";\n");

printf("%d ",st1.x);
printf(";\n");

printf("%u " ,st1.s);
printf(";\n");

printf("\n \n");

#include "stdafx.h"

#include <iostream.h>
#include <conio.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <fstream.h>
#include <time.h>
/************************************************************************************/
//Описание структуры
struct sNumbers
{
    int x;
    double y;
    unsigned char z;
};
/************************************************************************************/
//Размер структуры
#define REC_LEN sizeof(sNumbers)
/************************************************************************************/
//Указатель на таблицу индексов
unsigned long *pIndex = NULL;

//Размерность массива
unsigned long ddM;
//Указатели на выходные потоки
ofstream fsOut, fsInText;
//Указатель на входной поток
ifstream fsIn;

//Переменные для временных значений
sNumbers nTmp;
char sBin[REC_LEN];
unsigned long ddTmp;
/************************************************************************************/
//Заполнение входного файла
void fnFillInFile()
{
    //Открытие файлов для записи
    //... в бинарном формате
    fsOut.open("iData.bin");
    //... в текстовом формате
    fsInText.open("iData.txt");

    //Цикл заполнения входных данных для сортировки
    for(unsigned long i = 0; i < ddM; i++)
    {  
        //Генерация информации
        nTmp.x = rand() % 10;
        nTmp.y = (rand() % 10) / 1.130666;
        //Число от 1 до 255, т.к.
        //  z - знаменатель дроби в расчетной формуле
        nTmp.z = rand() % 254 + 1;

        //Копирование данных в символьный массив
        memcpy(sBin, &nTmp, REC_LEN);
        //Запись в бинарном формате
        fsOut.write(sBin, REC_LEN);

        //Запись в текстовом формате
        fsInText << nTmp.x << " " <<
                    nTmp.y << " " <<
                    nTmp.z << endl;
    }

    //Закрытие файлов
    fsOut.close();
    fsInText.close();
}
/************************************************************************************/
//Возвращает значение для сравнения из записи с заданным номером
double fnTestValue(unsigned long ddRecNum)
{  
    double dblRes;
    sNumbers nRecord;
   
    //Вычисление смещения
    ddTmp = ddRecNum * REC_LEN;
    //Переход на заданную позицию
    fsIn.seekg(ddTmp);
    //Чтение структуры
    fsIn.read(sBin, REC_LEN);
    //Перезапись бинарных данных в структуру
    memcpy(&nRecord, sBin, REC_LEN);

    //Вычисление значения
    dblRes = pow(nRecord.y, (double)nRecord.x) / (double)nRecord.z;

    return dblRes;
}
/************************************************************************************/
void fnSorted()
{
    unsigned long i, j, ddOffset;
    double dblValue1, dblValue2;

    //Открытие бинарного файла для считывания
    fsIn.open("iData.bin");

    //Сортировка "пузырьком"
    for(i = 0; i < ddM; i++)
    {
        for(j = 0; j < (ddM - 1); j++)
        {
            //Получение структур для сравнения
            //  с учетом их номеров в индексной таблице
            dblValue1 = fnTestValue(pIndex[j]);
            dblValue2 = fnTestValue(pIndex[j + 1]);

            //Сравнение
            if(dblValue1 > dblValue2)
            {
                //Если условие выполнено, то переставить индексы
                ddTmp = pIndex[j];
                pIndex[j] = pIndex[j + 1];
                pIndex[j + 1] = ddTmp;
            }
        }
    }

    //Закрытие файла
    fsIn.close();
}
/************************************************************************************/
//Запись результата
void fnRecord()
{
    //Открытие файлов для чтения и записи
    fsIn.open("iData.bin");
    fsOut.open("oData.txt");

    //Цикл по всем элементам
    for(unsigned long i = 0; i < ddM; i++)
    {
        //Чтение структуры с заданным индексом
        ddTmp = pIndex * REC_LEN;
        fsIn.seekg(ddTmp);
        fsIn.read(sBin, REC_LEN);

        //Перезапись бинарных данных в структуру
        memcpy(&nTmp, sBin, REC_LEN);

        //Вывод в файл в текстовом формате
        fsOut << nTmp.x << " " <<
                 nTmp.y << " " <<
                 nTmp.z << endl;
    }

    //Закрытие файлов
    fsIn.close();
    fsOut.close();
}
/************************************************************************************/
//Основная функция
void main()
{
    unsigned long i;

    //Инициализация генератора случайных чисел
    srand(time(NULL));

    //Ввод числа элементов
    cout << "M = ";
    cin >> ddM;

    //Создание таблицы индексов
    pIndex = new unsigned long[ddM];
    if(!pIndex) return;
   
    //Заполнение таблицы индексов
    for(i = 0; i < ddM; i++)
        pIndex = i;

    //Генерация данных для сортировки
    fnFillInFile();
    //Сортировка
    fnSorted();
    //Вывод
    fnRecord();

    //Удаление таблицы индексов
    delete []pIndex;
}
/************************************************************************************/