Реализация библиотеки для работы с

Вид материала

Документы

Содержание Основной файл (реализация пользовательского интерфейса) Листинг программы на Delphi

Подобный материал:

• План работы библиотеки зав библиотекой Полещук Людмила Дмитриевна Анализ работы библиотеки, 363.46kb.
• Реализация комплексной программы автоматизации обслуживания пользователей в библиотеке, 81.9kb.
• План работы библиотеки Муниципального бюджетного общеобразовательного учреждения основной, 511.68kb.
• Годовой план работы библиотеки псош №46 имени В. П. Астафьева на 2008 2009 учебный, 536.46kb.
• В. М. Красильщикова Советник отдела библиотек, 110.39kb.
• Задачи конкурса -повысить престиж библиотеки как современного информационного и культурного, 108.49kb.
• Зональной научной библиотеки, 1482.03kb.
• План работы библиотеки моу «Миндерлинская сош» на 2010 -2011 учебный год Задачи библиотеки, 63.53kb.
• План работы школьной библиотеки мбоу краснокаменская сош №4 на 2011/2012 учебный год., 170.02kb.
• План работы Никольской сельской библиотеки на 2011, 33.87kb.

Основной файл (реализация пользовательского интерфейса)

// OopDll1.cpp : Defines the entry point for the console application.

//

// for visual

#include “stdafx.h”

#include “Gudkov.h”

#pragma hdrstop

#include

#include

#include

#include


// for borland

/*

#include

#include

#include

#include

#include

*/


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

using namespace std;


int _tmain(int argc, _TCHAR* argv[])

{

char x[10];

int choice;

bool fQuit = false;

MyArr myArrayStatic;

MyArr myTwoDimenArray;


while (1)

{

cout<<(Rus(“\n\n\t\t=====ГЛАВНОЕ МЕНЮ=====”))<<”\n”;

cout<<(Rus(«\t\t Выберите массив»))<<»\n»;

cout<<(Rus(« 1 – Одноменый статический массив\n 2 – Двумерный статический массив сортируемый по строкам»))<<»\n»;

cout<<(Rus(« 3 – Двумерный статический массив сортируемый по столбцам»))<<»\n»;

cout<<(Rus(« 4 – Одномерный динамический массив\n 5 – Двумерный динамический массив сортируемый по строкам»))<<»\n»;

cout<<(Rus(« 0 – Завершить работу»))<<»\n»;


while (1)

{

cin >> x ;

if (myArrayStatic.check(x) )

{

choice=atoi(x) ;

if (choice>=0 && choice<=6) { break; }

else myArrayStatic.MyError(4, x);

}

else myArrayStatic.MyError(0, x);

}

switch (choice) {

case 1:

{

myArrayStatic.createArrayStatic();

SearchAndSort mySearchAndSort;

cout<<(Rus(“\tОдноменый статический массив”))<<”\n”;

mySearchAndSort.printArray();

/* mySearchAndSort.searchMax(); === ПОИСК МИНИМУМА И МАКСИМУМА, ИХ НОМЕРОВ В ОДНОМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ

mySearchAndSort.searchMin(); И ВЫВОД НА МОНИТОР

cout<<(Rus(«\tМаксимальный элемент в массиве»))<<»\n»;

cout<<”\t\t”<
cout<<(Rus(«\t его номер»))<<»\n»;

cout<<”\t\t”<
cout<<(Rus(«\tМинимальный элемент в массиве»))<<»\n»;

cout<<”\t\t”<
cout<<(Rus(«\t его номер»))<<»\n»;

cout<<”\t\t”<
/* mySearchAndSort.SortMin(); === СОРТИРОВКА ВСТАВКАМИ ОДНОМЕРНОГО СТАТИЧЕСКОГО МАССИВА ПО ВОЗРАСТАНИЮ

cout<<(Rus(«\tОтсортированный массив по возрастанию»))<<»\n»; И ВЫВОД НА МОНИТОР

mySearchAndSort.printArray(); */

/* mySearchAndSort.SortMax(); === СОРТИРОВКА ВСТАВКАМИ ОДНОМЕРНОГО СТАТИЧЕСКОГО МАССИВА ПО УБЫВАНИЮ

cout<<(Rus(«\tОтсортированный массив по убыванию»))<<»\n»; И ВЫВОД НА МОНИТОР

mySearchAndSort.printArray(); */

break ;

}

case 2:

{

TwoDimenStr myTwoDimStr;

myTwoDimenArray.createTwoDimenArray();

myTwoDimStr.createNewArrayStatic();

cout<<(Rus(“\tДвумерный статический массив”))<<”\n”;

myTwoDimStr.printTwoDimArray();

/* myTwoDimStr.searchMaxT(); === ПОИСК МИНИМУМА И МАКСИМУМА, ИХ НОМЕРОВ В ДВУМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ

myTwoDimStr.searchMinT(); ПО СТРОКАМ И ВЫВОД НА МОНИТОР

cout<<(Rus(«\tМаксимальный элемент в массиве»))<<»\n»;

cout<<”\t\t”<
cout<<(Rus(«\t его номер»))<<»\n»;

cout<<”\t\t”<
cout<<(Rus(«\tМинимальный элемент в массиве»))<<»\n»;

cout<<”\t\t”<
cout<<(Rus(«\t его номер»))<<»\n»;

cout<<”\t\t”<
/* myTwoDimStr.SortMin(); === СОРТИРОВКА ВСТАВКАМИ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ПО ВОЗРАСТАНИЮ ПО СТРОКАМ

cout<<(Rus(«\tОтсортированный массив по возрастанию»))<<»\n»; И ВЫВОД НА МОНИТОР

myTwoDimStr.printArray();*/

/* myTwoDimStr.SortMax(); === СОРТИРОВКА ВСТАВКАМИ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ПО УБЫВАНИЮ ПО СТРОКАМ

cout<<(Rus(«\tОтсортированный массив по убыванию»))<<»\n»; И ВЫВОД НА МОНИТОР

myTwoDimStr.printArray();*/

break;

}

case 3:

{

TwoDimenCol myTwoDimCol;

myTwoDimenArray.createTwoDimenArray();

myTwoDimCol.createNewArrayStatic();

cout<<(Rus(“\tДвумерный статический массив”))<<”\n”;

myTwoDimCol.printTwoDimArray();

/* myTwoDimCol.searchMaxT(); // === ПОИСК МИНИМУМА И МАКСИМУМА, ИХ НОМЕРОВ В ДВУМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ

myTwoDimCol.searchMinT(); // ПО СТОЛБЦАМ И ВЫВОД НА МОНИТОР

cout<<(Rus(«\tМаксимальный элемент в массиве»))<<»\n»;

cout<<”\t\t”<
cout<<(Rus(«\t его номер»))<<»\n»;

cout<<”\t\t”<
cout<<(Rus(«\tМинимальный элемент в массиве»))<<»\n»;

cout<<”\t\t”<
cout<<(Rus(«\t его номер»))<<»\n»;

cout<<”\t\t”<
/* myTwoDimCol.SortMin(); // === СОРТИРОВКА ВСТАВКАМИ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ПО ВОЗРАСТАНИЮ ПО СТОЛБЦАМ

cout<<(Rus(«\tОтсортированный массив по возрастанию»))<<»\n»; // И ВЫВОД НА МОНИТОР

myTwoDimCol.printArray(); */

/* myTwoDimCol.SortMax(); // === СОРТИРОВКА ВСТАВКАМИ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ПО УБЫВАНИЮ ПО СТОЛБЦАМ

cout<<(Rus(«\tОтсортированный массив по убыванию»))<<»\n»; // И ВЫВОД НА МОНИТОР

myTwoDimCol.printArray();//*/

break;

}

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

case 4:

{

myArrayStatic.createDynArray();

cout<<(Rus(«\tОдноменый динамический массив»))<<»\n»;

cout<<(Rus(«\nСортировка методом вставки «))<<»\n»;

vp.sort_p(n);

vp.print(n);

cout<<(Rus(«\nСортировка методом пузырька «))<<»\n»;

vb.sort_b(n);

vp.print(n);

cout<<(Rus(«\nОбменная сортировка «))<<»\n»;

vp.sort_p(n);

vp.print(n);

break;

}

case 5:

{

myArrayStatic.createDynArrayT();

cout<<(Rus(“\tДвумерный динамический массив”))<<”\n”;

cout<<(Rus(«\nСортировка методом вставки «))<<»\n»;

vp.sort_p(s*c);

vp.print(s*c);

cout<<(Rus(«\nСортировка методом вставки «))<<»\n»;

wp.rebuild();

wp.print();

break;

}

default:

fQuit = true ;

break;

}

if (fQuit) {

break;

}

}

return 0;

}


Листинг программы на Delphi

Заголовочный файл (объявление классов и реализация методов)

unit listing5;


interface


uses

SysUtils;

//------------------- КОНСТАНТЫ ---------------------------------------------

const

nn=127;

ss=127; // строки

cc=127; // столбцы

ll=(ss*cc);

//------------------- ПЕРЕМЕННЫЕ ---------------------------------------------

var

n,s,c,l,m,h:integer;

ArrayStatic : array[1..nn] of ShortInt;

TwoDimenArray : array[1..ss,1..cc] of ShortInt;

NewArrayStatic : array[1..ll] of ShortInt;

//-----

ArrayDynamic : array of ShortInt; // одномерный динамич. массив

ArrayDynamicT: array of array of ShortInt ; // двумерный динамич. массив

TwoDimenArrayD: array of shortInt;


//---------------------ОБЪЯВЛЕНИЕ КЛАССОВ------------------------------------


type MyArr = class

public

procedure createArrayStatic();

procedure createTwoDimenArray();

function check(x: string):boolean;

procedure myError(a: shortint; s: string);

//--------

procedure createDynArray();

procedure deleteDynArray();


//--------

procedure createDynArrayT();

procedure deleteDynArrayT();


end; {class MyArr}

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

type SearchAndSort = class

constructor Create();

Destructor Destroy; override;


public

max:ShortInt;

numMax:ShortInt;

min:ShortInt;

numMin:ShortInt;

maxT:ShortInt;

numMaxS:ShortInt;

numMaxC:ShortInt;

minT:ShortInt;

numMinS:ShortInt;

numMinC:ShortInt;


function searchMax():ShortInt;

procedure searchMin();

procedure searchMinForSort(pos:ShortInt);

procedure searchMaxForSort(pos:ShortInt);

procedure SortMin();

procedure SortMax();

procedure printArray();

procedure printTwoDimArray();

procedure printArrayD();

procedure printDynArrayT();

procedure SortBubbleMax();

procedure SortBubbleMin();

procedure DTMax();

procedure DTMin();

procedure TMax();

procedure TMin();

function GetMax():ShortInt;

function GetNumMax():ShortInt;

function GetMin():ShortInt;

function GetNumMin():ShortInt;


end; {class SearchAndSort}

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

type TwoDimenStr = class (SearchAndSort)

constructor Create();

Destructor Destroy; override;

public

procedure createNewArrayStatic();

procedure searchMax();

procedure searchMin();

procedure searchMinForSort(pos:ShortInt);

procedure searchMaxForSort(pos:ShortInt);

procedure SortMin();

procedure SortMax();

procedure printArray();

end; {class TwoDimenStr}

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


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

type TwoDimenStrD = class (SearchAndSort)

constructor Create();

Destructor Destroy; override;

public

procedure createNewArrayDynamic();

procedure searchMax();

procedure searchMin();

procedure searchMinForSort(pos:ShortInt);

procedure searchMaxForSort(pos:ShortInt);

procedure SortMin();

procedure SortMax();

procedure printArray();

//procedure SortBubbleMax();

//procedure SortBubbleMin();

// procedure deleteArray();

end; {class TwoDimenStr}


type TwoDimenCol = class(SearchAndSort)

constructor Create();

Destructor Destroy; override;

public

procedure createNewArrayStatic();

procedure searchMax();

procedure searchMin();

procedure searchMinForSort(pos:ShortInt);

procedure searchMaxForSort(pos:ShortInt);

procedure SortMin();

procedure SortMax();

procedure printArray();

end; {class TwoDimenCol}

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


//------------------- ОБЪЯВЛЕНИЕ РУССИФИКАТОРА-------------------------------

function rus(s:string):string;

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

implementation

//-------------------РЕАЛИЗАЦИЯ МЕТОДОВ---------------------------------


//======================= ОБЩИЕ МЕТОДЫ ==================================


//------------------- РУССИФИКАТОР -------------------------------------

function rus(s:string):string;

var i:longint;

begin

for i:=1 to length(s) do

begin

if ord(s[i]) in [129..239]then s[i]:=chr(ord(s[i])-64);

if ord(s[i]) in [240..255]then s[i]:=chr(ord(s[i])-16);

end;

RUS:=s

end;

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

//------------------- СООБЩЕНИЯ ОБ ОШИБКАХ -------------------------------------

procedure MyArr.myError(a: shortint; s: string);


begin

case a of

0 :

begin

writeln(Rus('Введенное вами значение '):34,s,Rus(' не является целым числом'));

writeln;

end;

1 :

begin

writeln(Rus('Введенное вами значение выходит за пределы заданного диапазона'));

writeln;

end;


2 :

begin

writeln(Rus('Данного пункта меню не существует'):48);

writeln;

end;


end;

end;

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

//------------------ ПРОВЕРКА ВВОДИМЫХ ДАННЫХ ----------------------------------

function MyArr.check(x: string):boolean;

var


d:boolean;

Code, temp : integer;

begin


if (x='')


then d:=false

else

begin

if (x[1]='-')

then delete(x,6,Length(x))

else delete(x,5,Length(x));


Val(x,temp,Code);

if (Code<>0)

then

begin d := false; myError(0, x); end

else

begin

if ((temp>=-128) and (temp<=127))

then d :=true

else begin d := false; myError(1, x); end;

end;

end;

Result:=d;

end;

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

//------------- СОЗДАНИЕ ОДНОМЕРНОГО СТАТИЧЕСКОГО МАССИВА ------------------------

procedure myArr.createArrayStatic();

var

x:string;

i,a:shortInt;

begin

i:=1;

while (true) do

begin

writeln(Rus('Введите количество элементов массива от 1 до 127'));

readln(x);


if (check(x)) then

begin

n:=StrToInt(x);

if ((n>0) and (n<=127)) then Break else myError(1, x);

end;

end;


while (i
begin

writeln(Rus('Вводите элементы массива - целые числа от -128 до 127'));

readln(x);

if (check(x)) then

begin

a:=StrToInt(x) ;

if ((a>=-128) and (a<=127)) then

begin ArrayStatic[i]:=a; i:=i+1; end

end

end

end;

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

//--------------- СОЗДАНИЕ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА -------------------

procedure MyArr.createTwoDimenArray();

var

x,y,el:string;

j,i,k,a,temp:shortInt;

begin

k:=1;

while (true) do

begin

writeln(Rus('Введите количество строк двумерного массива от 0 до 127'));

readln(x);

if (check(x)) then

begin

n:=StrToInt(x) ;

if ((n>0) and (n<=127)) then Break else myError(1, x);

end;

end;


while (true) do

begin

write(Rus('Введите количество столбцов массива от 1 до '));

writeln ( 127 div StrToInt(x));

readLN(y) ;

if (check(y) ) then

begin

n:=StrToInt(y) ;

if ((n>0) and (n<=(127div(StrToInt(x))))) then Break else myError(1, x)

end;

end;


s:=StrToInt(x);

c:=StrToInt(y);

while (k
begin

WriteLN(Rus('Введите элемент массива - целое число от -128 до 127'));

ReadLN(el) ;

if (check(el)) then

begin

a:=StrToInt(el) ;

if ((a>=-128) and (a<=127))then

begin

ArrayStatic[k]:=a;

k:=k+1;

end

end

end;

k:=1;

for i:=1 to s do

for j := 1 to c do

begin

temp := ArrayStatic[k];

TwoDimenArray[i][j] := temp;

k:=k+1;

end;


end;


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

//--------------- СОЗДАНИЕ ОДНОМЕРНОГО ДИНАМИЧЕСКОГО МАССИВА -------------------

procedure myArr.createDynArray();

var

x:string;

i,a:shortInt;

begin

i:=0;

while (true) do

begin

writeln(Rus('Введите количество элементов массива от 1 до 127'));

readln(x);


if (check(x)) then

begin

n:=StrToInt(x);

if ((n>0) and (n<=127)) then Break else myError(1, x);

end;

end;


SetLength(ArrayDynamic,n);


while (i
begin

writeln(Rus('Вводите элементы массива - целые числа от -128 до 127'));

readln(x);

if (check(x)) then

begin

a:=StrToInt(x) ;

if ((a>=-128) and (a<=127)) then

begin ArrayDynamic[i]:=a; i:=i+1; end

end

end

end;


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

//--------------- УДАЛЕНИЕ ОДНОМЕРНОГО ДИНАМИЧЕСКОГО МАССИВА -------------------

procedure MyArr.deleteDynArray();

begin

ArrayDynamic:=nil;

end;//deleteDynArray

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

//--------------- СОЗДАНИЕ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА -------------------

procedure myArr.createDynArrayT();

var

x:string;

j,i,a:shortInt;

temp: shortint;

begin

i:=0;

while (true) do

begin

writeln(Rus('Введите количество строк массива от 1 до 127'));

readln(x);


if (check(x)) then

begin

m:=StrToInt(x);

if ((m>0) and (m<=127)) then Break else myError(1, x);

end;

end;


while (true) do

begin

writeln(Rus('Введите количество столбцов массива от 1 до '),127 div StrToInt(x));

readln(x);


if (check(x)) then

begin

h:=StrToInt(x);

if ((h>0) and (h<=127 div StrToInt(x))) then Break else myError(1, x);

end;

end;


SetLength(ArrayDynamic,m*h);


while (i<(m*h)) do

begin

writeln(Rus('Вводите элементы массива - целые числа от -128 до 127'));

readln(x);

if (check(x)) then

begin

a:=StrToInt(x) ;

if ((a>=-128) and (a<=127)) then

begin ArrayDynamic[i]:=a; i:=i+1; end

end//if

end ; //while


i:=0;

SetLength(ArrayDynamicT,m,h);


for l:= 0 to m-1 do

begin

for j:=0 to h-1 do

begin

ArrayDynamicT[l,j]:=ArrayDynamic[i];//temp;

i:=i+1;

end;//for2

end;//for


end;//createArrayDinamicT


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

//--------------- УДАЛЕНИЕ ОДНОМЕРНОГО ДИНАМИЧЕСКОГО МАССИВА -------------------

procedure MyArr.deleteDynArrayT();

begin

ArrayDynamic:=nil;

ArrayDynamicT:=nil;

end;//deleteDynArray

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

//--- ВЫВОД НА ПЕЧАТЬ ОДНОМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

Procedure SearchAndSort.printArray();

var i:shortInt;

begin

for i := 1 to n do

begin

Write(ArrayStatic[i]);

write(' ');

end;

writeln;


end;


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

//--- ВЫВОД НА ПЕЧАТЬ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---

procedure SearchAndSort.printTwoDimArray();

var i,j:shortInt;

begin

for i := 1 to s do

begin

for j := 1 to c do

begin

write (TwoDimenArray[i][j]:4);

write(' ');

end;

writeln;

end;

writeln;

end;


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

//--- ВЫВОД НА ПЕЧАТЬ ОДНОМЕРНОГО ДИНАМИЧЕСКОГО МАССИВА ---

procedure SearchAndSort.printArrayD();

var i : ShortInt;

begin

i:=0;

while (i
begin

write(ArrayDynamic[i],' ');

if i=0 then write('')

else

if (i mod 10 =0) and (i<>n) then writeln;

i:=i+1;

end;

writeln;

end;//printArrayD


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

//--------- ВЫВОД НА ПЕЧАТЬ ДВУМЕРНОГО ДИНАМИЧЕСКОГО МАССИВА ----------


procedure SearchAndSort.printDynArrayT();

var l,j:shortInt;

begin

for l := 0 to m-1 do

begin

for j := 0 to h-1 do

begin

write (ArrayDynamicT[l,j]);

write(' ');

end;

writeln;

end;

writeln;

end;//printDynArrayT


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

//------------ КОНСТРУКТОР КЛАССА SearchAndSort----------

constructor SearchAndSort.Create();

begin

end;

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

//------------ ДЕСТРУКТОВ КЛАССА SearchAndSort----------

destructor SearchAndSort.Destroy;

begin

end;


//================= ИНДИВИДУАЛЬНЫЕ МЕТОДЫ ======================


//----------------- СОРТИРОВКА МЕТОДОМ ПУЗЫРЬКА ПО УБЫВАНИЮ-----------------


procedure SearchAndSort.SortBubbleMax();

var i,j,tmp:shortint;

begin

for i:=n-2 downto 0 do

for j:=0 to i do

if ArrayDynamic[j]>ArrayDynamic[j+1] then

begin

tmp := ArrayDynamic[j];

ArrayDynamic[j]:=ArrayDynamic[j+1];

ArrayDynamic[j+1]:=tmp;

end;//if

end;//SortBubble

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

//----------------- СОРТИРОВКА МЕТОДОМ ПУЗЫРЬКА ПО ВОЗРАСТАНИЮ----------------

procedure SearchAndSort.SortBubbleMin();

var i,j,tmp:shortint;

begin

for i:=n-2 downto 0 do

for j:=0 to i do

if ArrayDynamic[j]
begin

tmp := ArrayDynamic[j];

ArrayDynamic[j]:=ArrayDynamic[j+1];

ArrayDynamic[j+1]:=tmp;

end;//if

end;//SortBubble


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

//----------------- КОНСТРУКТОР КЛАССА TwoDimenStrD----------------


constructor TwoDimenStrD.Create();

begin

end;

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

//----------------- ДЕСТРУКТОР КЛАССА TwoDimenStrD----------------

destructor TwoDimenStrD.Destroy();

begin

end;

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

//--ВЫПРЯМЛЕНИЕ ДВУМЕРНОГО ДИНАМИЧЕСКОГО МАССИВА В ОДНОМЕРНЫЙ ПО СТРОКАМ------


procedure TwoDimenStrD.createNewArrayDynamic();

var l,j,k,i:shortInt;

temp:shortint;


begin


temp:=0;

k:=0;

for l:=0 to m-1 do

begin

for j:= 0 to h-1 do

begin


temp:=ArrayDynamicT[l,j];

ArrayDynamic[k]:=temp;

// write (ArrayDynamic[k],' ');

k:=k+1;

end;

end;

n:=k;

end;


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

//----------------- ПОИСК МАКСИМУМА В ДВУМЕРНОМ ДИНАМИЧЕСКИМ МАССИВЕ-----------

procedure TwoDimenStrD.searchMax();

var

i:shortint;

begin

s:=m*h;

max := ArrayDynamic[0];

numMax := 1;

for i := 0 to s-1 do

if (ArrayDynamic[i] > max) then

begin

max := ArrayDynamic[i];

numMax := i+1 ;

end

end;

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

//----------------- ПОИСК МИНИМУМА В ДВУМЕРНОМ ДИНАМИЧЕСКИМ МАССИВЕ-----------

procedure TwoDimenStrD.searchMin();

var i:shortint;

begin

s:=m*h;

min := ArrayDynamic[0];

numMin := 1;

for i := 0 to s-1 do

if (ArrayDynamic[i] < min) then

begin

min := ArrayDynamic[i];

numMin := i+1 ;

end;

end;


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

//------ ПОИСК МИНИМУМА В ДВУМЕРНОМ ДИНАМИЧЕСКИМ МАССИВЕ ДЛЯ СОРТИРОВКИ-------

procedure TwoDimenStrD.searchMinForSort(pos:shortint);

var i:shortint;

begin

s:=m*h;

min := ArrayDynamic[pos];

numMin := pos;

for i := pos to s-1 do

if (ArrayDynamic[i] < min) then

begin

min := ArrayDynamic[i];

numMin := i ;

end;

end;

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

//---- СОРТИРОВКА ВСТАВКАМИ В ДВУМЕРНОМ ДИНАМИЧЕСКИМ МАССИВЕ ПО ВОЗРАСТАНЮ-----


procedure TwoDimenStrD.SortMin();

var i,temp:shortint;

begin

s:=m*h;

for i:=0 to s-1 do

begin

searchMinForSort(i);

temp := ArrayDynamic[i];

ArrayDynamic[i] := GetMin();

ArrayDynamic[GetNumMin()] := temp;

end;

end;

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

//------ ПОИСК МАКСИМУМА В ДВУМЕРНОМ ДИНАМИЧЕСКИМ МАССИВЕ ДЛЯ СОРТИРОВКИ--------

procedure TwoDimenStrD.searchMaxForSort(pos:shortint);

var i:shortint;

begin

s:=m*h;

max := ArrayDynamic[pos];

numMax := pos;

for i := pos to s-1 do

if (ArrayDynamic[i] > max) then

begin

max := ArrayDynamic[i];

numMax := i ;

end;

end;

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

//---- СОРТИРОВКА ВСТАВКАМИ В ДВУМЕРНОМ ДИНАМИЧЕСКИМ МАССИВЕ ПО УБЫВАНИЮ-----

procedure TwoDimenStrD.SortMax();

var

temp,i:shortint;

begin

s:=m*h;

for i:=0 to s-1 do

begin

searchMaxForSort(i);

temp := ArrayDynamic[i];

ArrayDynamic[i] := GetMax();

ArrayDynamic[GetNumMax()] := temp;

end;

end;


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

//-------------- ВЫВОД ОТСОРТИРОВАННОГО МАССИВА НА МОНИТОР----------


procedure TwoDimenStrD.printArray ();

var

temp,k,i,j:shortint;

begin

k:=0;

for l:=0 to m-1 do

begin

for j := 0 to h-1 do

begin

temp := ArrayDynamic[k];

ArrayDynamicT[l][j]:=temp;

write(ArrayDynamicT[l][j]:4);write(' ');

k:=k+1;

end;

writeln;

end;

writeln;

end;

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

{procedure MyArr.TwoDimenCol();

var l,j,k,i:shortInt;

temp:shortint;


begin


temp:=0;

k:=0;

for j:= 0 to h-1 do

begin

for l:=0 to m-1 do

begin


temp:=ArrayDynamicT[l,j];

ArrayDynamic[k]:=temp;

// write (ArrayDynamic[k],' ');

k:=k+1;

end;

end;

n:=k;

SortBubbleMax();

writeLn(Rus('Отсортированный массив по возрастанию'):48);

i:=0;

SetLength(ArrayDynamicT,m,h);


for j:=0 to h-1 do

begin

for l:= 0 to m-1 do

begin

ArrayDynamicT[l,j]:=ArrayDynamic[i];//temp;

i:=i+1;

end;//for2

end;//for

printDynArrayT();

SortBubbleMin();

writeLn(Rus('Отсортированный массив по убыванию'):48);


i:=0;

for j:=0 to h-1 do

begin

for l:= 0 to m-1 do

begin

ArrayDynamicT[l,j]:=ArrayDynamic[i];//temp;

i:=i+1;

end;//for2

end;//for

printDynArrayT();

end;//TwoDimaenStr


}

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


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


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


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

//-------------- ПОИСК МАКСИМУМА ДЛЯ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---------


procedure SearchAndSort.TMax();

var

i,j:shortint;

begin

maxT := TwoDimenArray[1][1];

numMaxS := 1;

numMaxC := 1;

for i := 1 to s do

for j := 1 to c do

begin

if (TwoDimenArray[i][j] > maxT) then

begin

maxT := TwoDimenArray[i][j];

numMaxS := i ;

numMaxC := j ;

end;

end;

writeln(Rus ('Значене максимального элемента:'), maxT, Rus('его строка: '), numMaxS, Rus(' его столбец: '), numMaxC);

end;

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

//-------------- ПОИСК МИНИМУМА ДЛЯ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА ----------


procedure SearchAndSort.TMin();

var

i,j:shortint;

begin

minT := TwoDimenArray[1][1];

numMinS := 1;

numMinC := 1;

for i := 1 to s do

for j := 1 to c do

begin

if (TwoDimenArray[i][j] < minT) then

begin

minT := TwoDimenArray[i][j];

numMinS := i ;

numMinC := j ;

end;

end;

write(Rus ('Значене минимума элемента:'), minT);

write(Rus('его строка: '), numMinS);

writeln (Rus(' его столбец: '),numMinC);

end;

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

//-------------- ПОИСК МАКСИМУМА ДЛЯ ДВУМЕРНОГО ДИНАМИЧЕСКОГО МАССИВА ---------

procedure SearchAndSort.DTMax();

var

l,j:shortint;

begin

maxT := ArrayDynamicT[0,0];

numMaxS := 1;

numMaxC := 1;

for l := 0 to m-1 do

for j := 0 to h-1 do

begin

if (ArrayDynamicT[l,j] > maxT) then

begin

maxT := ArrayDynamicT[l,j];

numMaxS := l+1 ;

numMaxC := j+1 ;

end;

end;

write(Rus ('Значене максимального элемента:'), maxT);

write( Rus('его строка: '), numMaxS);

writeln(Rus(' его столбец: '),numMaxC);


end;

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

//-------------- ПОИСК МИНИМУМА ДЛЯ ДВУМЕРНОГО ДИНАМИЧЕСКОГО МАССИВА ---------

procedure searchAndSort.DTMin();

var

l,j:shortint;

begin

minT := ArrayDynamicT[0,0];

numMinS := 1;

numMinC := 1;

for l := 0 to m-1 do

for j := 0 to h-1 do

begin

if (ArrayDynamicT[l,j] < minT) then

begin

minT := ArrayDynamicT[l,j];

numMinS := l+1 ;

numMinC := j+1 ;

end;

end;

write(Rus ('Значене минимума элемента:'), maxT);

write( Rus('его строка: '), numMaxS);

writeln(Rus(' его столбец: '),numMaxC);

end;

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

//-------------- ПОИСК МАКСИМУМА ДЛЯ ОДНОМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---------

function SearchAndSort.searchMax():ShortInt;

var

i:shortInt;

begin

max := ArrayStatic[1];

numMax := 1;

for i := 1 to n do

if (ArrayStatic[i] > max) then

begin

max := ArrayStatic[i];

numMax := i;

end;

Result:=numMax;

end;

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

//-------------- ПОИСК МИНИМУМА ДЛЯ ОДНОМЕРНОГО СТАТИЧЕСКОГО МАССИВА ---------

procedure SearchAndSort.searchMin();

var

i:shortInt;

begin

min := ArrayStatic[1];

numMin := 1;

for i := 1 to n do

if (ArrayStatic[i] < min) then

begin

min := ArrayStatic[i];

numMin := i;

end;

end;

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

//-------------- ПОИСК МИНИМУМА СОРТИРОВКИ ---------

procedure SearchAndSort.searchMinForSort(pos:shortInt );

var i:shortInt;

begin

min := ArrayStatic[pos];

numMin := pos;

for i := pos to n do

if (ArrayStatic[i] < min) then

begin

min := ArrayStatic[i];

numMin := i ;

end;

end;


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

//---- СОРТИРОВКА ВСТАВКАМИ В ОДНОМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ ПО ВОЗРАСТАНЮ-----

procedure SearchAndSort.SortMin();

var

temp,i:shortInt;

begin

for i:=1 to n do

begin

searchMinForSort(i);

temp := ArrayStatic[i];

ArrayStatic[i] := GetMin();

ArrayStatic[GetNumMin()] := temp;

end;

end;


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

//-------------- ПОИСК МАКСИМУМА СОРТИРОВКИ ---------

procedure SearchAndSort.searchMaxForSort(pos:shortint );

var i:shortInt;

begin

max := ArrayStatic[pos];

numMax := pos;

for i := pos to n do

if (ArrayStatic[i] > max) then

begin

max := ArrayStatic[i];

numMax := i ;

end;

end;


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

//---- СОРТИРОВКА ВСТАВКАМИ В ОДНОМЕРНОМ СТАТИЧЕСКОМ МАССИВЕ ПО УБЫВАНИЮ-----


procedure SearchAndSort.SortMax();

var

temp,i:shortInt;

begin

for i:=1 to n do

begin

searchMaxForSort(i);

temp := ArrayStatic[i];

ArrayStatic[i] := GetMax();

ArrayStatic[GetNumMax()] := temp;

end;

end;


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

//--- ВЗЯТИЕ ПЕРВОГО МАКСИМАЛЬНОГО ЭЛЕМЕНТА В МАССИВЕ ---

function SearchAndSort.GetMax():ShortInt;

begin

Result:=max;

end;

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

//--- ВЗЯТИЕ НОМЕРА ПЕРВОГО МАКСИМАЛЬНОГО ЭЛЕМЕНТА В МАССИВЕ ---

function SearchAndSort.GetNumMax():ShortInt;

begin

Result:=numMax;

end;

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

//--- ВЗЯТИЕ ПЕРВОГО МИНИМАЛЬНОГО ЭЛЕМЕНТА В МАССИВЕ ---

function SearchAndSort.GetMin():ShortInt;

begin

Result:=min;

end;

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

//--- ВЗЯТИЕ НОМЕРА ПЕРВОГО МИНИМАЛЬНОГО ЭЛЕМЕНТА В МАССИВЕ ---

function SearchAndSort.GetNumMin():ShortInt;

begin

Result:=numMin;

end;

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

//-------------------КОНСТРУКТОР КЛАССА TwoDimenStr-----------------------


constructor TwoDimenStr.Create();

begin

end;

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

//-------------------ДЕСТРУКТОР КЛАССА TwoDimenStr-----------------------

destructor TwoDimenStr.Destroy;

begin

end;

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

//--ВЫПРЯМЛЕНИЕ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА В ОДНОМЕРНЫЙ ПО СТРОКАМ------

procedure TwoDimenStr.createNewArrayStatic ();

var

temp,k,i,j:shortInt;

begin

temp := 0;

k := 1;

for i := 1 to s do

for j := 1 to c do

begin

temp := TwoDimenArray [i][j];

NewArrayStatic[k]:=temp;

write (NewArrayStatic[k],' ');

k:=k+1;

end;

writeln;

end;


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

//--ПОИСК МАКСИМУМА В ДВУМЕРНОМ МАССИВЕ ------

procedure TwoDimenStr.searchMax();

var

i:shortint;

begin

l:=s*c;

max := NewArrayStatic[1];

numMax := 1;

for i := 1 to l do

if (NewArrayStatic[i] > max) then

begin

max := NewArrayStatic[i];

numMax := i ;

end

end;

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

//--ПОИСК МИНИМУМА ДВУМЕРНОМ МАССИВЕ ПО СТРОКАМ------

procedure TwoDimenStr.searchMin();

var i:shortint;

begin

l:=s*c;

min := NewArrayStatic[1];

numMin := 1;

for i := 1 to l do

if (NewArrayStatic[i] < min) then

begin

min := NewArrayStatic[i];

numMin := i ;

end;

end;

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

//--ПОИСК МИНИМУМА ДЛЯ СОРТИРОВКИ СТРОКАМ------

procedure TwoDimenStr.searchMinForSort(pos:shortint);

var i:shortint;

begin

l:=s*c;

min := NewArrayStatic[pos];

numMin := pos;

for i := pos to l do

if (NewArrayStatic[i] < min) then

begin

min := NewArrayStatic[i];

numMin := i ;

end;

end;

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

//--ПОИСК МИНИМУМА ДЛЯ СОРТИРОВКИ СТРОКАМ------

procedure TwoDimenStr.SortMin();

var i,temp:shortint;

begin

l:=s*c;

for i:=1 to l-1 do

begin

searchMinForSort(i);

temp := NewArrayStatic[i];

NewArrayStatic[i] := GetMin();

NewArrayStatic[GetNumMin()] := temp;

end;

end;

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

//--ПОИСК МАКСИМУМА ДЛЯ СОРТИРОВКИ ПО СТРОКАМ------

procedure TwoDimenStr.searchMaxForSort(pos:shortint);

var i:shortint;

begin

l:=s*c;

max := NewArrayStatic[pos];

numMax := pos;

for i := pos to l do

if (NewArrayStatic[i] > max) then

begin

max := NewArrayStatic[i];

numMax := i ;

end;

end;

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

//--СОРТИРОВКА ВСТАВКОЙ ПО УБЫВАНИЮ ПО СТРОКАМ------

procedure TwoDimenStr.SortMax();

var

temp,i:shortint;

begin

l:=s*c;

for i:=1 to l-1 do

begin

searchMaxForSort(i);

temp := NewArrayStatic[i];

NewArrayStatic[i] := GetMax();

NewArrayStatic[GetNumMax()] := temp;

end;

end;

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

//--ВЫВОД НА МОНИТОР ОТСОРТИРОВАННОГО МАССИВА ПО СТРОКАМ------

procedure TwoDimenStr.printArray ();

var

temp,k,i,j:shortint;

begin

k:=1;

for i:=1 to s do

for j := 1 to c do

begin

temp := NewArrayStatic[k];

TwoDimenArray[i][j]:=temp;

k:=k+1;

end;

for i := 1 to s do

begin

for j := 1 to c do

begin

write(TwoDimenArray[i][j]:4);

write(' ');

end;

writeln;

end;

writeln;

end;

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

//-------------------КОНСТРУКТОР КЛАССА TwoDimenStr-----------------------

constructor TwoDimenCol.Create();

begin

end;

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

//-------------------ДЕСТРУКТОР КЛАССА TwoDimenStr-----------------------

destructor TwoDimenCol.Destroy;

begin

end;

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

//--ВЫПРЯМЛЕНИЕ ДВУМЕРНОГО СТАТИЧЕСКОГО МАССИВА В ОДНОМЕРНЫЙ ПО СТОЛБЦАМ------

procedure TwoDimenCol.createNewArrayStatic ();

var

temp,k,i,j:shortint;

begin

temp := 0;

k := 1;

for j := 1 to c do

for i := 1 to s do

begin

temp := TwoDimenArray [i][j];

NewArrayStatic[k]:=temp;

write ( NewArrayStatic[k], ' ');

k:=k+1;

end;

writeln;

end;

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

//--ПОИСК МИНИМУМА ДВУМЕРНОМ МАССИВЕ ПО СТОЛЦАМ------

procedure TwoDimenCol.searchMax();

var i:shortint;

begin

l:=s*c;

max := NewArrayStatic[1];

numMax := 1;

for i := 1 to l do

if (NewArrayStatic[i] > max) then

begin

max := NewArrayStatic[i];

numMax := i ;

end;

end;

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

//--ПОИСК МИНИМУМА ДЛЯ СОРТИРОВКИ СТОЛБЦАМ------

procedure TwoDimenCol.searchMin();

var i:shortint;

begin

l:=s*c;

min := NewArrayStatic[1];

numMin := 1;

for i := 1 to l do

if (NewArrayStatic[i] < min) then

begin

min := NewArrayStatic[i];

numMin := i ;

end;

end;

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

//--ПОИСК МИНИМУМА ДЛЯ СОРТИРОВКИ СТОЛБЦАМ------

procedure TwoDimenCol.searchMinForSort(pos:shortint);

var i:shortint;

begin

l:=s*c;

min := NewArrayStatic[pos];

numMin := pos;

for i := pos to l do

if (NewArrayStatic[i] < min) then

begin

min := NewArrayStatic[i];

numMin := i ;

end;

end;

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

//--ПОИСК МИНИМУМА ДЛЯ СОРТИРОВКИ СТОЛБЦАМ------

procedure TwoDimenCol.SortMin();

var

temp,i:shortint;

begin

l:=s*c;


for i:=1 to l-1 do

begin

searchMinForSort(i);

temp := NewArrayStatic[i];

NewArrayStatic[i] := GetMin();

NewArrayStatic[GetNumMin()] := temp;

end;

end;

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

//--ПОИСК МАКСИМУМА ДЛЯ СОРТИРОВКИ ПО СТОЛБЦАМ------

procedure TwoDimenCol.searchMaxForSort(pos:shortint);

var

i:shortint;

begin

l:=s*c;

max := NewArrayStatic[pos];

numMax := pos;

for i := pos to l do

if (NewArrayStatic[i] > max) then

begin

max := NewArrayStatic[i];

numMax := i ;

end;

end;

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

//--СОРТИРОВКА ВСТАВКОЙ ПО УБЫВАНИЮ ПО СТОЛБЦАМ------

procedure TwoDimenCol.SortMax();

var

temp,i:shortint;

begin

l:=s*c;

for i:=1 to l-1 do

begin

searchMaxForSort(i);

temp := NewArrayStatic[i];

NewArrayStatic[i] := GetMax();

NewArrayStatic[GetNumMax()] := temp;

end;

end;

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

//--ВЫВОД НА МОНИТОР ОТСОРТИРОВАННОГО МАССИВА ПО СТОЛБЦАМ------

procedure TwoDimenCol.printArray ();

var temp,k,i,j:shortint;

begin

k:=1;

for i:=1 to c do

for j := 1 to s do

begin

temp := NewArrayStatic[k];

TwoDimenArray[j][i]:=temp;

k:=k+1;

end;

for i := 1 to s do

begin

for j := 1 to c do

begin

write(TwoDimenArray[i][j]:4);

write(' ');

end;

writeln;

end;

end;


end.