Return 0;

Файл stack.h

#include <stdio.h>

#include <stdlib.h>

#include <malloc.h>

#include <conio.h>

////////////////////// Stack for char

typedef struct {

char *stack;

int head;

int size;

} STACK;

int Init(STACK* Stack, int nSize);

char Pop(STACK* Stack);

int Push(STACK* Stack, char cElement);

void Clear(STACK* Stack);

int GetSize(STACK* Stack);

void Free(STACK* Stack);

////////////////////// Stack for char

///////////////////////////////////////////////

#include "stack.h"

int Init(STACK* Stack, int nSize)

{

Stack->stack = (char*)malloc(nSize);

if (Stack->stack == NULL) return -1;

Stack->size = nSize;

Stack->head = 0;

return nSize;

}

///////////////////////////////////////////////

char Pop(STACK* Stack)

{

if (Stack->head == 0) return 0;

return Stack->stack[--Stack->head];

}

///////////////////////////////////////////////

int Push(STACK* Stack, char cElement)

{

if (Stack->head == Stack->size) return -1;

Stack->stack[Stack->head++] = cElement;

return 1;

}

///////////////////////////////////////////////

void Clear(STACK* Stack)

{

Stack->head = 0;

}

///////////////////////////////////////////////

int GetSize(STACK* Stack)

{

return Stack->head;

}

///////////////////////////////////////////////

void Free(STACK* Stack)

{

free(Stack->stack);

}

Как пользоваться

void main()

{

STACK A;

Init(&A, 8);

Push(&A, 'J');

Push(&A, 'F');

char c = Pop(&A);

. . .

/* На основе статического массива создать очередь для чисел с функциями Put, Get . Ввести с экрана имя файла для сохранения результата. Ввести размер очереди. При вводе в очередь заносить только отрицательные числа. Сохранить результат. */

#include <stdio.h>

#include <conio.h>

#define MAX 50

int Queue Queue [MAX];

int beg = 0;

int end = 0;

void put(int c) {Queue [end++] = c;}

int get() {return Queue [beg++];}

Int main (void)

{

int i, j, q, n, count = 0;

char name_fil[100] = " ";

FILE *fp;

puts("Input name of file: ");

Gets(name_fil);

if ((fp = fopen(name_fil,"w+")) == NULL)

{ puts("\nFile not open"); getch(); return -1;}

puts("Input size of Queue : ");

scanf("%d",&n);

puts("input elements of Queue : ");

for(j = 0; count < n; j++) { scanf("%d", &q);

if(q < 0)

{put(q); count++;}

}

if (count > 0) {

printf("Elements of Queue : \n");

for (i = 0; i < count; i++) { q = get();

fprintf(fp, "%d ", q);

printf("%d ", q);

}

printf("\n");

}

Else

puts("Queue is empty\n");

Fclose(fp); getch();

return 0;

}

3. Использование стека при организации связи функций в языке Си и в операционной системе.

5. Программная реализация очереди на основе статического массива.

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

#include <malloc.h>

/////////////// Queue for int positive (x>0)

typedef struct {

int *queue;

int head;

int tail;

int size;

} QUEUE;

int Init(QUEUE* Queue, int nSize);

int Extract(QUEUE* Queue);

int Add(QUEUE* Queue, int nElement);

void Clear(QUEUE* Queue);

int GetSize(QUEUE* Queue);

void Free(QUEUE* Queue);

Программа реализации кольцевой очереди на основе статического массива – queue.cpp:

#include "queue.h"

/////////////// Queue for int positive (x>0)

//////////////////////////////////////////

int Init(QUEUE* Queue, int nSize)

{

Queue->queue = (int*)malloc(nSize*(sizeof(int)));

if (Queue->queue == NULL) return -1;

Queue->size = nSize;

Queue->head = 0;

Queue->tail = 0;

return nSize;

}

///////////////////////////////////////////

int Extract(QUEUE* Queue)

{

int w;

if (Queue->head == Queue->tail) return -1;

w = Queue->queue[Queue->head];

if (Queue->head == Queue->size - 1)

Queue->head = 0;

else

Queue->head++;

return w;

}

///////////////////////////////////////////

int Add(Q* Qu, int nEl)

{

if (Qu->tail +1 == Qu->head)

return -1; // Очередь заполнена - запись невозможна!

if (Qu->tail == Qu->size )

if( Qu->head > 1)

Qu->tail = 0; //Достигнут конец памяти, выделенной под очередь

else return -1;

Qu->queue[Qu->tail++] = nEl;

return 1;

}

///////////////////////////////////////////

void Clear(QUEUE* Queue)

{

Queue->head = 0;

Queue->tail = 0;

}

///////////////////////////////////////////

int GetSize(QUEUE* Queue)

{

if (Queue->head == Queue->tail)

return 0; // Очередь пуста

if (Queue->head < Queue->tail)

return (Queue->tail - Queue->head);

else

return (Queue->size - (Queue->head - Queue->tail));

}

///////////////////////////////////////////

void Free(QUEUE* Queue)

{

free(Queue->queue);

}

Тестовая программа:

#include "queue.h"

/////////////////////////// Print of queue information

void Print(QUEUE *Queue)

{

if (Queue->head == Queue->tail)

printf("\nQueue is empty!");

else

printf ("\nhead=%u, tail=%u, (%d-%d)", Queue->head, Queue->tail,

Queue->queue[Queue->head], Queue->queue[Queue->tail-1]);

}

void main()

{

QUEUE Queue;

Init(&Queue,4); Print(&Queue);

Add(&Queue,10); Print(&Queue);

Add(&Queue,11); Print(&Queue);

Add(&Queue,12); Print(&Queue);

Extract(&Queue); Print(&Queue);

Add(&Queue,13); Print(&Queue);

Extract(&Queue); Print(&Queue);

Add(&Queue,21); Print(&Queue);

Extract(&Queue); Print(&Queue);

Add(&Queue,22); Print(&Queue);

GetSize(&Queue);

Extract(&Queue); Print(&Queue);

Extract(&Queue); Print(&Queue);

Extract(&Queue); Print(&Queue);

Clear(&Queue); Print(&Queue);

Add(&Queue,31); Print(&Queue);

Extract(&Queue); Print(&Queue);

Free(&Queue);

getch();}

6. Логическая шкала и описание множества элементов

typedef struct

{

short x;

short y;

char color;

} COLORPOINT;

7. Операции над множествами. Использование структуры типа «множество» при программировании.

0 0 1 1 1 0 1 0 1 0 0 0 1 1 1 0 1

0 0 0 1 1 1 0 0 0 0 0 1 1 1 1 1 0

0 0 0 1 1 0 0 0 0 0 0 0 1 1 1 0 0 – результат: в отмеченных единицами позициях везде черный цвет.

Для определения позиций белого цвета исходные строки необходимо инвертировать:

1 1 0 0 0 1 0 1 0 1 1 1 0 0 0 1 0

1 1 1 0 0 0 1 1 1 1 1 0 0 0 0 0 1

1 1 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 – результат: в отмеченных единицами позициях везде белый цвет.

Для программирования задач, связанных с побитной обработкой информации очень полезными могут оказаться следующие макроподстановки:

// Количество бит в байте

#define S_1 8

//Адр байта, в кот описывается(представляется битом) x_-ый элемент

#define BIT_BYTE(x_) ((x_)/S_1)

//Кол-во байт, необходимое для представления x_ элементов множеств

#define LEN_BYTE(x_) (((x_)+S_1-1)/S_1)

// Номер бита в байте, представляющего x_-ый элемент множества

#define ADR_BIT(x_) ((x_)%S_1)

Теперь в нашей программе определим статический массив:

static BYTE OB[8]={128,64,32,16,8,4,2,1};

и тогда доступ к отдельному биту можно записывать так:

int GetBitAt(BLACK *Vect, int nIndex)

{

return ((Vect->set[BIT_BYTE(nIndex)] & OB[ADR_BIT(nIndex)])!=0);

}

Пользоваться: