- •Лабораторные работы. Сборник задач.
- •Оглавление
- •Часть 1. Лаборатоные работы
- •Работа со структурами и объединениями …………………………………….91
- •3 Задача
- •4 Задача
- •5 Задача
- •6 Задача
- •Дополнительное условие:использование цикла с предусловием.
- •1 Задача
- •2 Задача
- •Дополнительное условие: программа написана без использования функции.
- •Дополнительное условие: программа написана с использованием функций.
- •3 Задача
- •Дополнительное условие: программа написана без использования функции.
- •Дополнительное условие: программа написана с использованием функции.
- •4 Задача
- •Дополнительное условие: программа написана без использования функции
- •Дополнительное условие: программа написана с использованием функции.
- •Самостоятельная работа
- •Лабораторная работа №3
- •Самостоятельная работа
- •1 Задача
- •2 Задача
- •1 Задача
- •2 Задача
- •3 Задача
- •Лабораторная работа №6
- •1 Задача
- •1 Задача
- •2 Задача
- •3 Задача
- •1 Задача
- •1 Задача
- •2 Задача
- •3 Задача
- •4 Задача
- •Синтаксический анализатор
- •Самостоятельная работа
- •1 Задача
- •2 Задача
- •3 Задача
- •Работа с каталогами
- •Самостоятельная работа
- •1 Задача
- •2 Задача
- •1 Задача
- •2 Задача
- •3 Задача
- •1 Задача
- •2 Задача
- •1 Задача Реализовать очередь, состоящую из целых чисел
- •Комментарий:
- •2 Задача
- •1 Задача
- •Идеально-сбалансированные деревья
- •1 Задача
- •2 Задача
- •1 Задача
- •2 Задача
- •3 Задача
- •1 Задача
- •2 Задача
- •3 Задача
- •1 Задача
- •1 Задача
- •1 Уровень сложности
- •2 Уровень сложности
- •3 Уровень сложности
- •1 Уровень сложности.
- •2 Уровень сложности
- •3 Уровень сложности
- •1 Уровень сложности
- •Работа с несколькими массивами
- •Преобразование массива
- •Изменение элементов массива
- •2 Уровень сложности Формирование массива и вывод его элементов
- •Анализ элементов массива
- •Преобразование массива
- •Изменение элементов массива
- •Удаление и вставка элементов
- •Серии целых чисел
- •3 Уровень сложности Множества точек на плоскости
- •1 Уровень сложности
- •2 Уровень сложности
- •3 Уровень сложности
- •1 Уровень сложности
- •2 Уровень сложности
- •3 Уровень сложности
- •1 Уровень сложности
- •2 Уровень сложности
- •3 Уровень сложности
- •Not простое_логическое
- •(Простое_логическое знак_операции простое_логическое)
- •Построить синтаксический анализатор для понятия предложение.
- •1 Уровень сложности
- •2 Уровень сложности
- •1 Уровень сложности
- •Примеры:
- •Двусвязные списки
- •1 Уровень сложности
- •2 Уровень сложности
- •3 Уровень сложности
3 Задача
Найти путь с наименьшей стоимостью из пункта A в пункт B. Стоимость проезда из пункта A в пункт B и из пункта В в пункт А отличается.
Дополнительное условие:данные о графе считываются из текстового файла и хранятся в виде матрицы. Граф задаётся как матрица смежности.
#include <stdio.h>
#include <stdlib.h>
// количество вершин
int n;
// матрица смежности графа
int**G;
// массив пометок
int*M;
// длина пути
int npath;
// начальная вершина пути
int A;
// конечная вершина пути
int B;
// массив для номеров вершин, включённых в путь из A в B
int*path;
int main()
{
// загрузка данных из файла
Input();
// поиск в ширину: ищется самый дешёвый маршрут из A в B
FindPath(A,B);
printf("Path from A to B and back to A: ");
// вывод первой части пути на экран
PrintPath();
int cost = M[B];
// поиск в ширину: ищется самый дешёвый маршрут из B в A
FindPath(B,A);
// вывод второй части пути на экран
PrintPath();
cost += M[A];
// вывод стоимости
printf("\nIt costs %d\n",cost);
// освобождение памяти после использования всех нужных массивов
FreeMem();
return 0;
}
// функция выделения памяти под одномерный массив
void initarr(int*&A)
{
A = (int*)malloc(n*sizeof(int));
}
// функция выделения памяти под двумерный массив
void init2arr(int**&A)
{
A = (int**)malloc(n*sizeof(int*));
for (int i=0; i<n; i++)
A[i] = (int*)malloc(n*sizeof(int));
}
// функция освобождения памяти после использования двумерного массива
void free2arr(int**&A)
{
for (int i=0; i<n; i++)
free(A[i]);
free(A);
}
// функция освобождения памяти после использования всех нужных массивов
void FreeMem()
{
free2arr(G);
free(M);
free(path);
}
// функция загрузки данных из файла
void Input()
{
FILE*f;
// открытие текстового файла на считывание
f = fopen("graf.txt","r");
// считывание количества вершин графа
fscanf(f,"%d",&n);
// инициализация всех нужных массивов
init2arr(G);
initarr(M);
initarr(path);
int i,j;
// считывание матрицы смежности графа
for (i=0; i<n; i++)
for (j=0; j<n; j++)
fscanf(f,"%d",&G[i][j]);
// считывание начального и конечного пунктов маршрута
fscanf(f,"%d%d",&A,&B);
// для нумерации вершин с 0, а не с 1
A--; B--;
// закрытие файла
fclose(f);
}
// поиск в ширину: ищется самый дешёвый маршрут из A в B
void FindPath(int A,int B)
{
int i,j;
// инициализация массива пометок
for(i=0;i<n;i++)
M[i] = -1;
M[A] = 0;
int b = 1;
// пока в массиве пометок происходят изменения
while (b)
{
b = 0;
for (i=0; i<n; i++)
if (M[i] >= 0)
for (j=0; j<n; j++) if (i != j)
if (G[i][j])
// (в j-ю вершину пока пути не проложено)
if ((M[j] == -1) || (M[i] + G[i][j] < M[j]))
{
// ИЛИ (попасть в j-ю вершину из i-ой дешевле, чем способом, найденным до этого)
M[j] = M[i] + G[i][j];
b = 1;
}
}
// если в вершину B так и не дошли
if (M[B] == -1)
npath= 0;
else
{
// иначе проходим от B к A и записываем найденный путь в массив path
path[0] = B;
npath = 0;
j = B;
int d;
while (j != A)
{
i = 0;
d = 1;
while (d)
{
if (i != j)
if (G[i][j])
if (M[i] != -1)
d = (M[i] != M[j] - G[i][j]);
i++;
}
j = i-1;
npath++;
path[npath] = j;
}
}
}
// функция вывода пути на экран
void PrintPath()
{
for (int i=npath; i>=0; i--)
printf("%d ",path[i]+1);
}
Самостоятельная работа.
Изменить вторую задачу таким образом, чтобы вывести все возможные пути из пункта А в пункт В, не превышающие заданной стоимости.
Лабораторная работа №25
Метод с возвращением
Цель: использование метода с возвращением, нахождение единственного решения (если оно существует).
Методические рекомендации: лабораторная работа рассчитана на 2 часа и состоит из анализа одного разобранного задания и решения самостоятельной работы.
Для работы с данным методом предусмотрено 3 лабораторные работы и одно обязательное зачетное задание.
Необходимый уровень знаний:
работа с указателями;
работа с матрицами;
алгоритм поиска с возвращением.
Задача
Дана доска размером n x n. Вначале на поле с координатами x0, y0 помещается конь - фигура, которая перемещается по шахматным правилам. Задача заключается в поиске хотя бы одной последовательности ходов (если она существует), при которой конь точно один раз побывает на всех полях доски.
#include <stdio.h>
#include <stdlib.h>
// задание количества возможных ходов конем из данной клетки на бесконечном поле
intNSTEP= 8;
// задание массив для пометок: M[i][j] = номер хода, на котором конь попадет в клетку (i,j)
int**M;
// задание начального положения коня
int x0,y0;
// задание размера поля
intn;
// nn = n*n
int nn;
// = 1, если искомая матрица еще не найдена
intinprocess;
// ввод данных с экрана
void Input()
{
printf("n = ");
scanf("%d",&n);
nn = n*n;
printf("x0 = ");
scanf("%d",&x0);
printf("y0 = ");
scanf("%d",&y0);
// пользователь нумерует клетки шахматной доски начиная с единицы, компьютер // будет нумеровать с нуля
x0--;y0--;
}
// вывод результата на экран
void Output()
{
int i,j;
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
printf("%5d",M[i][j]);
printf("\n");
}
}
// выделение памяти под двумерный массив M
void InitMem()
{
M = (int**)malloc(n*sizeof(int*));
for (int i=0; i<n; i++)
M[i] = (int*)malloc(n*sizeof(int));
}
// освобождение памяти
voidFreeMem()
{
for (int i=0; i<n; i++)
free(M[i]);
free(M);
}
// присваивание каждому элементу массива M0
void InitM()
{
int i,j;
for (i=0; i<n; i++)
for (j=0; j<n; j++)
M[i][j] = 0;
}
// проверка, находится ли клетка (x,y) на полеnxn
int InRange(int x,int y)
{
return (x >= 0) && (x < n) && (y >= 0) && (y < n);
}
// ход коня из клетки (X,Y) в клетку (x,y)
void Move(int X,int Y,int&x,int&y,int k)
{
x = X;
y = Y;
// нумерация (k) - против часовой стрелки, от осиx
switch(k)
{
ход конем на две клетки вправо и на одну вверх
case 0: {x += 2; y -= 1; break;}
case 1: {x += 1; y -= 2; break;}
case 2: {x -= 1; y -= 2; break;}
case 3: {x -= 2; y -= 1; break;}
case 4: {x -= 2; y += 1; break;}
case 5: {x -= 1; y += 2; break;}
case 6: {x += 1; y += 2; break;}
case 7: {x += 2; y += 1; break;}
}
}
// перебор всех возможных вариантов очередного хода
void Step(int X,int Y,int h)
{
// если номер шага меньше n*n, то следует продолжать ходы
if (h <= nn)
{
int k;
int x,y;
// перебор всех возможных ходов конем из клетки (X,Y)
for (k=0; (k<NSTEP) && (inprocess); k++)
{
Move(X,Y,x,y,k);
// проверка, что после хода конь не оказался за пределами доски
if (InRange(x,y))
// проверка, что на данной позиции конь еще не побывал
if (!M[x][y])
{
// сохранение в матрицу Mномера хода
M[x][y] = h;
// рекурсивный вызов функцииStep(), совершение следующего хода
Step(x,y,h+1);
// если решение не найдено, стираем пометку с поля (x,y) (т.е. данный
// ход оказался ошибочным)
if (inprocess)
M[x][y] = 0;
}
}
}
// в противном случае процесс перебора нужно остановить, решение найдено
else
inprocess = 0;
}
int main()
{
// ввод данных с экрана
Input();
// выделение памяти под двумерный массив M
InitMem();
// присваивание каждому элементу массива M0
InitM();
// = 1, если искомая матрица еще не найдена
inprocess= 1;
// отмечаем, что в клетке (x0,y0) конь уже побывал
M[x0][y0] = 1;
запускаем функцию, рекурсивно выполняющую перебор ходов
Step(x0,y0,2); //
// вывод результата на экран
Output();
// освобождение памяти
FreeMem();
// ожидание ввода символа с клавиатуры
char c; scanf("%c",&c);
return0;
}
Самостоятельная работа.
Дана доска размером n x n. Вначале на поле с координатами x[i, j] (координаты задает пользователь) помещается конь - фигура, которая перемещается по шахматным правилам. Задача заключается в поиске хотя бы одной последовательности ходов (если она существует), при которой конь может перейти на поле с координатами x[k, m] (координаты задает пользователь).
Лабораторная работа №26
Метод с возвращением
Цель: использование метода с возвращением, нахождение всех решений (если они существует).
Методические рекомендации: лабораторная работа рассчитана на 2 часа и состоит из анализа одного разобранного задания.
Самостоятельная работа не предусмотрена.
Необходимый уровень знаний:
работа с указателями;
работа с матрицами;
алгоритм поиска с возвращением.
Задача
Расставить восемь ферзей на шахматной доске так, чтобы один ферзь не угрожал другому. Вывести все варианты такого расположения ферзей.
#include <stdio.h>
#include <stdlib.h>
#define N 8
//размер доски - N x N
int*q,*horiz,*diag1m,*diag2;
intinprocess;
/*
q[i] – позиция столбца, где находится ферзь, стоящий наi-й горизонтали
horiz[i]=1 <=>i-тая горизонталь занята
diag1m- диагонали, параллельные главной,diag1m[N-1] - главная диагональ
Нумерация (для N=4):
3210
4321
5432
6543
diag1m[i]=1 <=>i-тая диагональ, параллельная главной, (далее - диагональ-1) занята
diag2 - диагонали, параллельные побочной,diag2[N-1] - побочная диагональ
Нумерация:
0123
1234
2345
3456
diag2[i]=1 <=>i-тая диагональ, параллельная побочной, (далее - диагональ-2) занята
*/
intmain()
{
// выделение памяти для всех используемых массивов
InitMem();
// заполнение массивов horiz,diag1mиdiag2 нулями
InitFill();
//=1 <=> решение еще не найдено
inprocess= 1;
//запуск рекурсивной функции с нулевого столбца
Step(0);
// вывод доски на экран: 0 - пустое поле, 1 - на поле стоит ферзь
Output();
// освобождение памяти
FreeMem();
return0;
}
// функция постановки ферзя на клетку (i,j) (находящуюся наi-той строке иj-том столбце)
void put(int i,int j,int k)
{
q[i] = j;
// если k=1, то мы отмечаем, чтоi-тая горизонталь, (N-1-j+i)-тая диагональ-1 и (i+j)-тая
// диагональ-2 теперь находятся под боем,
// иначе отмечаем, что эта горизонталь и эти диагонали освобождаются
horiz[i] = k;
diag1m[N-1-j+i] = k;
diag2[i+j] = k;
}
//=1 <=> можно поставить ферзя на клетку (i,j)
int canstay(int i,int j)
{
// проверяем, не находятся ли соответствующие горизонталь и диагонали под боем
return (!horiz[i] && !diag1m[N-1-j+i] && !diag2[i+j]);
}
// функция для постановки ферзя на h-ый столбец (нумерация с нуля)
void Step(int h)
{
// если номер столбца не превысил (N-1), то продолжаем поиск решения
// (нумерация столбцов с нуля)
if (h < N)
// просмотр всех строк на наличие решения
for (int i=0; (i<N) && inprocess; i++)
// проверка, что мы можем ставить ферзя в клетку (i,h)
if (canstay(i,h))
{
put(i,h,1);
// поиск позиции для следующего ферзя
Step(h+1);
// если решение не найдено, то освобождаем клетку
if (inprocess)
put(i,h,0);
}
else{}
// иначе решение найдено
else
inprocess= 0;
}
// функция вывода доски на экран: 0 - пустое поле, 1 - на поле стоит ферзь
void Output()
{
int i,j;
for (i=0; i<N; i++)
{
for (j=0; j<N; j++)
if (j == q[i])
printf("1 ");
else
printf("0 ");
printf("\n");
}
}
// функция выделения памяти под массив из nэлементов типаint
void initarr(int*&A,int n)
{
A = (int*)malloc(n*sizeof(int));
}
// функция выделения памяти для всех используемых массивов
void InitMem()
{
initarr(horiz,N);
initarr(diag1m,2*N-1);
initarr(diag2,2*N-1);
initarr(q,N);
}
// функция освобождение памяти
voidFreeMem()
{
free(horiz);
free(diag1m);
free(diag2);
free(q);
}
// функция заполнения массивов horiz,diag1mиdiag2 нулями
void InitFill()
{
int i;
for (i=0; i<N; i++)
horiz[i] = 0;
for (i=0; i<2*N-1; i++)
{
diag1m[i] = 0;
diag2[i] = 0;
}
}
Лабораторная работа №27
Метод с возвращением
Цель: использование метода с возвращением, нахождение оптимального решения по заданному критерию.
Методические рекомендации: лабораторная работа рассчитана на 2 часа и состоит из анализа одного разобранного задания.
Самостоятельная работа не предусмотрена.
Необходимый уровень знаний:
работа с указателями;
работа с матрицами;
алгоритм поиска с возвращением.
Задача
Имеется n мужчин и n женщин. Требуется разделить их на пары, которые заключают между собой браки. Каждая из n женщин выбирает мужчин в порядке предпочтения, от мужчины, которому оказывается наибольшее предпочтение (его ранг равен 1), до того, которому - наименьшее (его ранг равен n). Информация об этих предпочтениях дана в виде матрицы и хранится в текстовом файле. В том же файле находится аналогичная информация для предпочтений мужчин. Решением является выбор пар, которые должны удовлетворять условию стабильности (все браки должны быть стабильными).
Брак между m и w считается нестабильным, если выполняется одно из двух условий:
существует женщина w1, которая у мужчины m имеет большее предпочтение, чем женщина w и у женщины w1 мужчина m имеет большее предпочтение, чем ее муж;
существует мужчина m1, который у женщины w имеет большее предпочтение, чем мужчина m и у мужчины m1 женщина w имеет большее предпочтение, чем его жена.
Необходимо вывести все решения, а также оценки оптимальности каждого решения для мужчин и для женщин.
Оценка оптимальности для женщин определяется как сумма рангов их мужей.
Аналогично определяется оценка оптимальности решения для мужчин.
#include <stdio.h>
#include <stdlib.h>
// количество пар
int n;
// массивы предпочтений
int**W,**M;
// y[i] - мужчина, состоящий в браке с i-той женщиной
int*y;
// x[i] - женщина, состоящая в браке с i-тым мужчиной
int*x;
// Wr[w][m] - ранг m-того мужчины у w-женщины
// (Wr[w][m]=0 <=> женщина w отдает мужчине m наибольшее предпочтение)
int**Wr;
// Mr[m][w] - ранг w-женщины у m-того мужчины
int**Mr;
// функция выделения памяти под одномерный массив из n элементов типа int
void initarr(int*&A)
// функция выделения памяти под двумерный массив n x n
void init2arr(int**&A)
// функция выделения памяти под все используемые массивы
voidInitMem()
// функция освобождения памяти, отведенной под двумерный массив
void free2arr(int**&A)
// функция освобождения памяти, отведенной под все используемые массивы
voidFreeMem()
// функция заполнения массивов x[] и y[] -1 (x[m]=-1 <=> m пока не состоит в браке)
voidInitFill()
// функция считывания из текстового файла fдвумерный массивA
void freadarr(FILE*&f,int**A)
// функция загрузки n и двух матриц предпочтений из файла
voidInput()
// функция заключение брака между w и m
void put(int w,int m,int k)
// функция проверки стабильности браков
int AllStable()
// функция вывода решения на экран
voidOutput()
// функция выбора мужчины для w-ой женщины
void Step(int w)
// функция выделения памяти под одномерный массив из n элементов типа int
void initarr(int*&A)
{
A = (int*)malloc(n*sizeof(int));
}
// функция выделения памяти под двумерный массив n x n
void init2arr(int**&A)
{
A = (int**)malloc(n*sizeof(int*));
for (int i=0; i<n; i++)
initarr(A[i]);
}
// функция выделения памяти под все используемые массивы
void InitMem()
{
init2arr(W);
init2arr(M);
init2arr(Wr);
init2arr(Mr);
initarr(y);
initarr(x);
}
// функция освобождения памяти, отведенной под двумерный массив
void free2arr(int**&A)
{
for (int i=0; i<n; i++)
free(A[i]);
free(A);
}
// функция освобождения памяти, отведенной под все используемые массивы
void FreeMem()
{
free2arr(W);
free2arr(M);
free2arr(Wr);
free2arr(Mr);
free(y);
free(x);
}
// функция заполнения массивов x[] и y[] -1 (x[m]=-1 <=> m пока не состоит в браке)
void InitFill()
{
for (int i=0; i<n; i++)
{
y[i] = -1;
x[i] = -1;
}
}
// функция считывания из текстового файла fдвумерный массивA
void freadarr(FILE*&f,int**A)
{
int r;
int i,j;
for (i=0; i<n; i++)
for (j=0; j<n; j++)
{
fscanf(f,"%d",&r);
A[i][j] = r-1;
}
}
// функция загрузки n и двух матриц предпочтений из файла
void Input()
{
FILE*f;
// открытие текстового файла на чтение
f = fopen("marriage.in","r");
fscanf(f,"%d",&n);
// выделение памяти под все используемые массивы
InitMem();
// считывание из текстового файла f двумерного массива W
freadarr(f,W);
// считывание из текстового файла f двумерного массива M
freadarr(f,M);
// закрытие файла
fclose(f);
}
// функция заключение брака между w-ой женщиной и m-м мужчиной
void put(int w,int m,int k)
{
// если брак заключается, то ставим в соответствие w и m друг другу
if (k)
{
x[m] = w;
y[w] = m;
}
// если брак расторгается, то отмечаем, что w и m теперь single
else
{
x[m] = -1;
y[w] = -1;
}
}
//=1 <=> брак между w и m стабилен
int stable(int w,int m)
{
// предполагаем, что брак стабилен
int yes = 1;
int i = 0;
int m1 = W[w][i];
// проверяем, что жена не уйдет налево
// т.е. перебираем всех мужчин, имеющим у w больший приоритет, чем ее
// предполагаемый муж m
while((m1 !=m) &&yes)
{
// проверка останавливается либо при исчерпании этих мужчин, либо при
// обнаружении нестабильности брака
if(x[i] != -1)
yes = (Mr[m1][w] > Mr[m1][x[m1]]);
i++;
m1 = W[w][i];
}
i = 0;
int w1 = M[m][i];
// проверяем, что муж не уйдет налево
// т.е. перебираем всех женщин, имеющим у m больший приоритет, чем его
// предполагаемая жена w
while((w1 !=w) &&yes)
{
if (y[w1] != -1)
yes = (Wr[w1][m] > Wr[w1][y[w1]]);
i++;
w1 = M[m][i];
}
returnyes;
}
// функция проверки стабильности браков
int AllStable()
{
//предполагаем, что это так
int yes = 1;
int w;
// перебираем все возможные браки, либо до обнаружения первого нестабильного //брака
for (w=0; (w<n) && yes; w++)
yes = stable(w,y[w]);
return yes;
}
// функция вывода решения на экран
void Output()
{
int m;
// rm и rw - оценки оптимальности полученного решения для мужчин и женщин
// соответственно
int rm = 0;
// чем меньше rw, тем оптимальнее полученное решение для женщин
int rw = 0;
for (m=0; m<n; m++)
{
printf("%d ",x[m]+1);
rm += Mr[m][x[m]];
rw += Wr[x[m]][m];
}
// вывод оценок оптимальности после самого решения, через разделители
printf("|%3d|%3d\n",rm+n,rw+n);
}
// функция выдбора мужчины для w-ой женщины
void Step(int w)
{
//если еще не все женщины вышли замуж, то продолжаем поиск решения
if (w < n)
{
int m;
// перебор по рангу i мужчины m у женщины w
for (int i=0; i<n; i++)
// проверка, что m холост
if (x[W[w][i]] == -1)
{
m = W[w][i];
// предварительная проверка, что на данном этапе при уже заключенных
// браках этот брак стабилен
if (stable(w,m))
{
// предварительная проверка, что на данном этапе при уже
// заключенных браках этот брак стабилен
put(w,m,1);
// рекурсивный вызов функции Step() для (w+1)-женщины
Step(w+1);
// заключаем брак между w и m
put(w,m,0);
}
else{}
}
else{}
}
// иначе проверяем полученное решение на "устойчивость"
else
if (AllStable())
// в случае полной стабильности решения выводим его на экран
Output();
else{}
}
// формирование матриц рангов Wr и Mr
void FormWrMr()
{
int m,w,i;
for (m=0; m<n; m++)
for (i=0; i<n; i++)
Mr[m][M[m][i]] = i;
for (w=0; w<n; w++)
for (i=0; i<n; i++)
Wr[w][W[w][i]] = i;
}
intmain()
{
// загрузка n и двух матриц предпочтений из файла
Input();
// формирование матриц рангов Wr и Mr
FormWrMr();
// заполнение массивов x[] и y[] -1 (x[m]=-1 <=> m пока не состоит в браке)
InitFill();
// подбор мужчины для 0-женщины, в теле этой функции рекурсивно запускается
// подбор для 1-женщины и т.д.
Step(0);
// освобождение памяти, отведенной под все используемые массивы
FreeMem();
return 0;
}
Лабораторная работа №28
Элементарные методы сортировки
Цель: закрепление на практике навыков для работы с некоторыми элементарными методами сортировки.
Методические рекомендации: лабораторная работа рассчитана на 2 часа и состоит из анализа трех разобранных заданий.
Самостоятельной работы не предусмотрена.
Для работы с элементарными методами сортировки предусмотрено 3 лабораторные работы и одно обязательное зачетное задание.
Необходимый уровень знаний:
работа с указателями;
работа с функциями.