Очередь. Циклический список. Удалить указанный элемент и все предшествующие - C (СИ)

Узнай цену своей работы

Формулировка задачи:

Очередь. Циклический список. Удалить указанный элемент и все предшествующие. Вот рабочий код, напишите пожалуйста к каждой строке комментарий, что означает или делает эта строка. Помогите очень надо. Спасибо заранее!
#include <stdio.h>
#include <stdlib.h>
 начиная от сюда ->
typedef struct node_t
{
   int value;
   struct node_t* next;
}  TNode;
 
typedef struct queue_t
{
   TNode* head;
   TNode* tail;
}  TQueue;
 
//-----------------------------------------------------------------------------
TQueue* Push(TQueue* list, int value)
{
   TNode* node = (TNode*) malloc(sizeof(TNode));
   node->value = value;
 
   if (list->head && list->tail)
   {
      node->next = list->head;
      list->tail->next = node;
      list->tail = node;
   }
   else
   {
      node->next = node;
      list->head = list->tail = node;
   }
 
   return list;
}
//-----------------------------------------------------------------------------
TQueue* Pop(TQueue* list)
{
   TNode* node = list->head;
 
   if (node)
   {
      if (list->head == list->tail)
      {
         list->head = list->tail = NULL;
      }
      else
      {
         list->head = node->next;
         list->tail->next = list->head;
      }
 
      free(node);
   }
 
   return list;
}
//-----------------------------------------------------------------------------
TNode* Find(TQueue* list, int value)
{
   TNode* node = list->head;
 
   if (node)
   {
      while ((node != list->tail) && (node->value != value))
      {
         node = node->next;
      }
   }
 
   return (node && (node->value == value)) ? node : NULL;
}
//-----------------------------------------------------------------------------
TQueue* RemoveBefore(TQueue* list, int value)
{
   TNode* node = Find(list, value);
 
   if (node)
   {
      while (node != list->head)
      {
         Pop(list);
      }
      Pop(list);
   }
 
   return list;
}
//-----------------------------------------------------------------------------
void Print(const TQueue* list)
{
   TNode* node = list->head;
 
   printf("[");
   if (node)
   {
      while (node != list->tail)
      {
         printf("%d, ", node->value);
         node = node->next;
      }
      printf("%d", node->value);
   }
   printf("]\n");
}
//-----------------------------------------------------------------------------
 
int main()
{
   TQueue list = {NULL, NULL};
   size_t i;
 
   for (i = 0; i < 10; ++i)
   {
      Push(&list, i + 1);
   }
 
   Print(&list);
 
   RemoveBefore(&list, 5);
 
   Print(&list);
 
   system("pause");
 
   return EXIT_SUCCESS;
заканчивая тут
}

Решение задачи: «Очередь. Циклический список. Удалить указанный элемент и все предшествующие»

textual
Листинг программы
#include <stdio.h>
#include <stdlib.h>
 
// Узел списка
typedef struct node_t
{
   int value;           // Хранимое значение
   struct node_t* next; // Указатель на следующий узел
}  TNode;
 
// Очередь
typedef struct queue_t
{
   TNode* head; // Указатель на вершину списка
   TNode* tail; // Указатель на конец списка
}  TQueue;
 
//-----------------------------------------------------------------------------
// Функция добавления элемента в список. В качестве аргументов получает
// саму очереди и элемент который следует добавить
TQueue* Push(TQueue* list, int value)
{
   // Создаём новый узел
   TNode* node = (TNode*) malloc(sizeof(TNode));
   // Задаём значение новому узлу
   node->value = value;
 
   // Если в списке есть уже элементы, то...
   if (list->head && list->tail)
   {
      // Новый элемент будет ссылаться на вершину списка (т.к. у нас кольцо)
      node->next = list->head;
      // А хвост будет ссылаться на новый элемент
      list->tail->next = node;
      // Теперь новый элемент становится хвостом
      list->tail = node;
   }
   // Если список пуст
   else
   {
      // Т.к. у нас кольцевой список, а элемент всего один, то
      // он ссылается сам на себя. И кроме этого является как
      // вершиной, так и хвостом
      //
      node->next = node;
      list->head = list->tail = node;
   }
 
   return list;
}
//-----------------------------------------------------------------------------
// Функция удаления элемента из списка
TQueue* Pop(TQueue* list)
{
   // Вспомогательная переменная, в начале принимает значение вершины
   TNode* node = list->head;
 
   // Если список не пуст
   if (node)
   {
      // Если в списке всего один элемент
      if (list->head == list->tail)
      {
         list->head = list->tail = NULL;
      }
      else
      {
         // указатель на голову смещаем ниже на один узел
         list->head = node->next;
         // Хвост должен указывать на новый верхний узел
         list->tail->next = list->head;
      }
 
      // Удаляем отделённый узел
      free(node);
   }
 
   return list;
}
//-----------------------------------------------------------------------------
// Поиск элемента в списке. В случае нахождения указанного элемента возвращает
// указатель на найденный элемент, иначе возвращает NULL
TNode* Find(TQueue* list, int value)
{
   // Вспомогательная переменная, в начале принимает значение вершины
   TNode* node = list->head;
 
   // Если список не пуст
   if (node)
   {
      // Пока узел не равен хвосту и пока значение его не примет value
      // перебираем узлы
      while ((node != list->tail) && (node->value != value))
      {
         node = node->next;
      }
   }
 
   // Если список был не пуст и был найден требуемый элемент, то
   // возвращаем непосредственно ссылку на него, иначе возвращаем NULL
   return (node && (node->value == value)) ? node : NULL;
}
//-----------------------------------------------------------------------------
// Удаление всех элементов/узлов которые расположены перед искомым.
// Также удаляется и сам элемент
TQueue* RemoveBefore(TQueue* list, int value)
{
   // Пытаемся найти требуемый элемент
   TNode* node = Find(list, value);
 
   // В случае нахождения такового
   if (node)
   {
      // Удаляем все элементы до найденного
      while (node != list->head)
      {
         Pop(list);
      }
      // Удаляем найденный элемент
      Pop(list);
   }
 
   return list;
}
//-----------------------------------------------------------------------------
// Вывод на экран всего списка
void Print(const TQueue* list)
{
   // Вспомогательная переменная, в начале принимает значение вершины
   TNode* node = list->head;
 
   printf("[");
   // Если список не пуст
   if (node)
   {
      // Перебираем все узлы пока не дойдём до хвоста
      while (node != list->tail)
      {
         printf("%d, ", node->value);
         node = node->next;
      }
      // Выводим хвостовой элемент
      printf("%d", node->value);
   }
   printf("]\n");
}
//-----------------------------------------------------------------------------
 
int main()
{
   // Инициализируем список
   TQueue list = {NULL, NULL};
   size_t i;
 
   // Добавляем в список числа от 1 до 10
   for (i = 0; i < 10; ++i)
   {
      Push(&list, i + 1);
   }
 
   // Выводим на экран получившийся список
   Print(&list);
 
   // Удаляем все элемент до цифры 5 включительно
   RemoveBefore(&list, 5);
 
   // Выводим результат
   Print(&list);
 
   system("pause");
 
   return EXIT_SUCCESS;
}

Оцени полезность:

8   голосов , оценка 4.25 из 5
Похожие ответы