Сортировка данных

Размещено на http://www.allbest.ru/

Содержание

Введение

1 Задание

2 АНАЛИТИЧЕСКАЯ ЧАСТЬ

3 ПРАКТИЧЕСКАЯ ЧАСТЬ

Заключение

Список литературы

ВВЕДЕНИЕ

С++ был развит из языка программирования C и за очень немногими исключениями сохраняет C как подмножество. Одним из первоначальных предназначений C было применение его вместо программирования на ассемблере в самых насущных задачах системного программирования. Когда проектировался С++, были приняты меры, чтобы не ставить под угрозу успехи в этой области.

Чтобы облегчить работу программиста практически все современные компиляторы языка C++ содержат специальные библиотеки классов. Такие библиотеки включают в себя практически весь программный интерфейс Windows и позволяют пользоваться при программировании средствами более высокого уровня, чем обычные вызовы функций. За счет этого значительно упрощается разработка приложений, имеющих сложный интерфейс пользователя, облегчается поддержка технологии OLE и взаимодействие с базами данных.

Целью курсового проекта является освоение принципов организации и функционирования системного программного обеспечения, особенностей разработки системного программного обеспечения, получение практических навыков программирования на языке Microsoft Visual С++.

В связи с тем, что уровень сложности программного обеспечения очень высок, разработка приложений Windows с использованием только какого-либо языка программирования значительно затрудняется. Программист тратит массу времени на решение стандартных задач по созданию многооконного интерфейса.

1 задание

1.1 Аналитическое задание

Таблица 1 - Аналитическое задание

№ варианта	Тема задания
5	Методы сортировки: сортировка вставками, выбором, разделением, слиянием

1.2 Практическое задание

1.2.1 Разработать библиотеку функций

Таблица 2 - Варианты к практическому заданию №1

№ варианта	Тема задания
7	Реализовать библиотеку для работы с матрицами, которая включает следующие функции: определение детерминанта матрицы; вычисление обратной матрицы; транспонирование матрицы.

данные сортировка матрица

1.2.2 Разработать класс, объект которого реализует «пользовательский» тип данных. Разработать необходимые конструкторы, деструктор, а также методы, обеспечивающие изменение отдельных составных частей объекта и вывод его содержимого.

Таблица 3 - Варианты к практическому заданию №2

№ варианта	Класс
1	Геометрические фигуры

2 АНАЛИТИЧЕСКАЯ ЧАСТЬ

Сортировка - это вещь, которую студент обязательно должен знать, если он хочет окончить университет успешно. Поэтому важно уже сейчас, если вы ещё не студент, узнать что-либо о ней (хотя, вообще-то, всё это не так уж и необходимо в наши дни, когда в С есть встроенная функция qsort()). Эта статья может быть использована как руководство для начинающих, так и в качестве справочника.

Алгоритмы деления и вставки: сортировка вставками

В этом типе алгоритмов массив разделяется на две части: уже отсортированную и ещё не отсортированную.

Сначала отсортированная часть состоит всего из одного элемента, первого. Она расширяется вправо на каждой итерации цикла.

В каждой итерации первый элемент не отсортированной части сравнивается с элементами в отсортированной части слева направо. Если первый элемент не отсортированной части меньше или равен текущему элементу в отсортированной части, все элементы слева от первого элемента в не отсортированной части и справа от текущей позиции в отсортированной части смещаются вправо, и тот найденный элемент вставляется на освободившееся от передвижения место.

Сортировка окончена в том случае, если размер отсортированного массива равен размеру всего массива.

Пример (отсортированная часть выделена жирным шрифтом):

Не отсортированная последовательность 8 4 1 5 4

Шаг 1 8 4 1 5 4

Шаг 2 4 8 1 5 4

Шаг 3 1 4 8 5 4

Шаг 4 1 4 5 8 4

Результат 1 4 4 5 8

Подобно сортировке выбором, сортировка вставками итеративна. Перемещение элементов может быть осуществлено с помощью обмена:

void insertionsort_slow(int *array, int n)

{

int source, i, j;

for(source=1; source<n; source++)

{

for(i=0; (i<source) && (array[i]<array[source]); i++) {}

if(array[source]<array[i])

{

for(j=source; j>i; j--)

{

swap(&array[j], &array[j-1]);

}

}

}

}

Оптимизация сортировки вставками: Текущий вариант не оптимален и его можно улучшить. Можно, например, сравнивать элементы обеих частей не в возрастающей последовательности, а в убывающей. То есть вместо сравнения элементов a[source] с a[0], потом с а[1] и т. д. (source - индекс первого элемента в неупорядоченной части) сравнивать a[source] с a[source-1], потом с a[source-2] и т. д. Преимущество этого: если a[source] больше или равен a[source-1], то выполнение итерации может быть остановлено и a[source] начинает считаться входящим в отсортированную часть. Однако, если a[source] меньше чем a[source-1], мы должны обменять элементы, а потом сравнивать a[source-1] c a[source-2] и т. д. Реализация:

void insertionsort(int *array, int n)

{

int source, i, j;

for(source=1; source<n; source++)

{

for(j=source; j && (array[j]<array[j-1]); j--)

{

swap(&array[j], &array[j-1]);

}

}

}

Алгоритмы деления и вставки: дихотомическая сортировка вставками

Этот оптимизированный вариант первоначальной медленной сортировки вставками. В отличие от него, мы сравниваем не первый элемент упорядоченной части с элементом неупорядоченной, а центральный элемент этой упорядоченной части. В зависимости от того, является ли этот центральный элемент меньше или больше текущего элемента в неупорядоченной части, мы сравниваем элементы либо слева, либо справа от центрального. Таким образом, общее количество сравнений может быть сокращено.

Алгоритмы деления и вставки: сортировка Шелла

Эта сортировка является оптимизацией сортировки вставками. Сначала различные части массива сортируются раздельно, используя обычную сортировку вставками, но которая имеет один дополнительный параметр - величину "шага" между сравниваемыми элементами. Потом весь массив обрабатывается обычной сортировкой вставками (шаг равен единице). Благодаря частичному упорядочению массива на прошлых шагах, она справляется со своей задачей быстрее.

Мои эксперименты с этим видом сортировки привели к заключению, что эффективность сортировки Шелла сильно зависит от следующих факторов: a) начального шага, b) от дальнейшей последовательности шагов. Вот статистика:

Длина последовательности	расстояние=n/5 делённое на 5	расстояние=n/4 делённое на 2	расстояние=n/10 делённое на 10
20 чисел	17 итераций	>20 итераций	19 итераций
50 чисел	89 итераций	>110 итераций	46 итераций

Другими словами, только один из приведённых способов улучшил работу по сравнению с обычной сортировкой вставками (где число итераций равно n), это третий вариант, с начальным шагом n/10 и делением этого шага на 10 на каждой новой итерации. Вот моя реализация этого алгоритма:

void shellsort(int *array, int n)

{

int distance, source, i, j;

for(distance=n/10; distance; distance/=10)

{

for(source=1; source<=n-distance; source++)

{

for(j=source; (j>=distance) && (array[j]<array[j-distance]); j--)

{

swap(&array[j], &array[j-distance]);

}

}

}

}

Сортировка выбором

Принцип этого типа сортировки заключается в нахождении минимального элемента в массиве (с индексами от 0 до n-1) и помещения его в начало массива. После этого массив, состоящий из первого элемента, будет отсортирован, поэтому дальше мы повторяем процедуру нахождения минимального элемента, начиная с индекса 1 и кончая индексом n-1. И так до тех пор, пока "левый" индекс не дойдёт до конца массива. После k-ого этапа первые k первых элементы будут отсортированы. В итоге мы получим полностью отсортированный массив.

Есть два очевидных пути установки найденного минимального элемента на требуемую позицию:

1. Можно двигать элементы стоящие слева от найденного вправо на одну позицию пока мы не дойдём до позиции, куда нужно было вставить этот минимальный элемент. Естественно, перед сдвигом его нужно где-то запомнить. Пример (область, в которой ищется минимальный элемент, напечатана жирным шрифтом):

Не отсортированный массив 8 4 1 5 4

Шаг 1 8 4 1 5 4

Шаг 2 1 8 4 5 4

Шаг 3 1 4 8 5 4

Шаг 4 1 4 4 8 5

Результат 1 4 4 5 8

Однако, этот вариант имеет низкое быстродействие, потому что перемещение большого объёма чисел в памяти требует много времени. В худшем случае (в данной ситуации - если массив уже упорядочен, но в обратной последовательности) потребуется n*(n-1)/2 операций перемещения (как сказали бы знающие люди: этот алгоритм имеет сложность порядка О(n^2)). Пример:

Не отсортированный массив 5 4 3 2 1

Шаг 1 5 4 3 2 1 => перемещено 4 элемента

Шаг 2 1 5 4 3 2 => перемещено 3 элемента

Шаг 3 1 2 5 4 3 => перемещено 2 элемента

Шаг 4 1 2 3 5 4 => перемещён 1 элемент

Результат 1 2 3 4 5

То есть, нужно сделать 10 перемещений.

2. Поэтому лучше просто обменять найденный минимальный элемент с первым, стоящим в ещё не отсортированной подпоследовательности. Пример:

Не отсортированный массив 8 4 1 5 4

Шаг 1 8 4 1 5 4

Шаг 2 1 4 8 5 4

Шаг 3 1 4 8 5 4

Шаг 4 1 4 4 5 8

Результат 1 4 4 5 8

Сортировка выбором - это итеративный алгоритм (хотя рекурсия тоже возможна, но это лишь пустая трата мозгов и тактов). Мы используем цикл for, в течение которого счётчик увеличивается от 0 до n-2. И в результате, после n-1 шагов массив будет отсортирован.

Вот моя реализация сортировки выбором:

void selectionsort(int *array, int n)

{

int first, i, smallest;

for(first=0; first<n-1; first++)

{

smallest=first;

for(i=first+1; i<n; i++)

{

if(array[i]<array[smallest]) smallest = i;

}

swap(&array[first], &array[smallest]);

}

}

Она использует функцию swap, определённую следующим образом:

void swap(int *a, int *b)

{

int h = *a;

*a = *b;

*b = h;

}

Сортировка с разделением

Данный метод является одним из лучших методов внутренней сортировки и весьма эффективен для больших таблиц. Целью каждого шага в данном методе является помещение очередной рассматриваемой записи на конечную позицию внутри таблицы. Если поступать таким способом, то все записи, предшествующие данной, будут иметь меньший ключ, в то время как все последующие - больший. При использовании такого метода таблица всегда делится на две подтаблицы. Анологичный процесс может быть применен к каждой из этих подтаблиц и повторяться до тех пор, пока все записи не будут установлены на их конечные позиции.

Используются два индекса i и j с начальными значениями границ таблицы. Сравниваются ключи K[i] и K[j], и если перестановка не требуется, то j уменьшается на 1, и процесс повторяется. В том случае, когда K[i]>=K[j], записи R[i] и R[j] меняются местами. Затем этот процесс повторяется с i, увеличенным на 1, и фиксированным j до тех пор, пока не возникает другая перестановка. В этот момент j снова будет уменьшено на 1, а i останется фиксированным, и т.д. Процесс выполняется до тех пор, пока i<j.

Каждый раз таблица разбивается на две подтаблицы, одна из которых обрабатывается, в то время как границы второй запоминаются с тем, чтобы она была обработана позже. В этих целях может быть использован стек, представляющий собой матрицу из двух столбцов. В первом столбце хранятся нижние границы разделяемых подтаблиц, во втором - верхние границы. Всякий раз одна из полученных в результате разделения подтаблиц подвергается дальнейшему разделению, а границы другой помещаются в свободную строку стека (обычно в стек помещаются границы большей по длине таблицы, поскольку это уменьшает требуемый размер стека). Как только завершается процесс разделения текущей подтаблицы, т.е. ее длина станет меньше трех, для разделения берется подтаблица, границы которой были занесены в стек последними. Строка стека, в которой хранились эти границы, освобождается. Процесс упорядочения завершается, когда стек полностью освобождается.

Разделение следует применять для подтаблиц, длина которых больше 9, а короткие подтаблицы упорядочивать методом вставки.

Стек занимает мало места. Например, стек из 20 строк позволяет упорядочить таблицу, содержащую до 10**7 записей. Кроме того, в современных языках программирования при работе рекурсивных программ занесение и извлечение из стека выполняется автоматически, поэтому рекомендуется использовать именно этот механизм. Среднее число сравнений для данного алгоритма составляет n*log(n) где n - число записей в сортируемой таблице, m - размер подтаблицы, сортируемой методом вставки.

Наихудшей ситуацией при использовании рассмотренного алгоритма является случай, когда таблица уже отсортирована. При этом число сравнений порядка n , т.е. алгоритм не лучше сортировки выборкой.

В качестве примера рассмотрим записи со следующими ключами:

42 23 74 11 36 58 94

Ниже приведена последовательность перестановок при перемещении записи с ключем 42 на его конечную позицию. Подчеркнуты ключи, значения которых сравнивались.

42 23 74 11 36 58 94

~~~ ~~~

42 23 74 11 36 58 94

~~~ ~~~

42 23 74 11 36 58 94

~~~ ~~~

36 23 74 11 42 58 94

~~~ ~~~

36 23 74 11 42 58 94

~~~ ~~~

36 23 42 11 74 58 94

~~~ ~~~

36 23 11 42 74 58 94

~~

В результате записи с исходными ключами разбиты на две подтаблицы, а именно, на наборы [36, 23, 11] и [74, 58, 94], к которым применяется тот же метод.

В качестве разделяющего можно выбрать X - любой элемент таблицы, например, средний (l=n/2).Сначала таблица рассматривается слева от X до тех пор, пока не обнаружится ключ K[i]>X (K[i]<=X, i:=i+1; если K[i]>X, то i фиксируется). Затем таблица просматривается справа, пока выполняется K[j]>=X (j:= j-1; если K[j]<X, то j фиксируется).Элементы таблицы с ключами K[i] и K[j] меняются местами.Процесс просмотра и обмена продолжается до тех пор, пока оба просмотра не встретятся в некоторой позиции таблицы. При этом необходимо сравнивать индексы i и j с индексом выбранного элемента X ( индекс l) с тем, чтобы процесс обмена (перестановки) записей с ключами K[i] и K[j] выполнялся правильно. В результате таблица окажется разбитой на левую часть с ключами меньше или равными X, и правую - с ключами больше X.

Для каждой из полученных частей процесс повторяется.

Сортировка слиянием

Сортировка слиянием (метод простого двухпутевого слияния)

В основе данного метода внутренней сортировки лежит процедура слияния двух упорядоченных таблиц. Эти таблицы должны быть объединены таким образом, чтобы получилась одна упорядоченная таблица.

Пусть имеются две таблицы А и В, упорядоченные по возрастанию ключей. Слияние заключается в поочередной пересылке элементов из таблиц А и В в зону формирования С. Порядок пересылки в зону формирования зависит от результата попарного сравнения ключей таблиц А и В.

Сортировка слиянием производится на основе использования рассмотренной выше процедуры. Сущность сортировки состоит в том, что упорядочиваемая таблица разделяется на равные группы элементов. Группы упорядочиваются, а затем попарно сливаются, образуя новые группы, содержащие вдвое больше элементов.

Процедура слияния двух групп должна иметь такие параметры:

TAB - имя сортируемой таблицы;

n - длина таблицы (количество записей);

i1, i2 - начальные индексы сливаемых групп;

l1, l2 - длины сливаемых групп;

h - шаг слияния;

PS - поле слияния.

TAB TAB

--------------- ---------------

¦ . . . ¦ ¦ . . . ¦

i1 +-------------+ ------- i1 +-------------+

¦ 23 ¦ l1 ¦ 17 ¦ ¦ 17 ¦

¦ 68 ¦ +-----+ ¦ 19 ¦

i2 +-------------+ ¦ 19 ¦ ¦ 23 ¦

¦ 17 ¦ +-----+ ¦ 68 ¦

¦ 19 ¦ l2 ¦ 23 ¦ ¦ ¦

+-------------+ +-----+ +-------------+

¦ ¦ ¦ 68 ¦ ¦ ¦

¦ . . . ¦ ------ ¦ . . . ¦

-------------- --------------

На первом этапе каждая группа содержит два соседних элемента исходного массива. Элементы внутри групп упорядочиваются (напр., методом вставки). Затем происходит попарное слияние групп. Количество групп в списке уменьшается вдвое до тех пор, пока не будет получена одна упорядоченная группа. Если число элементов нечетное, то вводится дополнительный элемент с максимальным значением. После сортировки он отбрасывается. Если число групп, сформированных на первом этапе, нечетно, то непарная группа переписывается без слияния. Рассмотренный метод двухпутевой сортировки слиянием весьма эффективен. Поскольку при сортировке нужно выполнить log2(n) проходов, то необходимое суммарное число сравнений равно, примерно, n*log2(n). Одним из недостатков данного метода является требование большого резерва памяти:

S = [n/2].

Сортировка слиянием (естественное слияние)

Метод простого слияния никак не учитывает тот факт, что в таблице могут быть сразу или получаться на некотором шаге упорядоченые группы записей длиной m и l, которые можно сразу объединить в одну упорядоченную группу длиной m+l (более того, эти упорядоченные последовательности могут разрываться, их элементы будут относиться к разным группам). Сортировка, при которой сливаются рядом стоящие упорядоченные группы произвольной длины, называется естественным слиянием. Цель естественного слияния-исключить лишние просмотры. Процедура слияния двух групп такая же, как и в методе простого слияния, но длины l1 и l2 сливаемых групп нужно каждый раз подсчитывать, сравнивая ключи двух рядом стоящих записей (можно составить массив длин упорядоченных групп).

3 пракТИЧЕСКАЯ ЧАСТЬ

Разработать библиотеку функций:

class Matr

{

private:

int Rows;

int Cols;

float ** FloatData;

public:

Matr(int Row=1, int Col=1); //класс Вещественной матрицы со своим конструктором, деструктором и методами.

~Matr(void);

void Trans();

void Display();

void DisplayTrans();

void Fill();

void Power(int n);

};

#include <iostream>

#include "matrix.h"

using namespace std;

// -----

Matr::Matr(int Row, int Col)

{

Rows = Row;

Cols = Col;

FloatData= new float * [Rows];

for (int j=0;j<Rows;j++){

FloatData[j] = new float[Cols]; // Методы создания матрицы.

for (int i=0;i<Cols;i++){

FloatData[j][i]=0.0;

}

}

}

Matr::~Matr()

{

for (int j=0;j<Rows;j++){

delete FloatData[j];

}

delete [] FloatData;

}

//-----

void Matr::Fill()

{

for (int j=0;j<Rows;j++){

for (int i=0;i<Cols;i++){

FloatData[j][i]=(float)(rand() % 15); // Метод заполнения матрицы случайными значениями

}

}

}

//-----

void Matr::Display()

{cout <<"Displayed Matrix"<<endl;

for (int j=0;j<Rows;j++){

for (int i=0;i<Cols;i++){

cout<<FloatData[j][i]<<" "; // Метод вывод матрицы на экран

}

cout<< endl << endl;

}

}

void Matr::DisplayTrans()

{cout <<"Transed Matrix"<<endl;

for (int i=0;i<Rows;i++){

for (int j=0;j<Cols;j++){

float tmp= FloatData[j][j];

tmp=FloatData[j][i]; //Метод транспонирования и вывода транспонированной матрицы на экран

tmp=FloatData[i][j];

cout <<FloatData[j][i]<<" ";

}

cout<<endl<<endl;

}

}

//-----

void Matr::Power(int n) {

if(Rows != Cols) return;

if(n == 0) {

for(int i = 0; i < Rows; i++){

for(int j = 0; j < Cols; j++) {

if(i != j) FloatData[i][j] = 0;

else FloatData[i][j] = 1;}

}

}

else {

for(int degree = 1; degree < n; degree++) {

Matr buffer(Rows, Cols);

for(int i = 0; i < Rows; i++) {

for(int j = 0; j < Cols; j++) {

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

buffer.FloatData[i][j] += FloatData[i][k]*FloatData[k][j];

}

}

}

for(int l = 0; l < Rows; l++) {

for(int j = 0; j < Cols; j++) {

FloatData[l][j] = buffer.FloatData[l][j];}

}

}

}

}

#include <iostream>

#include "matrix.h"

using namespace std;

int main()

{int Col, Row;

cout<<"Enter size of matrix: "<<endl;

cin>>Col;

Row=Col;

Matr m(Col, Row);

m.Fill();

m.Display();

m.DisplayTrans();

cout<<endl;

cout << " Enter the deegree: "<<endl; // вызов методов для исполнения программы

int n;

cin>>n;

m.Power(n);

m.Display();

cout<<"Press any key to exit"<<endl;

char o;

cin>>o;

}

Геометрическая фигура: конус

#include <windows.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <GL/glaux.h>

#include "stdlib.h"

double R = 1, H = 2;

void CALLBACK Key_UP(void)

{

R = R + 0.2;

H = H + 0.4;

}

void CALLBACK Key_DOWN(void)

{

R = R - 0.2;

H = H - 0.4;

}

void DrawCone()

{

glPushMatrix(); // сохраняем текущие координаты

glTranslated(0.1, 0, 0); // сдвигаемся в точку (2, 0, 0)

glRotated(-75, 0.1, 0, 0); // поворачиваем систему координат

glColor3d(0, 1, 0);

auxWireCone(R, H); // рисуем конус

glPopMatrix(); // возвращаемся к старым координатам

}

void CALLBACK resize(int width, int height)

{

glViewport(0, 0, width, height);

glMatrixMode( GL_PROJECTION );

glLoadIdentity();

glOrtho(-5, 5, -5, 5, 2, 12);

gluLookAt( 0, 0, 5, 0, 0, 0, 0, 1, 0 );

glMatrixMode( GL_MODELVIEW );

}

void CALLBACK display(void)

{

 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

 DrawCone();

 auxSwapBuffers();

}

void main()

{

float pos[4] = {3, 3, 3, 1};

float dir[3] = {-1, -1, -1};

GLfloat mat_specular[] = {1, 1, 1, 1};

auxInitPosition( 50, 10, 400, 400);

auxInitDisplayMode( AUX_RGB | AUX_DEPTH | AUX_DOUBLE );

auxInitWindow( "Glaux Template" );

auxIdleFunc(display);

auxReshapeFunc(resize);

auxKeyFunc(AUX_UP, Key_UP);

auxKeyFunc(AUX_DOWN, Key_DOWN);

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

glLightfv(GL_LIGHT0, GL_POSITION, pos);

glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, dir);

glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);

glMaterialf(GL_FRONT, GL_SHININESS, 128.0);

/*

* Enter your cod here

*/

auxMainLoop(display);

}

Куб

#include <windows.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <GL/glaux.h>

#include "stdlib.h"

double h = 2;

void CALLBACK Key_UP(void)

{

h = h + 0.4;

}

void CALLBACK Key_DOWN(void)

{

h = h - 0.4;

}

void DrawCube()

{

glPushMatrix(); // сохраняем текущие координаты

glTranslated(0.1, 0, 0); // сдвигаемся в точку (2, 0, 0)

glRotated(-75, 0.1, 0, 0); // поворачиваем систему координат

glColor3d(0, 1, 0);

auxWireCube(h); // рисуем

glPopMatrix(); // возвращаемся к старым координатам

}

void CALLBACK resize(int width, int height)

{

glViewport(0, 0, width, height);

glMatrixMode( GL_PROJECTION );

glLoadIdentity();

glOrtho(-5, 5, -5, 5, 2, 12);

gluLookAt( 0, 0, 5, 0, 0, 0, 0, 1, 0 );

glMatrixMode( GL_MODELVIEW );

}

void CALLBACK display(void)

{

 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

 DrawCube();

 auxSwapBuffers();

}

void main()

{

float pos[4] = {3, 3, 3, 1};

float dir[3] = {-1, -1, -1};

GLfloat mat_specular[] = {1, 1, 1, 1};

auxInitPosition( 50, 10, 400, 400);

auxInitDisplayMode( AUX_RGB | AUX_DEPTH | AUX_DOUBLE );

auxInitWindow( "Glaux Template" );

auxIdleFunc(display);

auxReshapeFunc(resize);

auxKeyFunc(AUX_UP, Key_UP);

auxKeyFunc(AUX_DOWN, Key_DOWN);

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

glLightfv(GL_LIGHT0, GL_POSITION, pos);

glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, dir);

glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);

glMaterialf(GL_FRONT, GL_SHININESS, 128.0);

/*

* Enter your cod here

*/

auxMainLoop(display);

}

ЗАКЛЮЧЕНИЕ

В процессе выполнения курсовой работы были приобретены навыки работы с языком C++. В аналитической части был разобран материал по методам сортировки: сортировка вставками, выбором, разделением, слиянием. Были рассмотрены мощные средства языка - указатели и ссылки, которые позволяют разрабатывать гибкие и весьма эффективные программы. В практической части были приобретены навыки работы с массивами, файлами и различными процедурами и функциями. Изучен принцип работы с массивами и создания библиотек.

СПИСОК ЛИТЕРАТУРЫ

1 Официальный сайт Интернет института информационных технологий: “Intuit”;

2 Bjarne Stroustrup's FAQs узел Бьерна Страуструпа;

3 Десятки тысяч ссылок на разные темы объектно-ориентированного программирования, включая Си++.

Размещено на Allbest.ru