One of the types of data structures that are widely used today in application programming is the stack. Its feature is the principle of organizing elements, in which their addition and removal is possible only one at a time and only through the "top", that is, according to the LIFO principle. But sometimes it is necessary to clear the entire stack at once.
Necessary
- - text editor or IDE;
- - a translator from the used programming language.
Instructions
Step 1
Use methods on the stack objects that are specifically designed to clean up the stack. They are present in most of the corresponding classes of various libraries and frameworks. For example, the. NET Stack class has a Clear method. An example of its use in C # might look like this:
Stack oStack = new Stack (); // create a stack object
oStack. Push ("000"); // fill the stack
oStack. Push ("111");
oStack. Clear (); // clear the stack
Step 2
Methods for changing the number of elements of container classes, on which the functionality of stack classes is often built, can also be used for cleaning. You just need to reduce the current number of elements to zero. For example, the Qt template class QStack inherits from the QVector template class, which has a resize method. An example of its use could be like this:
QStack oStack; // declaration of the stack object
for (int i = 0; i <10; i ++) oStack.push (i); // fill the stack
oStack.resize (0); // clear the stack
Step 3
Cleaning up a stack object can usually be done through the assignment operator, which is often implemented in the corresponding classes. To do this, the object of the stack to be cleared must be assigned a temporary object created by the default constructor. For example, the C ++ Standard Library stack templated class, which is an adapter for container templated classes, does not have methods for arbitrarily changing the number or removing all elements. You can clear it like this:
std:: stack <int, std:: list> oStack; // declaration of the stack object
for (int i = 0; i <10; i ++) oStack.push (i); // fill the stack
oStack = std:: stack
Step 4
Clear the stack object by calling the copy constructor using the new operator with an object argument created by the default constructor:
std:: stack <int, std:: list> oStack; // declaration of the stack object
for (int i = 0; i <10; i ++) oStack.push (i); // fill the stack
new std:: stack
Step 5
The stack can be cleared by sequentially retrieving all elements using the appropriate methods:
std:: stack <int, std:: list> oStack; // declaration of the stack object
for (int i = 0; i <10; i ++) oStack.push (i); // fill the stack
while (! oStack.empty ()) oStack.pop (); // clear the stack
However, this approach has a time complexity that linearly depends on the number of elements in the stack. Therefore, its use is not rational.
