методички.C++ / С Fundamentals

5:int x;

6:int y;

7:} Coordinate;

9:int main(void)

10:{

11:Coordinate* pixel; /* объявление указателя на структуру */

12:

13:pixel = (Coordinate *)malloc(sizeof(Coordinate));

14:if (pixel == NULL) {

15:puts(″Out of memory!″);

16:exit(1);

17:}

18:pixel–>x = 10; /* присваивание 10 члену х */

19:pixel–>y = 11; /* присваивание 11 члену y */

20:printf(″x = %d\n″, pixel–>x);

21:printf(″y = %d\n″, pixel–>y);

22:free(pixel);

23:return 0;

24:}

Самоссылочные структуры

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

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

Самыми распространенными самоссылочными структурами являются списки, стеки, и очереди.

Cтеки

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

Стек – это набор связанных между собой элементов, размещаемых в динамической памяти. Стеки организованы по принципу: «Последним вошел

– первым вышел». Данные добавляются в начало стека, называемое вершиной, и извлекаются также из начала стека. Представить себе стек позволяет пример: шарики закатываются в трубку, запаянную с одного конца.

Еще одна распространенная операция над стеками – удаление элементов. Для стека, изображенного на рис. 5.4, следующие операторы удаляют элемент, адресуемый указателем top:

Item *p = top; top = top->next; free(p);

Временному указателю р типа Item * присваивается значение top,

после чего указателю top присваивается адрес следующей структуры (рис. 5.5). Последний оператор передает указатель р в функцию free(), удаляя отсоединенный элемент стека из кучи.

Рис. 5.5. Удаление элемента в стеке

Листинг 5.4 демонстрирует принципы добавления и удаления данных из стека. Скомпилируйте и запустите программу, затем нажмите <A> несколько раз, чтобы добавить в стек новые элементы. Нажмите <D>, чтобы удалить элементы. Если вы удалите все элементы, программа напечатает, что стек пуст.

Листинг 5.4. stack.c (запоминание значений в стеке)

1:#include <stdio.h>

2:#include <stdlib.h>

3:#include <ctype.h>

4:#include <conio.h>

6:#define FALSE 0

7:#define TRUE 1

9:typedef struct item {

11:struct item *next; /* указатель на следующий элемент */

12:} Item;

13:

14:void Push(void);

15:void Pop(void);

16:void Display(void);

21:{

22:int done = FALSE; /* если TRUE, программа завершается */

25:while (!done) {

26:Display();

27:printf("\n\nA)dd, D)elete, Q)uit ");

28:c = getch();

29:switch (toupper(c)) {

30:case ′A′:

31:Push();

32:break;

33:case ′D′:

34:Pop();

35:break;

36:case ′Q′;

37:done = TRUE;

38:break;

39:}

40:}

41:return 0;

42:}

43:

44:/* Добавление элемента в стек */

45:void Push(void)

46:{

47:Item* p;

48:

49:p = (Item *)malloc(sizeof(Item)); /* создание элемента */

50:p->data = rand();

51:p->next = top;

52:top = p;

53:}

54:

55:/* Удаление элемента из стека */

56:void Pop(void)

57:{

58:Item* p;

59:

60:if (top != NULL) { /* если стек не пуст... */

61:p = top;

62:top = top->next;

63:free(p);

64:}

65:}

66:

67:/* Отобразить содержимое стека */

68:void Display(void)

69:{

70:Item* p = top;

71:

72:clrscr();

73:if (p == NULL)

74:printf("Stack is empty");

75:else

76:printf("Stack: ");

77:while (p != NULL) {

78:printf("\n%d", p->data);

80:}

81:}

Встроке 18 объявляется указатель на вершину стека top. Будучи глобальным, указатель автоматически инициализируется нулевым значением, однако здесь ему явно присваивается значение NULL, чтобы подчеркнуть, что в начале программы стек пуст.

Основные функции, используемые при работе со стеками – это Push() и Pop(). Функция Push() (строки 45-53) создает новый элемент и помещает его на вершину стека. В строках 49-50 с помощью указателя p происходит

создание нового элемента и инициализация переменной data случайным числом. Оператор в строке 51:

p->next = top;

связывает новый элемент с предыдущими, образуя цепочку элементов.

Функция Pop() (строки 56-65) удаляет элемент, являющийся вершиной стека и освобождает выделенную память. Функция действует в полном соответствии с принципом «Последним вошел – первым вышел».

Функция Display() (строки 68-81) отображает содержимое стека. С помощью оператора в строке 79:

p = p–>next;

цикл while последовательно перебирает элементы стека, до тех пор, пока не встретится указатель на NULL.

Очереди

Еще одной распространенной структурой данных является очередь.

Очередь можно представить себе как трубку с двумя открытыми концами (рис. 5.6): данные добавляются в начало очереди, а извлекаются из ее конца. Другими словами, очередь работает по принципу: «Первый вошел – первый вышел».

Рис.5.6. Модель очереди

Очереди находят в компьютерных системах многочисленные

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

Информационным пакетам в сети Internet также приходится «стоять в очередях». Пакет в сети переправляется от одного сетевого узла к другому, пока не достигнет узла назначения. Сетевой узел способен послать в каждый момент всего один пакет, поэтому все остальные пакеты становятся в очередь, ожидая, когда пересылающий узел сможет их обработать.

Листинг 5.5 представляет собой пример работы с очередью. Программа queue предлагает выполнить следующие действия: поставить элемент в очередь, удалить его из очереди либо выйти из программы.

Листинг 5.5. queue.c (работа с очередью)

1:#include <stdio.h>

2:#include <stdlib.h>

3:#include <ctype.h>

4:#include <conio.h>

6:#define FALSE 0

7:#define TRUE 1

8:

9:typedef struct item {

10:int data;

11:struct item *next;

12:} Item;

13:

14:void Enqueue(void);

15:void Dequeue(void);

16:void Display(void);

18:/* Указатели на начало (голову) и конец (хвост) очереди */

19:Item *head = NULL, *tail = NULL;

21:int main(void)

22:{

23:int done = FALSE;

24:char c;

25:

26:while (!done) {

27:Display();

28:printf("\n\nA)dd, D)elete, Q)uit ");

29:c = getch();

30:switch (toupper(c)) {

31:case ′A′:

32:Enqueue();

33:break;

34:case ′D′:

35:Dequeue();

36:break;

37:case ′Q′:

38:done = TRUE;

39:break;

40:}

41:}

42:return 0;

43:}

44:

45:/* Поставить элемент в очередь */

46:void Enqueue(void)

47:{

48:Item* p;

49:

50:p = (Item *)malloc(sizeof(Item)); /* создать элемент */

51:p->data = rand(); /* присвоить data случайное число */

53:if (head == NULL) /* если очередь пуста... */

56:tail->next = p; /* поставить новый эл. в конец очереди*/

57: tail = p; /* tail указывает на конец очереди */ 58: } 59:

60:/* Удалить элемент из очереди */

61:void Dequeue(void)

62:{

65:if (head != NULL) { /* если очередь не пуста... */

66:head = head->next; /* head указывает на следующий эл. */

67:if (head == NULL) /* если очередь содержит 1 элемент */

70:}

71:}

72:

73:/* Отобразить содержимое очереди */

74:void Display(void)

75:{

76:Item* p = head;

77:

78:clrscr();

79:if (p == NULL)

80:printf("Queue is empty");

81:else

82:printf("Queue: ");

83:while (p != NULL) {

84:printf("\n%d", p->data);

85:p = p->next;

86:}

87:}

За исключением нескольких важных особенностей листинг 5.5 похож на предыдущий. В строке 18 для работы с очередью объявляется два указателя: head («голова») и tail («хвост») очереди. Указателя два, т.к. в очереди необходимо отслеживать начальный и конечный элемент (рис. 5.7).

Рис. 5.7. Очередь, состоящая из 4 элементов

Функция Enqueue() («поставить в очередь»), описанная в строках 45-57, похожа на функцию Push() для работы со стеками. С помощью временного указателя p создается новый элемент, член data которого инициализируется случайным значением. Указатель next создаваемого элемента всегда должен быть нулевым, т.к. элементы могут добавляться только в конец очереди. Если очередь пуста, то и «голова», и «хвост» очереди будут указывать на создаваемый (первый) элемент. В противном случае на новый элемент будет указывать лишь tail («хвост»).

Функция Dequeue() («удалить из очереди»), описанная в строках 60-70, напоминает функцию Pop(). Вначале проверяется, есть ли в очереди элементы. Если это так, то указателю head присваивается адрес следующего элемента. После этого элемент, на который head указывал раньше, удаляется. Функция работает в полном соответствии с принципом «Первым вошел – первым вышел», так как удаляет элементы только из «головы» очереди.

Списки

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

Листинг 5.6 демонстрирует работу со списками. Программа list расширяет возможности предыдущих программ, позволяя вставлять символы в список в алфавитном порядке.

Листинг 5.6. list.c (управление списком символов)

1:#include <stdio.h>

2:#include <stdlib.h>

3:#include <conio.h>

4:#include <ctype.h>

6:typedef struct item {

7:char data;

8:struct item *next;

9:} Item;

10:

11:void Insert(char value);

12:void Delete(char value);

13:void Display(void);

14:

15:Item* list = NULL;

16:#define FALSE 0

17:#define TRUE 1

18:

19:int main(void)

20:{

21:int done = FALSE;

24:while (!done) {

25:Display();

26:printf("\n\nA)dd, D)elete, Q)uit ");

27:c = getch();

28:switch (toupper(c)) {

29:case ′A′:

30:printf("\nEnter a character: ");

31:value = getch(); /* получить символ */

33:break;

34:case ′D′:

35:if (list != NULL) { /* если список не пуст */

36:printf("\nEnter the character to be deleted: ");

37:value = getch(); /* получить символ */

39:}

40:break;

41:case ′Q′:

42:done = TRUE;

43:break;

44:}

45:}

46:return 0;

47:}

48:

49:/* Вставить элемент в список */

50:void Insert(char value)

51:{

52:Item *p, *cur = list, *prev = NULL;

53:

54:p = (Item *)malloc(sizeof(Item));

55:p->data = value;

56:p->next = NULL;

57:/* Цикл while находит место для вставки элемента */