Stack: Difference between revisions

 

 

Sometimes the last pushed stack element is made accessible for immutable access (for read) or mutable access (for write):

 

 

 

 

Create a stack supporting the basic operations: push, pop, empty.

 

=={{header|ActionScript}}==

In ActionScript an Array object provides stack functionality.

stack.push(1);

stack.push(2);

trace(stack.pop()); // outputs "2"

 

=={{header|Ada}}==

This is a generic stack implementation.

 

=={{header|ALGOL 68}}==

ALGOL 68 uses "HEAP" variables for new LINKs in a linked list. Generally ALGOL 68's

 

 

);

 

 

 

 

OD;

 

<pre>

</pre>

 

=={{header|AutoHotkey}}==

msgbox % stack("push", 5)

msgbox % stack("peek")

return 0

}

}

=={{header|C}}==

#include <stdlib.h>

#include <stddef.h>

s->bottom = realloc(s->bottom, new_size);

check_pointer(s->bottom);

 

 

 

=={{header|C++}}==

{{libheader|STL}}

The C++ standard library already provides a ready-made stack class. You get it by writing

and then using the <tt>std::stack</tt> class.

 

An example of an explicit implementation of a stack class (which actually implements the standard stack class, except that the standard one is in namespace std):

template <class T, class Sequence = std::deque<T> >

class stack {

{

return !(x < y);

 

 

 

elements)

 

(push element (stack-elements stack)))

 

 

(defun stack-empty (stack)

 

(defun stack-peek (stack)

 

=={{header|D}}==

}

 

 

 

Here's a stack implemented out of a reference to a linked list:

 

 

 

=={{header|Erlang}}==

Erlang has no built-in stack, but its lists behave basically the same way. A stack module can be implemented as a simple wrapper around lists:

-export([empty/1, new/0, pop/1, push/2, top/1]).

 

push(H,T) -> [H|T].

 

Note that as Erlang doesn't have mutable data structure (destructive updates), pop returns the popped element and the new stack as a tuple.

 

The module is tested this way:

{ok,stack}

2> Stack = stack:new().

false

7> stack:empty(stack:new()).

 

 

=={{header|Forth}}==

 

 

=={{header|Groovy}}==

Of course, these stack semantics are not ''exclusive''. Elements of the list can still be accessed and manipulated in myriads of other ways.

 

assert stack.empty

 

assert stack.empty

 

 

<pre>[55, 21, kittens]

[55, 21]

 

=={{header|Haskell}}==

The Haskell solution is trivial, using a list. Note that <code>pop</code> returns both the element and the changed stack, to remain purely functional.

 

create :: Stack a

peek :: Stack a -> a

peek [] = error "Stack empty"

We can make a stack that can be destructively popped by hiding the list inside a <code>State</code> monad.

 

type Stack a b = State [a] b

 

nonEmpty :: Stack a ()

 

 

 

 

 

 

=={{header|Java}}==

private Node first = null;

}

throw new Exception("Can't Pop from an empty Stack.");

return temp;

}

}

first = new Node(o, first);

}

this(value, null);

}

}

}

{{works with|Java|1.5}}

private Node first = null;

}

throw new Exception("Can't Pop from an empty Stack.");

return temp;

}

}

first = new Node(o, first);

}

this(value, null);

}

}

}

 

=={{header|JavaScript}}==

The built-in Array class already has stack primitives.

stack.push(1)

stack.push(2,3);

print(stack.pop()); // 3