if (minimum_.Empty() && Size() != 0) {
    Stack<T> right_reversed = right_.GetReversedStack();
    right_.DeleteStack();

    minimum_ = left_.GetMinStackWithOther(right_reversed);
  }


Node* GetFirstNode() { return head_; }
Stack<T> GetMinStackWithOther(Stack<T> other);
Stack<T> GetReversedStack();

template <typename T>
Stack<T> Stack<T>::GetMinStackWithOther(Stack<T> other) {
  Stack<T> min_stack;

  Node* current_node = head_;
  bool current_stack = true;

  while (current_stack || current_node != nullptr) {
    if (min_stack.Empty() || current_node->value <= min_stack.GetHead().second) {
      min_stack.Push(current_node->value);
    }

    if (current_node->next_node == nullptr && current_stack) {
      current_node->next_node = other.GetFirstNode();
      current_stack = false;
    }

    current_node = current_node->next_node;
  }

  return min_stack;
}

template <typename T>
Stack<T> Stack<T>::GetReversedStack()
{
  Stack<T> reversed_stack;

  Node* current_node = head_;

  while (current_node != nullptr) {
    reversed_stack.Push(current_node->value);
  }

  return reversed_stack;
}