Федеральное агентство по образованию РФ
Государственное образовательное учреждение высшего профессионального образования
Белгородский Государственный Технологический Университет им. В. Г. Шухова.
Кафедра программного обеспечения вычислительной техники и
автоматизированных систем.
Расчётно-графическое задание по дисциплине
«Алгоритмы и структуры данных»
Выполнил
студент группы КБ-21
Биньковский Борис
Белгород 2014
Стек на массиве.
Файл Stack_Array.h
##ifndef _STACK_ARRAY_H_
#define _STACK_ARRAY_H_
/*Размер стека*/
#defineSIZE_STACK_ARRAY100
/*Описание исключительных ситуаций*/
const int okStackArray = 0; // Все нормально
const int fullStackArray = 1; // Стек переполнен
const int emptyStackArray = 2; // Стек пуст
/*********************************/
/*Переменная ошибок*/
extern int errorStackArray;
/*Базовый тип стека*/
typedef int stackArrayBaseType;
/*Дескриптор стека*/
typedef struct {
stackArrayBaseType buf[SIZE_STACK_ARRAY]; // Буфер стека
unsigned uk; // Указатель
} StackArray;
/*Функции работы со стеком*/
void initStackArray(StackArray *S); // Инициализация стека
void putStackArray(StackArray *S, stackArrayBaseType E); // Включение в стек
void getStackArray(StackArray *S, stackArrayBaseType *E); // Исключение из стека
int isFullStackArray(StackArray *S); // Предикат: полон ли стек
int isEmptyStackArray(StackArray *S); // Предикат: пуст ли стек
#endif
Файл Stack_Array.c
#include <stdio.h>
#include "Stack_Array.h"
/*Переменная ошибок*/
int errorStackArray;
/*Инициализация стека*/
void initStackArray(StackArray *S) {
S->uk = 0;
errorStackArray = okStackArray;
}
/*Включение в стек*/
void putStackArray(StackArray *S, stackArrayBaseType E) {
/*Если стек переполнен*/
if (isFullStackArray(S)) {
return;
}
/*Иначе*/
S->buf[S->uk] = E; // Включение элемента
S->uk++; // Сдвиг указателя
}
/*Исключение из стека*/
void getStackArray(StackArray *S, stackArrayBaseType *E) {
/*Если стек пуст*/
if (isEmptyStackArray(S)) {
return;
}
/*Иначе*/
*E = S->buf[S->uk - 1]; // Считывание элемента в переменную
S->uk--; // Сдвиг указателя
}
/*Предикат: полон ли стек*/
int isFullStackArray(StackArray *S) {
if (S->uk == SIZE_STACK_ARRAY) {
errorStackArray = fullStackArray;
return 1;
}
return 0;
}
/*Предикат: пуст ли стек*/
int isEmptyStackArray(StackArray *S) {
if (S->uk == 0) {
errorStackArray = emptyStackArray;
return 1;
}
return 0;
}
Модуль стека как отображение на ОЛС:
StackList.H
#ifndef _STACK_LIST_H_
#define _STACK_LIST_H_
#include "List_One.h"
/*Описание исключительных ситуаций*/
const int stackListOk = listOneOK;
const int stackListEmpty = listOneEmpty;
const int stackListNoMem = listOneNoMem;
/*Переменная ошибок*/
extern int listOneError;
/*Базовый тип стека на списке*/
typedeflistOneBaseTypestackListBaseType;
/*Тип стека на списке*/
typedef ListOne StackList;
/*Функции работы со стеком*/
void initStackList(StackList *S); // Инициализация стека
void putStackList(StackList *S, stackListBaseType E); // Включение в стек
void getStackList(StackList *S, stackListBaseType *E); // Исключение из стека
void doneStackList(StackList *L); // Удаление стека
int isEmptyStackList(StackList *S); // Предикат: пуст ли стек
/**************************/
#endif
StackList.H
#include "Stack_List.h"
#include "List_One.h"
/*Инициализация стека*/
void initStackList(StackList *S) {
initListOne(S);
listOneError = stackListOk;
}
/*Включение в стек*/
void putStackList(StackList *S, stackListBaseType E) {
putListOne(S, E);
listOneError= listOneNoMem;
}
/*Исключение из стека*/
void getStackList(StackList *S, stackListBaseType *E) {
getListOne(S, E);
listOneError= listOneEmpty;
}
/*Удаление стека*/
void doneStackList(StackList *L) {
doneListOne(L);
}
/*Предикат: пуст ли стек*/
int isEmptyStackList(StackList *S) {
return isEmptyListOne(S);
}
Модуль очереди как отображение на массив:
Queue_Array.H
##ifndef _QUEUE_ARRAY_H_
#define _QUEUE_ARRAY_H_
/*Размер очереди*/
#defineSIZE_QUEUE_ARRAY3
/*Описание исключительных ситуаций*/
const int okQueueArray = 0; // Все нормально
const int fullQueueArray = 1; // Очередь переполнена
constintemptyQueueArray= 2; // Очередь пуста
/*Переменная ошибок*/
extern int errorQueueArray;
/*Базовый тип очереди*/
typedef int queueArrayBaseType;
/*Дескриптор очереди*/
typedef struct {
queueArrayBaseType buf[SIZE_QUEUE_ARRAY]; // Буфер очереди
unsigned ukEnd; // Указатель на хвост (по нему включают)
unsigned ukBegin; // Указатель на голову (по нему исключают)
unsigned len; // Количество элементов в очереди
} QueueArray;
/*Функции работы с очередью*/
void initQueueArray(QueueArray *F); // Инициализация очереди
void putQueueArray(QueueArray *F, queueArrayBaseType E); // Включение в очередь
void getQueueArray(QueueArray *F, queueArrayBaseType *E); // Исключение из очереди
int isFullQueueArray(QueueArray *F); // Предикат: полна ли очередь
int isEmptyQueueArray(QueueArray *F); // Предикат: пуста ли очередь
#endif
Queue_Array.H
#include <stdio.h>
#include "Queue_Array.h"
/*Переменная ошибок*/
int errorQueueArray;
/*Инициализация очереди*/
void initQueueArray(QueueArray *F) {
F->ukBegin = 0;
F->ukEnd = 0;
F->len = 0;
errorQueueArray = okQueueArray;
}
/*Включение в очередь*/
void putQueueArray(QueueArray *F, queueArrayBaseType E) {
/*Если очередь переполнена*/
if (isFullQueueArray(F)) {
return;
}
/*Иначе*/
F->buf[F->ukEnd] = E; // Включение элемента
F->ukEnd = (F->ukEnd + 1) % SIZE_QUEUE_ARRAY; // Сдвиг указателя
F->len++; // Увеличение количества элементов очереди
}
/*Исключение из очереди*/
void getQueueArray(QueueArray *F, queueArrayBaseType *E) {
/*Если очередь пуста*/
if (isEmptyQueueArray(F)) {
return;
}
/*Иначе*/
*E = F->buf[F->ukBegin]; // Запись элемента в переменную
F->ukBegin = (F->ukBegin + 1) % SIZE_QUEUE_ARRAY; // Сдвиг указателя
F->len--; // Уменьшение длины
}
/*Предикат: полна ли очередь*/
int isFullQueueArray(QueueArray *F) {
if (F->len == SIZE_QUEUE_ARRAY) {
errorQueueArray = fullQueueArray;
return 1;
}
return 0;
}
/*Предикат: пуста ли очередь*/
int isEmptyQueueArray(QueueArray *F) {
if (F->len == 0) {
errorQueueArray = emptyQueueArray;
return 1;
}
return 0;
}
Модуль очереди как отображение на ОЛС: