Stack: Difference between revisions

=={{header|ActionScript}}==

In ActionScript an Array object provides stack functionality.

var stack:Array = new Array();

stack.push(1);

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

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

=={{header|Ada}}==

This is a generic stack implementation.

generic

type Element_Type is private;

end record;

end Generic_Stack;

with Ada.Unchecked_Deallocation;

end Generic_Stack;

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

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

[[garbage collector]] should recover the LINK memory some time after a value is popped.

MODE VALUE = STRING; # type of a LINK in this STACK #

print(((repr OF class stack)(stack), newline))

Output:

<pre>

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

check_pointer(s->bottom);

s->allocated_top = s->bottom + qtty - 1;}

=={{header|C sharp|C #}}==

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

#include <stack>

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):

#include <deque>

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

return !(x < y);

}

=={{header|D}}==

Implemented a stack class by using sequence array.

module stack ;

class Stack(T){

bool empty() { return content.length == 0 ; }

}

=={{header|E}}==

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

type Stack a = [a]

empty [] = true

empty _ = false

=={{header|Java}}==

public class Stack

{

}

}

{{works with|Java|1.5}}

public class Stack<T>

{

}

}

=={{header|JavaScript}}==

The built-in Array class already has stack primitives.

var stack = [];

stack.push(1)

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

print(stack.length); // 2, stack empty if 0

=={{header|Logo}}==

Implemented as a singly-linked list, wrapped in an object:

exception Stack_empty

lst = []

end

=={{header|Pascal}}==

This implements stacks of integers in standard Pascal (should work on all existing Pascal dialects).

{ tStack is the actual stack type, tStackNode a helper type }

type

dispose(node);

end;

=={{header|Python}}==

The faster and Pythonic way is using a deque (available from 2.4). A regular list is little slower.

from collections import deque

stack = deque()

value = stack.pop()

not stack # is empty?

If you need to expose your stack to the world, you may want to create a simpler wrapper:

from collections import deque

def __nonzero__(self):

return bool(self._items)

Here is a stack implemented as linked list - with the same list interface.

class Stack:

def __init__(self):

value, self._first = self._first

return value

Notes:

Using list interface - append, __nonzero__ make it easier to use, cleanup the client code, and allow changing the implementation later without affecting the client code. For example, instead of:

while not stack.empty():

You can write:

while stack:

Quick testing show that deque is about 5 times faster then the wrapper linked list implementations. This may be important if your stack is used in tight loops.

Using an Array:

stack = []

stack.push(value) # pushing

value = stack.pop # popping

stack.empty? # is empty?

If you need to expose your stack to the world, you may want to create a simpler wrapper:

class Stack

def initialize

end

end

=={{header|Scheme}}==

This version uses primitive message passing.

(define (make-stack)

(let ((st '()))

result)))

(else 'badmsg)))))