-
Структуры данных.
Структурой данных является реализация понятия множества элементов определенного типа. Под реализацией понимается способ хранения данных. Вместе со способом хранения задается набор операций (=алгоритмов) по добавлению, поиску, удалению элементов множества.
-
Вектор.
Массив в языке С является точной реализацией структуры данных вектор. Вектором называется структура данных, в которой к каждому элементу множества можно обратиться по целочисленному индексу. В структуре данных вектор значение индекса может быть ограничено некоторой наперед заданной величиной - длиной вектора. В качестве опций в соответствующий исполнитель могут быть добавлены функции проверки невыхода индекса за границу вектора, проверки того, что по данному индексу когда-то был положен элемент.
Создание исполнителя вектор предполагает наличие следующих функций
-
создать вектор длины n
-
положить элемент в вектор по индексу i
-
взять элемент из вектора по индексу i
-
уничтожить вектор
При использовании массивов для реализации структуры данных вектор, создание/уничтожение объекта происходит в соответствующие моменты автоматически. Если же этим процессом надо управлять, то следует использовать функции malloc() / free().
Возможна ситуация, когда размер вектора становится известным уже после написания программы, но до ее компиляции (или мы для одной программы хотим получать ее различные версии для различных длин вектора). В этой ситуации можно задать размер массива константой препроцессора. Значение константы можно передать через ключи компилятора. Например, в программе (в файле prog.c) можно записать следующий набор операторов :
#ifndef N
#define N 100
#endif
int Array[N] ;
Если константа N не определена, то ее значение полагается равным 100. Далее создается массив из N элементов. У большинства компиляторов значение константы препроцессора можно передать через ключ `D’, например, для компилятора gcc это будет выглядеть так:
gcc –DN=200 prog.c
В получившейся программе с именем ./a.out везде вместо идентификатора N будет подставляться 200.
-
Стек.
Стеком называется структура данных, организованная по принципу LIFO – last-in, first-out , т.е. элемент, попавшим в множество последним, должен первым его покинуть. При практическом использовании часто налагается ограничение на длину стека, т.е. требуется, чтобы количество элементов не превосходило N для некоторого целого N.
Создание исполнителя стек предполагает наличие следующих функций
-
инициализация
-
добавление элемента на вершину стека
-
взятие/извлечение элемента с вершины стека
-
проверка: пуст ли стек?
-
очистка стека
Стек можно реализовать на базе массива или (в языке С ) это можно сделать на базе указателей.
Стек. Реализация 1.
Для реализации стека целых чисел, состоящего не более чем из 100 чисел, на базе массива в языке С следует определить массив целых, состоящий из 100 чисел и целую переменную, указывающую на вершину стека (ее значение будет также равно числу элементов в стеке)
int stack[100], i0=0;
Также, как было показано выше, максимальный размер стека можно задать после написания программы, но перед ее компиляцией, с помощью передачи соответствующей константы через ключи компилятора.
Стек. Реализация 2.
Для группировки различных переменных в один объект (например, чтобы впоследствии, так или иначе, передавать этот объект в функции за один прием) в языке С следует использовать структуры. Например, все данные, относящиеся к стеку можно поместить в структуру struct SStack:
struct SStack
{
int stack[100];
int i0;
};
Здесь создан новый тип с именем struct SStack. Далее можно создать переменную этого типа:
struct SStack st2;
Структуры нельзя передавать в качестве параметров функций, их нельзя возвращать как результат работы функций, но во всех этих случаях можно использовать указатели на структуры. Например, следующая функция будет инициализировать наш стек:
void InitStack(struct SStack *ss){ ss->i0=0 ;}
Вызов функции осуществляется следующим способом :
InitStack(&st2) ;
Стек. Реализация 3.
Если максимальный размер стека можно выяснить только после сборки программы, то память под стек можно выделить динамически. При этом, вершину стека можно указывать не индексом в массиве, а указателем на вершину (отметим, что оба способа указания вершины стека применимы в обоих реализациях стека). Для этого следует определить следующие переменные
int *stack, *head;
Как и ранее, эти переменные можно объединить в структуру:
struct SStack3{ int *stack, *head; };
Тогда соответствующую переменную st3 можно определить оператором
struct SStack3 st3;
Стек. Реализация 4.
Однако, можно поступить и по-другому. Т.к. элементы stack и head имеют один тип, то их можно объединить в один массив объектов соответствующего типа (т.е. типа int* ). Массив, естественно, должен быть длины 2:
int *st4[2];
Здесь следует заметить, что при определении/описании переменных квадратные скобки имеют приоритет больший, чем *, поэтому переменная st4 имеет тип `массив указателей’, а не `указатель на массив’.
Функция создания стека не более чем из n элементов может выглядеть, в простейшем случае, следующим образом
void StackCreate4(int n, int *st[2] ) {st[1]= st[0] = (int*)malloc(n*sizeof(int));}
а ее вызов будет выглядеть так: StackCreate4(n,st4);
Простейшая функция добавления элемента к стеку может выглядеть, в простейшем случае (без проверки переполнения), следующим образом
void StackAdd4(int v, int * st[2] ) { (*(st[1]++)) = v;}
а ее вызов будет выглядеть так: StackAdd4 (v, st4);
Проверка стека на пустоту выглядит следующим образом :
int StackIsEmpty4 ( int * st[2] ) { return st[1]<=st[0] ; }
Стек. Реализация 5.
У Реализации 4 есть существенный недостаток. Допустим, что стек создан внутри некоторой функции и требуется использовать его вне данной функции. Тогда у нас есть единственная возможность осуществить данную реализацию, это - сделать переменную st4 глобальной или локальной статической. В противном случае, при выходе из данной функции переменная st4 утратит свое существование и указателями st4[0], st4[1] уже нельзя будет пользоваться. Но, как уже писалось, подобный способ реализации является дурным стилем.
Собственно, вся наша проблема состоит в том, что память под переменную st4 отводится и очищается автоматически. В качестве альтернативы, отведение/очистку памяти под указатели можно взять на себя. Для этого следует использовать указатель на указатель на целую переменную:
int **st5;
Функция создания стека не более чем из n элементов может выглядеть, в простейшем случае, следующим образом
int ** StackCreate5(int n )
{int **st; st = (int**)malloc(2*sizeof(int*)); st[1]= st[0] = (int*)malloc(n*sizeof(int));}
а ее вызов будет выглядеть так: st5=StackCreate5(n);
Теперь переменная st5 может быть локальной и если ее вернуть из функции, то содержимое стека не будет потерянным. Очистку стека можно произвести с помощью следующей функции
void StackDelete5(int **st ) { free(st[0]); free(st);}
а ее вызов будет выглядеть так: StackDelete5 (st5);
