Объектно – ориентированное программирование

Федеральное агентство по образованию
Армавирский машиностроительный техникум
Методические указания для проведения практических работ
дисциплины
«Объектно
– ориентированное программирование»
По специальности
230105 «Программное обеспечение вычислительной техники и
автоматизированных систем»
2007
2
Одобрена предметной комиссией
«специальных дисциплин спец 230105»
Председатель предметной комиссии
____________________ Старкова А.Ю.
Соответствует
государственным
требованиям к минимуму содержания и
уровню
подготовки
выпускников
специальности
230105
среднего
профессионального образования
Составитель: преподаватель Старкова А.Ю
Рецензенты:
Преподаватели:
спец. дисциплин Бойко.В. И
спец. спец. дисциплин Яковенко Е. П.
Зам директора по У.Р.
_______Тараненко Л. А..
3
Содержание
Содержание
3
Введение
4
Практическое занятие 1:
«Создание класса целочисленной матрицы. Наследование»
6
Практическое занятие 2:
«Создание класса по сортировке вставками»
10
Практическое занятие 3:
«Алгоритмы сортировок с использованием классов»
14
Практическое занятие 4:
«Алгоритмы поиска данных в массиве с использованием классов»
20
Литература
25
4
Введение.
В данном методическом пособии представлена часть практических работ по дисциплине
«Объектно-ориентированное
программирование»
для
специальности
230105
«Программное обеспечение вычислительной техники и автоматизированных систем».
Цели и задачи предлагаемого пособия:
 изучение объектно-ориентированного языка программирования Visual С++;
 приобретение практических навыков программирования задач и отладки программ
на языке Visual С++.
Рассматриваемый курс содержит: 4 занятия; список литературы.
Каждое занятие состоит из следующих структурных частей:

изучение теоретического материала;

работа с контрольными вопросами;

выполнение заданий.
Работа с теоретическим материалом предполагает получение основополагающих знаний
по языку С++, рассмотрение приведенных текстов программ и комментариев к ним.
Работая с контрольными вопросами, учащиеся закрепляют теоретический материал.
Задания для самостоятельной работы служат для получения практических навыков в
разработке программ.
Предполагается выполнение следующих действий:
 самостоятельная выработка идей реализации задания;
 создание исполняемого файла, получение и объяснение результатов.
Перечень заданий может дополняться или изменяться преподавателем по усмотрению.
Контроль хода выполнения заданий осуществляется путем собеседования.
После выполнения практических работ студент должен
Знать



Назначение разделов класса;
Три основных понятия объектно – ориентированного программирования.
Назначение конструктора и деструктора класса
Уметь:


Создавать объекты на основе классов;
Использовать наследование при построении иерархии классов
5


Выполнять декомпозицию предметной области
Осуществлять вызов методов класса.
Правила выполнения практических работ
Студент должен


Выполнять домашнюю подготовку к очередному практическому занятию.
Представить преподавателю письменный отчет по предыдущему практическому
занятию, ответить на дополнительные вопросы преподавателя.
Критерии оценки




Оценка отлично ставится за полностью выполненное задание, подготовленный
отчет, правильно отвеченные вопросы преподавателя.
Оценка хорошо ставится за полностью выполненное задание с некоторыми
неточностями, подготовленный отчет, правильно отвеченные вопросы
преподавателя.
Оценка удовлетворительно ставится за выполненное задание с некоторыми
ошибками, которые студент не может исправить при помощи наводящих вопросов,
подготовленный отчет.
Оценка неудовлетворительно ставится за не полностью выполненное задание,
наличие ошибок, которые студент не может исправить, отсутствие отчета,
неудовлетворительные ответы.
6
Практическая работа №1
«Создание класса целочисленной матрицы. Наследование»
Цель работы: приобретение навыков
в создании классов с заданными свойствами
и методами на примере целочисленной матрицы.



Задание.
Предварительно изучить методические рекомендации по проведению
конкретного практического занятия
Подготовить отчет по работе.
Ответить на контрольные вопросы
Работа в лаборатории.
Когда происходит объявление класса, в С++ никакое действие не производится, и
следовательно не выделяется память. В тоже время объявление объекта есть некоторое
действие, при котором выделяется объём памяти и вызывается конструктор. Конструктор
– это метод, который инициализирует объект. Деструктор уничтожает созданный объект.
Некоторые свойства конструктора и деструктора:
 Конструктор может иметь аргументы;
 Конструктор может быть перегружен как и обычная функция;
 Деструктор не может иметь аргументов и быть перегружен.
Если у класса есть конструктор, то он вызывается всегда, когда создаётся объект класса.
Если у класса есть деструктор, то он вызывается всегда, когда объект уничтожается.
Задание 1. создать класс, осуществляющий ввод данных в матрице, печать матрицы,
поиск наибольшего и наименьшего элемента.
Листинг 1. Создание базового класса матрицы
# include <stdlib.h>
# include <stdlio.h>
# include <iostrim.h>
class matrix_base {
private:
int * mas; // указатель на начало массива
int ikol;
// кол строк
int jkol;
// кол столбцов
public:
matrix_base (int I, int J ); // конструктор класса
~matrix_base() ;
// деструктор класса
void print_matrix ();
// печать матрицы
void load_matrix ();
// загрузка матрицы значениями
};
// конструктор класса
matrix_base :: matrix_base (int I, int J )
{
mas = new int [I * J];
7
ikol = I;
jkol = J;
load_matrix ();
}
// деструктор класса
matrix_base::~matrix_base ()
{
delete mas ;
}
// метод загрузки матрицы значениями
void matrix_base :: load_matrix ()
{
int I, J;
for ( I =0; I< ikol; I ++ )
{
for ( J =0; J< jkol; J ++ )
*(mas + (jkol* I +J ) )= rand()%100;
}
}
// метод печати матрицы
void matrix_base :: print_matrix ()
{
int I, J;
for ( I =0; I< ikol; I ++ )
{
for ( J =0; J< jkol; J ++ )
cout << *(mas + (jkol* I +J ) )<< “ “;
cout << “\n” ;
}
}
//
int main(int argc, char* argv[])
{
int NI, NJ;
cout << "Введите кол строк" ;
cin >> NI;
cout << "Введите кол столбцов" ;
cin >> NJ;
matrix_base mat (NI, NJ ); // создание объекта
mat. print_matrix ();// печать матрицы
getchar():
return 0;
}
Наследование означает такое соотношение между классами, когда один класс использует
структурную или функциональную часть одного или нескольких других классов (
соответственно простое и множественное наследование).
Данный механизм действует по принципу создания иерархии классов:
8
Base class ( базовый класс)  derived class ( производный)
Задание 2. Используя наследование классов, создать класс на основе базового класса
matrix_base, который определяет минимальный и максимальный элемент в матрице.
class min_max_matr : public matrix_base{
public:
int min();
int max();
min_max_matr ( int ni, int nj ) : matrix_base(ni, nj){}
} ;
//---------------метод определения минимального числа
int min_max_matr::min()
{
int min;
int I, J;
for ( I =0, min = *mas; I< ikol; I ++ )
{
for ( J =0; J< jkol; J ++ )
if ( *(mas + (jkol* I +J ) )< min )
min= *(mas + (jkol* I +J ));
}
return (min);
}
//---------------метод определения максимального числа
int min_max_matr::max()
{
int max;
int I, J;
for ( I =0, max = *mas; I< ikol; I ++ )
{
for ( J =0; J< jkol; J ++ )
if ( *(mas + (jkol* I +J ) )>max )
max= *(mas + (jkol* I +J ));
}
return (max);
}
//--------------- главная функция main
int main(int argc, char* argv[])
{
int NI, NJ;
int min_el, max_el;
cout << "Введите кол строк" ;
cin >> NI;
cout << "Введите кол столбцов" ;
cin >> NJ;
9
min_max_matr mat (NI, NJ ); // создание объекта
mat.print_matrix ();// печать матрицы
min_el = mat.min();
cout << "\n";
cout << "min ="<< min_el<<"\n";
max_el = mat.max();
cout << "max ="<< max_el<<"\n";
getchar();
getchar();
return 0;
}
Класс min_max_matr наследует все свойства (поля) и методы базового класса. При вызове
конструктора производного класса вызывается конструктор базового класса.
Контрольные вопросы
1. Перечислите свойства конструктора и деструктора.
2. Когда вызывается конструктор класса?
3. Когда вызывается деструктор класса?
4. Укажите выражение с помощью которого происходит обращение к элементу
массива ?
5. Какое значение присваивается min в начале цикла?
Контрольные задания.
1. С помощью наследования создайте класс матрицы, который позволяет:
Определить среднее арифметическое нечётных элементов.
Произведение элементов кратных 5.
2. Создать класс матрица, содержащий методы:
Преобразует матрицу к единичной
Найти сумму элементов выше главной диагонали
3. С помощью наследования создайте класс матрицы, который позволяет
Найти минимальный и максимальный элемент в каждом столбце
Минимальный элемент расположить в первой строке, а максимальный
элемент в последней строке.
10
Практическая работа № 2
«Создание класса по сортировке вставками»
Цель работы: приобретение навыков
в создании классов с заданными свойствами
и методами на примере алгоритма сортировки вставками.



Задание.
Предварительно изучить методические рекомендации по проведению
конкретного практического занятия
Подготовить отчет по работе.
Ответить на контрольные вопросы
Работа в лаборатории.
Класс – это определяемый пользователем тип. В отличие от структуры, класс может
объединять в себе разнородные по типам переменные и функции. Рассмотрим объявление
класса.
class Name {
private:
int a, b[10];
float c, d;
int F();
public:
char s
void Sort(int);
} object;
Объявление класса состоит из нескольких частей:
 Class – зарезервированное слово;
 Name – имя класса;
 Private – метка, за котрой следует группа закрытых элементов. Элемент называется
закрытым, если он может использоваться только другими элементами класса;
 Public – метка, за которой следует группа открытых элементов. Элемент
называется открытым, если к нему разрешён доступ из программ при помощи
объектов соответствующего типа.
В объявлении класса указаны прототипы входящих в него функций-элементов. После
объявления их следует описать. Правило описания следующее:
Void Name:: Sort( int)
{
// тело функции
}
Здесь Name – это имя класса, void тип функции, Sort - имя фунции.
Принадлежность функции к классу определяет его имя и нотация ::
Рассмотрим использование класса на примере программы, которая сортирует массив
методом вставок и выводит его на экран.
11
# include < iostrim.h>
# include < conio.h>
class Task // объявление класса
{
// закрытые переменные
private: void swap ( int, int ); // функция обмена значениями двух элементов массива
int array[100];
// открытые переменные
public: void input();
// функция ввода данных
void output ();
// функция вывода результатов
void sort ( );
// функция сортировки массива
}; // завершение объявления класса
int N;
//--------------- функция ввода данных ---------------// Описание функции
void Task :: input()
{
int i;
for ( i=0; i< 100; i++)
cin >> array[i];
}
//--------------- функция сортировки массива ------------// Описание функции
void Task :: sort()
{
int start, i, min_pos, min;
int size=100;
start = 0;
// Начальная левая граница подмассива
// Запускает цикл повторений, который выполняет операции, пока все подмассивы не
пройдены
while ( start != size – 1)
{
// Предположим, что элемент с индексом левой границы подмассива минимален
min = array [start];
min_pos = start;
// Запоминает индекс элемента с минимальным значением
// Запускаем цикл потска мин элемента в подмассиве.
for ( i= start; i< size; i++)
if ( array[i] < min )
{
min = aray[i];
min_pos = i;
}
// Если позиция минимального элемента массива не совпадает с предложенной ранее,
// то меняет местами элементы с данными позициями
12
if ( min_pos!= start ) // Запускает функцию, которая меняет местами
// два элемента массива
start++;
// Уменьшает границу подмассива
}
}
//-------- функция обмена значениями двух элементов массива -----------// Описание функции
void Task :: swap ( int i, int j)
{
int temp;
temp = array[i];
array[i] = array [ j ];
array [ j ] = temp;
}
//--------------- функция вывода результатов ------------------------------// Описание функции
void Task :: output ()
{
int i;
for ( i=0; i< 100; i++)
cout << array[i]<<” “; //
getch();
}
//--------------- функция main ------------------------------main( )
{
Task object; // Объявляет объект типа Task
object.input( ); // Ввод элементов массива
object.sort(); // Сортировка массива
object.output( ); //Вывод отсортированного массива
}
Функция swap () организовывает обмен значениями между двумя элементами массива. В
функцию передаются два целых числа – номера 2- х элементов массива, значения которых
необходимо поменять местами. Функция swap () является закрытым элементомфункцией, т.к. она вызывается не из основной программы, а из другого элемента класса –
функции sort ( ).
13
Контрольные вопросы
6. Дайте определение Класса. Из каких структурных разделов он состоит .
7. Что обозначает в структуре класса ключевое слово Private
8. Что обозначает в структуре класса ключевое слово Public
9. Что выполняет метод output( ) ?
10. Что выполняет фрагмент кода:
for ( i=0; i< 100; i++)
cin >> array[i];
Контрольные задания.
4. Добавьте в структуру класса метод, который все чётные элементы на нечётных
позициях заменяет на 1.
5. Измените метод сортировки так, чтобы сортировались только нечётные элементы (
sort_not() )
6. Измените метод сортировки так, чтобы четные элементы сортировались по
убыванию
14
Практическая работа № 3
«Алгоритмы сортировок с использованием классов»
Цель работы: сортировка массива, состоящего из n элементов, расположенных в
порядке возрастания с использованием известных алгоритмов.



Задание.
Предварительно изучить методические рекомендации по проведению
конкретного практического занятия
Подготовить отчет по работе.
Ответить на контрольные вопросы
Работа в лаборатории.
Задание 1: Пузырьковая сортировка.
Этот метод хорошо работает на простых структурах данных или если данные, которые
нужно отсортировать, уже в некоторой степени отсортированы. В алгоритме пузырьковой
сортировки выполняются последовательные перемещения через сортируемые записи. Во
время каждого перемещения алгоритм сравнивает элементы массива и меняет эти
элементы местами, если они расположены не в желаемом порядке. Такие перемещения
выполняются только между соседними элементами. В результате только один элемент
помещается на своё правильное место после каждого перемещения. Отсортированные
элементы не нуждаются в сравнении в последующих перемещениях.
Листинг 1. Реализация пузырьковой сортировки с помощью класса.
#include "stdafx.h"
# include “: stdlib.h”
# include < iostream.h>
class sort {
private:
int *x;
int n;
public:
sort ( int size ) { x = new int [ size]; n=size; } // конструктор класса
~ sort ( ) { delete []x; }
// деструктор класса
void load_list ( );
// заполнение массива генератором сл чисел
void show_list ();
// печать массива
void buble_sort ( );
// метод сортировки
};
// заполнение массива генератором сл чисел
void sort :: load_list ( )
{
for ( int I=0; I < n; I++)
x[I] = rand()%100-30;
}
15
//метод выполняет печать массива
void sort :: show_list ()
{
cout << “ARRAY: “;
for ( int I=0; I < n; I++)
cout << “ “ << x[I];
cout << “ \n”;
}
// метод сортировки
void sort :: buble_sort ( )
{
int s=1;
load_list ( );
show_list ();
// цикл for выполняется один раз для каждого элемента массива
// в конце каждой итерации один элемент «всплывает» на своё правильное
// положение и не учитывается в последующих итерациях
for ( int I=0; I < n && s = =1; I++)
{
// если в конце тела цикла ненужно выполнять никаких перестановок,
// то это означает, что список уже отсортирован и цикл можно завершить.
s = 0;
for ( int j=0; j < n – (I+1); j ++ )
// если x[ j ] > x[ j +1], то элемент находится в неправильном порядке
// следовательно их можно поменять местами
if (x[ j ] > x[ j +1])
{
int t;
t = x[ j ];
x[ j ] = x[ j +1];
x[ j +1] = t ;
s = 1;
}
}
show_list ();
}
void main ( )
{
// создание нового объекта отсортированного массива
sort sort_object( 5);
sort_object. buble_sort ( );
}
16
Задание 2: Сортировка выбором.
Для массива из n элементов при сортировке выбором всегда выполняется (n - 1)
итерация. Ниже показан псевдокод для алгоритма сортировки выбором.:
Для j от 0 до (n - 1) выполнить следующие шаги:
 Для элементов от X[j+1] до X[n-1] выполнить сравнение по ключам и
найти наименьший элемент, назовём его X[lower]
 Поменять местами X[lower]и X[j]. X[lower] теперь находится в своей
отсортированной позиции.
Листинг 2. Реализация сортировки выбором с помощью класса.
#include "stdafx.h"
# include “ stdlib.h”
# include “ iostream.h”
class sort {
private:
int *x;
int n;
public:
sort ( int size ) { x = new int [ size]; n=size; } // конструктор класса
~ sort ( ) { delete []x; }
// деструктор класса
void load_list ( );
// заполнение массива генератором сл чисел
void show_list ();
// печать массива
void selection_sort ( );
// метод сортировки
};
// заполнение массива генератором сл чисел
void sort :: load_list ( )
{
for ( int I=0; I < n; I++)
x[I] = rand()%100-20;
}
//метод выполняет печать массива
void sort :: show_list ()
{
cout << “ARRAY: “
for ( int I=0; I < n; I++)
cout << “ “ << x[I];
cout << “ \n”;
}
// метод сортировки
void sort :: selection _sort ( )
{
int t;
load_list ( );
show_list ();
// Используя цикл
for находим наименьший элемент в массиве
17
// и перемещаем его в правильное положение
for ( int j=0; j < n-1; j++)
{
// На каждой итерации начинаем с элемента, имеющего индекс j
// определяя его как наименьший элемент
int lower = j;
for ( int k = j+1; k < n; k++)
if (x[ k] < x[ lower] )
lower = k;
// Когда найден элемент, который ещё меньше, чем наименьший известный
// до сих пор элемент, переставляем их местами
t = x [j];
x [j] = x[ lower] ;
x [ lower] =t;
}
show_list ();
}
void main ( )
{
// создание нового объекта отсортированного массива
sort sort_sel( 10);
sort_ sel. selection _sort ( );
}
Задание 3: Сортировка по методу Шелла.
Сортировка по методу Шелла является разновидностью сортировки вставками.
Сортировка вставками обладает ограничениями, потому что позволяет сравнивать только
смежные элементы, в результате при каждой перестановке элемент перемещается только
на одну позицию. Элементы, далеко удалённые от своих правильных позиций, требуют
многих проходов для попадания на свои правильные позиции. Эта сортировка допускает
«скачки» в порядке её выполнения. Для этого записи делятся на чередующиеся группы, и
каждая группа сортируется с использованием метода сортировки вставками. Это
разделение выполняется с использованием значения приращения ( назовем его h);
значение приращения делит первоначальный массив на h подмассивов. Затем эти
подмассивы сортируются с использованием метода сортировки вставками или
пузырьковой сортировки. Этот шаг называется h – сортировкой. Процесс h – сортировкой
повторяется с использованием уменьшающегося значения h, пока это значение не
окажется равным 1.
Выбор правильной последовательности значений для h очень важен. В рассмотренном
примере используется следующая стратегия:
1. Пусть h = 1 и n количество элементов.
2. Пусть hs+1 = 3* hs + 1. остановиться, когда h > n/2
Листинг 3. Реализация сортировки по методу Шелла
#include "stdafx.h"
# include “ stdlib.h”
# include “ iostream.h”
18
class sort {
private:
int *x;
int n;
public:
sort ( int size ) { x = new int [ size]; n=size; } // конструктор класса
~ sort ( ) { delete []x; }
// деструктор класса
void load_list ( );
// заполнение массива генератором сл чисел
void show_list ();
// печать массива
void hsell _sort ( );
// метод сортировки
};
// заполнение массива генератором сл чисел
void sort :: load_list ( )
{
for ( int I=0; I < n; I++)
x[I] = srand()%100;
}
//метод выполняет печать массива
void sort :: show_list ()
{
cout << “ARRAY: “;
for ( int I=0; I < n; I++)
cout << “ “ << x[I];
cout << “ \n”;
}
// метод сортировки
void sort :: hsell _sort ( )
{
int t, I,h;
load_list ( );
show_list ();
for ( h =1; h<= n/9; h = 3*h + 1) // вычисление необходимого h для количества n
;
// использование уменьшающихся значений для h
for ( ; h > 0; h / =3)
{
for ( I = h; I < n; I++)
{
int j;
t = x [I ] ;
for ( j = I – h; j >= 0; j= j - h )
if ( t < x[ j])
x[ j+h ] = x[ j];
else
break;
19
x[ j+h ] = t;
}
}
show_list ();
}
// Тест сортировки
void main ( )
{
// создание нового объекта отсортированного массива
sort sort_hsell( 20);
// вызов метода сортировки
sort_ shelll.hsell _sort ( );
}
Контрольные вопросы.
1. Опешите алгоритм «пузырьковой сортировки». При каких условиях он
эффективен.
2. Перечислите последовательность операций в псевдокоде сортировки выбором.
3. Для чего используется метод load_list в классах сортировки.
4. В чём состоит особенность сортировки Шелла.
5. По какой формуле вычисляется приращение h в сортировке Шелла
Контрольные задания.
1. Измените класс «пузырьковая сортировка», так чтобы элементы упорядочивались
по убыванию.
2. В сортировке выбором измените метод загрузки массива, так чтобы не допустить
наличие отрицательного элемента в массиве.
3. Создайте класс, который запускает «пузырьковую сортировку», если массив
частично отсортирован ( 32, 45, 55, 67, 60, 58) и сортировку вставками в противном
случае.
20
Практическая работа № 4
«Алгоритмы поиска данных в массиве с использованием
классов»
Цель работы : рассмотреть создание класса для поиска элемента в массиве,
состоящего из n элементов.



Задание.
Предварительно изучить методические рекомендации по проведению
конкретного практического занятия
Подготовить отчет по работе.
Ответить на контрольные вопросы
Работа в лаборатории.
Поиск – это процесс нахождения данных среди набора элементов, который удовлетворяет
определённому критерию. При сравнении методов поиска необходимо учесть критерии:
 Время подготовки;
 Время поиска;
 Необходимость возврата. Одни алгоритмы поиска выполняют простой линейный
просмотр элементов, другие переходят вперёд и назад по набору данных.
Задание 1.Линейный поиск.
Линейный поиск – это самый простой тип поиска, потому что при его выполнении просто
просматривается множество элементов данных и эти элементы сравниваются с искомыми
данными, пока не обнаружится совпадение. Алгоритм прост в реализации, но не всегда
эффективен. Необходимо использовать следующий псевдокод:
 Пусть I = 0
 Сравнить X[I] с s. Если они совпадают, возвратить I, иначе увеличить I на 1.
 Повторить шаг 2 и просмотреть массив, пока не обнаружится совпадение или пока
не будет просмотрен весь массив.
Листинг 1. реализация метода линейного поиска.
# include < stdio.h>
# include < stdlib.h>
# include < iostrim.h>
# include < time.h>
class Search {
private:
int *x; // указатель на начало массива
int n; // Количество элементов
public:
Search ( int size ) { x = new int [ size]; } // конструктор класса
~ Search ( ) { delete []x; }
// деструктор класса
void load_list ( );
// заполнение массива генератором сл чисел
void show_list();
// печать массива
int linear_list ( int s);
// поиск элемента
21
};
// заполнение массива генератором сл чисел
void Search :: load_list ( )
{
for ( int I=0; I < n; I++)
x[I] = srand()%100;
}
//метод выполняет печать массива
void Search :: show_list ()
{
cout << “ARRAY: “
for ( int I=0; I < n; I++)
cout << “ “ << x[I];
cout << “ \n”;
}
//метод выполняет поиск в массиве
int Search :: linear_list ( int s)
{
for ( int j = 0; j < N; j++)
if ( x[ j ]= = s)
return ( j);
return ( -1);
}
void main ( )
{
int key, result;
Search search_object(10);
search_object. load_list ( ); // заполнение массива
search_object. show_list(); // печать массива
cout << “Введите число для поиска “
cin >> key;
result = search_object. linear_list (key); // метод поиска
if (result!= -1 )
cout << “\n” << “ Search result: “ << “ x[“ << result<<”]= ” << key;
else
cout << “\n” << “ Search result: “
}
Задание 2. Двоичный поиск в отсортированном массиве.
Линейный поиск приемлем для массивов небольших размеров. Ели массив, в котором
нужно найти данные, уже отсортирован, то можно увеличить производительность ,
использую алгоритм двоичного поиска. Псевдокод двоичного поиска:
22
 Разбить массив на две половины в точке mid.
 Сравнить ключ поиска с X [mid ]
 Если они совпадают, то поиск завершён.
 Если key > X [mid ], то key находится в правой половине
 Значит, повторить предыдущие шаги для правой половины массива
 Иначе
key находится в левой половине массива
и следует повторить
предыдущие шаги для левой половины.
Листинг 2. реализация метода двоичного поиска.
# include < stdio.h>
# include < stdlib.h>
# include < iostrim.h>
# include < time.h>
class Search {
private:
int *x; // указатель на начало массива
int n; // Количество элементов
public:
Search ( int size ) { x = new int [ size]; } // конструктор класса
~ Search ( ) { delete []x; }
// деструктор класса
void load_list ( );
// заполнение массива генератором сл чисел
void show_list();
// печать массива
int binary_list ( int s);
// поиск элемента
};
// заполнение массива генератором сл чисел
void Search :: load_list ( )
{
for ( int I=0; I < n; I++)
x[I] = srand()%100;
}
//метод выполняет печать массива
void Search :: show_list ()
{
cout << “ARRAY: “
for ( int I=0; I < n; I++)
cout << “ “ << x[I];
cout << “ \n”;
}
//метод выполняет поиск в массиве
int Search :: binary _list ( int s)
{
int head, tail, mid;
int bmid; // элемент перед средним элементом
23
int amid; // элемент после среднего элемента
head = 0;
tail = N
if ( s< x[0] || s> x [N-1] ) // Искомый элемент вне границ диапазона
// поиск не продолжать
return(-1);
while ( head < tail)
{
mid = ( ( head + tail) / 2) + 1;
bmid = mid – 1;
amid = mid + 1;
if ( s = = x[mid] || s = = x[bmid] || s = = x[amid] ) // Сравнение со средним элем,
предыдущим и последующим
{
if( s = = x[mid]) return (x[mid]);
if( s = = x[bmid]) return (x[bmid]);
if( s = = x[amid]) return (x[amid]);
}
else
if( s > x[mid]) // в правой половине массива
head = mid + 1;
else // Искомый элемент, если существует, то в левой половине
tail = mid - 1;
}
return ( -1);
}
void main ( )
{
int key, result;
Search search_object(10);
search_object. load_list ( ); // заполнение массива
search_object. show_list(); // печать массива
cout << “Введите число для поиска “
cin >> key;
result = search_object. binary_list (key); // метод поиска
if (result!= -1 )
cout << “\n” << “ Search result: “ << “ x[“ << result<<”]= ” << key;
else
cout << “\n” << “ Search result: “
}
24
Контрольные вопросы.
1.
Опишите псевдокод линейного поиска.
2.
В каких случаях можно применить алгоритм двоичного поиска?
3.
Опишите псевдокод двоичного поиска.
4.
Каково назначение переменной mid в алгоритме двоичного поиска?
Контрольные задания.
1.Измените метод линейного поиска так, чтобы он возвращал сколько раз в массиве
встречается искомый элемент.
2.На основе созданного в 1-й задаче метода, создайте функцию которая выводит на печать
элементы, повторяющиеся в массиве.
3.На основе созданного в 1-й задаче метода, создайте функцию которая суммирует
элементы, не повторяющиеся в массиве
25
Литература.
1. Архангельский А.Я.Программирование в среде C++ Builder. Издательство
“Бином”, 2000
2. Гради Буч. Объектно-ориентированный анализ и проектирование.-М.: ЗАО
“Издательство БИНОМ”, 1999.
3. Джеймс Рамбо, Айвар Джекобсон. UML- руководство пользователя. –СПб.:
Издательство “ДМК”, 1999
4. Петер Коунд . Объектные модели. Стратегии , шаблоны, приложения.
:Издательство “Лори”, 1999.
5. Галяров И.Р. Borland C++ 5 для себя. -Издательство “ДМК”, 2001