Файл реализации

//---------------------------------------------------------------------------

#include <vcl.h>

#pragma hdrstop

#include "LR_3.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma link "CSPIN"

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

//---------------------------------------------------------------------------

int razm_min,razm_max,d,m,max_d,min_d,razm_out,t;

//---------------------------------------------------------------------------

array::array(int p)

{n=p;

a=new int[n];

sr=0;

obm=0;

for(int i=0;i<n;i++) a[i]=random(max_d-min_d+1)+min_d;

}

//---------------------------------------------------------------------------

array::array(array&c)

{n=c.n; sr=c.sr; obm=c.obm;

a=new int[n];

for(int i=0;i<n;i++)a[i]=c.a[i];

}

//---------------------------------------------------------------------------

void array::swap(int&x,int&y)

{int z=x;x=y;y=z;}

//---------------------------------------------------------------------------

void array::SwapSort(int i,int j,int k)

{ if(i==n-1) return;

if(j<n) {

if(a[i]>a[j]) {swap(a[i],a[j]); obm++;}

sr++; SwapSort(i,j+1,k);

}

else SwapSort(i+1,i+2,k);

}

//---------------------------------------------------------------------------

void array::SelectSort(int i,int j,int min,int k)

{ if(i==n-1) return;

if(j<n) {

if(a[min]>a[j]) min=j;

sr++; SelectSort(i,j+1,min,k);

}

else {

swap(a[i],a[min]); obm++;

SelectSort(i+1,i+2,i+1,k);

}

}

//---------------------------------------------------------------------------

void array::InsertSort(int i,int j,int k,array&c)

{ if(i==n) return;

int z=c.a[i];

if(j>0&&z<a[j-1]) {

a[j]=a[j-1]; sr++;

InsertSort(i,j-1,k,c);

}

else {

a[j]=z; sr++;

InsertSort(i+1,i+1,k,c);

}

}

//---------------------------------------------------------------------------

void array::BubbleSort(int i,int j,int last,int k)

{ if(i<=0) return;

if(j<i) {

if(a[j]>a[j+1]) {swap(a[j],a[j+1]); obm++; last=j;}

sr++; BubbleSort(i,j+1,last,k);

}

else BubbleSort(last,0,0,k);

}

//---------------------------------------------------------------------------

void array::QuickSort(int l,int h,int k)

{ int su,sd,m,p;

if(h-l<=0) return;

else if(h-l==1) {

if(a[h]<a[l]) {swap(a[l],a[h]); obm++;}

sr++;

return;

}

m=(l+h)/2; p=a[m]; swap(a[m],a[l]); obm++; su=l+1;sd=h;

do{

while(su<=sd && a[su]<=p) {su++; sr++;}

while(p<a[sd]) {sd--; sr++;}

if(su<sd) {swap(a[su],a[sd]); obm++; }

} while(su<sd);

a[l]=a[sd]; a[sd]=p; obm++;

if(l<sd-1) QuickSort(l,sd-1,k);

if(sd+1<h) QuickSort(sd+1,h,k);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::exitClick(TObject *Sender)

{

Close();

}

//---------------------------------------------------------------------------

void array::out_mass_a()const

{

AnsiString str="";

for(int i=0;i<n;i++)str+=" "+IntToStr(a[i]);

Form1->Memo1->Lines->Add(str);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn1Click(TObject *Sender)

{

Memo1->Clear();

Panel1->Caption="";

for(int i=0;i<StringGrid1->RowCount;i++)

for(int j=0;j<StringGrid1->ColCount;j++)

{StringGrid1->Cells[j][i]="";

StringGrid2->Cells[j][i]="";}

StringGrid1->Cells[0][0]="размер";

StringGrid1->Cells[1][0]="обменами";

StringGrid1->Cells[2][0]="выбором";

StringGrid1->Cells[3][0]="вставками";

StringGrid1->Cells[4][0]="пузырьком";

StringGrid1->Cells[5][0]="быстрая";

StringGrid2->Cells[0][0]="размер";

StringGrid2->Cells[1][0]="обменами";

StringGrid2->Cells[2][0]="выбором";

StringGrid2->Cells[3][0]="вставками";

StringGrid2->Cells[4][0]="пузырьком";

StringGrid2->Cells[5][0]="быстрая";

Series1->Clear();

Series2->Clear();

Series3->Clear();

Series4->Clear();

Series5->Clear();

Series6->Clear();

Series7->Clear();

Series8->Clear();

Series9->Clear();

Series10->Clear();

ProgressBar1->Position=0;

if(CSpinEdit1->Value>CSpinEdit2->Value){Panel1->Caption=

"мин размер не м б больше макс!"; return;}

if(CSpinEdit5->Value>CSpinEdit4->Value){Panel1->Caption=

"мин число не м б больше макс!"; return;}

if(CSpinEdit7->Value%CSpinEdit3->Value){Panel1->Caption=

"t/d должно быть целым!"; return;}

razm_min=CSpinEdit1->Value;

razm_max=CSpinEdit2->Value;

d=CSpinEdit3->Value;

m=(razm_max-razm_min)/d+1;

max_d=CSpinEdit4->Value;

min_d=CSpinEdit5->Value;

razm_out=CSpinEdit6->Value;

t=CSpinEdit7->Value;

sort->Enabled=true;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::recClick(TObject *Sender)

{

StringGrid1->RowCount=(razm_max-razm_min)/t+2;

StringGrid2->RowCount=(razm_max-razm_min)/t+2;

int count=m,current=0;

for(int k=0;k<m;k++){

array arr(razm_min+k*d);

if(razm_min+k*d==razm_out)

Form1->Memo1->Lines->Add(" Сортировка обменами");

array arr_swap=arr;

if(razm_min+k*d==razm_out){

Form1->Memo1->Lines->Add("Исходный массив");

arr_swap.out_mass_a();}

arr_swap.SwapSort(0,1,k);

Form1->Series1->AddXY(razm_min+k*d,arr_swap.get_sr(),"",clBlack);

Form1->Series2->AddXY(razm_min+k*d,arr_swap.get_obm(),"",clBlack);

if(razm_min+k*d==razm_out){

Form1->Memo1->Lines->Add("Отсортированный массив");

arr_swap.out_mass_a();}

if(razm_min+k*d==razm_out)

Form1->Memo1->Lines->Add(" Сортировка выбором");

array arr_select=arr;

if(razm_min+k*d==razm_out){

Form1->Memo1->Lines->Add("Исходный массив");

arr_select.out_mass_a();}

arr_select.SelectSort(0,1,0,k);

Form1->Series3->AddXY(razm_min+k*d,arr_select.get_sr(),"",clBlack);

Form1->Series4->AddXY(razm_min+k*d,

arr_select.get_obm()*100,"",clBlack);

if(razm_min+k*d==razm_out){

Form1->Memo1->Lines->Add("Отсортированный массив");

arr_select.out_mass_a();}

if(razm_min+k*d==razm_out)

Form1->Memo1->Lines->Add(" Сортировка вставками");

array arr_insert=arr;

if(razm_min+k*d==razm_out){

Form1->Memo1->Lines->Add("Исходный массив");

arr_insert.out_mass_a();}

arr_insert.InsertSort(1,1,k,arr);

Form1->Series5->AddXY(razm_min+k*d,arr_insert.get_sr(),"",clBlack);

Form1->Series6->AddXY(razm_min+k*d,arr_insert.get_obm(),"",clBlack);

if(razm_min+k*d==razm_out){

Form1->Memo1->Lines->Add("Отсортированный массив");

arr_insert.out_mass_a();}

if(razm_min+k*d==razm_out)

Form1->Memo1->Lines->Add(" Сортировка пузырьком");

array arr_bubble=arr;

if(razm_min+k*d==razm_out){

Form1->Memo1->Lines->Add("Исходный массив");

arr_bubble.out_mass_a();}

arr_bubble.BubbleSort(razm_min+k*d-1,0,0,k);

Form1->Series7->AddXY(razm_min+k*d,arr_bubble.get_sr(),"",clBlack);

Form1->Series8->AddXY(razm_min+k*d,arr_bubble.get_obm(),"",clBlack);

if(razm_min+k*d==razm_out){

Form1->Memo1->Lines->Add("Отсортированный массив");

arr_bubble.out_mass_a();}

if(razm_min+k*d==razm_out)

Form1->Memo1->Lines->Add(" Быстрая сортировка");

array arr_quick=arr;

if(razm_min+k*d==razm_out){

Form1->Memo1->Lines->Add("Исходный массив");

arr_quick.out_mass_a();}

arr_quick.QuickSort(0,razm_min+k*d-1,k);

Form1->Series9->AddXY(razm_min+k*d,arr_quick.get_sr(),"",clBlack);

Form1->Series10->AddXY(razm_min+k*d,arr_quick.get_obm(),"",clBlack);

if(razm_min+k*d==razm_out){

Form1->Memo1->Lines->Add("Отсортированный массив");

arr_quick.out_mass_a();}

if(k*d%t==0){

Form1->StringGrid1->Cells[0][k*d/t+1]=IntToStr(razm_min+k*d);

Form1->StringGrid2->Cells[0][k*d/t+1]=IntToStr(razm_min+k*d);

Form1->StringGrid1->Cells[1][k*d/t+1]=IntToStr(arr_swap.get_sr());

Form1->StringGrid2->Cells[1][k*d/t+1]=IntToStr(arr_swap.get_obm());

Form1->StringGrid1->Cells[2][k*d/t+1]=IntToStr(arr_select.get_sr());

Form1->StringGrid2->Cells[2][k*d/t+1]=IntToStr(arr_select.get_obm());

Form1->StringGrid1->Cells[3][k*d/t+1]=IntToStr(arr_insert.get_sr());

Form1->StringGrid2->Cells[3][k*d/t+1]=IntToStr(arr_insert.get_obm());

Form1->StringGrid1->Cells[4][k*d/t+1]=IntToStr(arr_bubble.get_sr());

Form1->StringGrid2->Cells[4][k*d/t+1]=IntToStr(arr_bubble.get_obm());

Form1->StringGrid1->Cells[5][k*d/t+1]=IntToStr(arr_quick.get_sr());

Form1->StringGrid2->Cells[5][k*d/t+1]=IntToStr(arr_quick.get_obm());

}

current+=1;

ProgressBar1->Position=100*current/count;

}

sort->Enabled=false;

}

//---------------------------------------------------------------------------

AnsiString fn1="swap.bmp",fn2="select.bmp",fn3="insert.bmp",

fn4="bubble.bmp",fn5="quick.bmp";

void __fastcall TForm1::N2Click(TObject *Sender)

{

Form1->Image1->Picture->LoadFromFile(fn1);

Form1->Image2->Picture->LoadFromFile(fn2);

Form1->Image3->Picture->LoadFromFile(fn3);

Form1->Image4->Picture->LoadFromFile(fn4);

Form1->Image5->Picture->LoadFromFile(fn5);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N3Click(TObject *Sender)

{

Form1->Chart1->SaveToBitmapFile(fn1);

Form1->Chart2->SaveToBitmapFile(fn2);

Form1->Chart3->SaveToBitmapFile(fn3);

Form1->Chart4->SaveToBitmapFile(fn4);

Form1->Chart5->SaveToBitmapFile(fn5);

MessageBox(NULL,"Все графики выведены в файлы!",

"5 пар графиков!",MB_OK);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N1Click(TObject *Sender)

{

Form1->Chart1->SaveToBitmapFile(fn1);

MessageBox(NULL,"Графики (обменами) выведены в файл!",

"Сортировка обменами",MB_OK);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N4Click(TObject *Sender)

{

Form1->Image1->Picture->LoadFromFile(fn1);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N5Click(TObject *Sender)

{

Form1->Chart2->SaveToBitmapFile(fn2);

MessageBox(NULL,"Графики (выбором) выведены в файл!",

"Сортировка выбором",MB_OK);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N6Click(TObject *Sender)

{

Form1->Image2->Picture->LoadFromFile(fn2);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N7Click(TObject *Sender)

{

Form1->Chart3->SaveToBitmapFile(fn3);

MessageBox(NULL,"Графики (вставками) выведены в файл!",

"Сортировка вставками",MB_OK);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N8Click(TObject *Sender)

{

Form1->Image3->Picture->LoadFromFile(fn3);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N9Click(TObject *Sender)

{

Form1->Chart4->SaveToBitmapFile(fn4);

MessageBox(NULL,"Графики (пузырьком) выведены в файл!",

"Сортировка пузырьком",MB_OK);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N10Click(TObject *Sender)

{

Form1->Image4->Picture->LoadFromFile(fn4);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N11Click(TObject *Sender)

{

Form1->Chart5->SaveToBitmapFile(fn5);

MessageBox(NULL,"Графики (быстрая) выведены в файл!",

"Быстрая сортировка",MB_OK);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N12Click(TObject *Sender)

{

Form1->Image5->Picture->LoadFromFile(fn5);

}

//---------------------------------------------------------------------------

void __fastcall TForm1::helpClick(TObject *Sender)

{

MessageBox(NULL,"Разработаны в г. студентом гр. ","Рекурсивные функции для сортировки массивов",MB_OK);

}

//---------------------------------------------------------------------------