Stacks (OCR A Level Computer Science)

Implementing a Stack

How Do You Program a Stack?

• To recap the main operations of Stacks and how they work, follow this link

• When programming a stack, the main operations listed below must be included in your program.

• The main operations for Stacks are:

Main Operations

Programming a Stack in Python

Explanation of the Python Code

• Class Stack: Defines a Python class, Stack, with a specified capacity and an empty list to store elements.

• Push Method: Appends an item to the stack if the stack is not full; otherwise, it prints a message to say that it is not possible.

• Pop Method: Removes and returns the top item from the stack if it's not empty; otherwise, it prints a message to say nothing can be popped as it is empty.

• Peek Method: Returns the top item of the stack without removing it if the stack is not empty; otherwise, it will print a message to say the stack is empty.

• Additional Operations: The code at the bottom includes methods to retrieve the stack size (size), check if the stack is empty (isEmpty), and check if the stack is full (isFull).

class Stack:

    def __init__(self, capacity):

        self.capacity = capacity

        self.stack = []

    def push(self, item):

        if len(self.stack) < self.capacity:

            self.stack.append(item)

            print("Pushed item:", item)

        else:

            print("Stack is full. Cannot push item:", item)

    def pop(self):

        if not self.isEmpty():

            return self.stack.pop()

        else:

            print("Stack is empty. Cannot pop item.")

    def peek(self):

        if not self.isEmpty():

            return self.stack[-1]

        else:

            print("Stack is empty. Cannot peek.")

    def size(self):

        return len(self.stack)

    def isEmpty(self):

        return len(self.stack) == 0

    def isFull(self):

        return len(self.stack) == self.capacity

• This code below is used to demonstrate the usage of the operations above with a stack of animals, pushing, popping, peeking, and checking the stack's status.

# Create a stack with a capacity of 5

stack = Stack(5)

# Push animals onto the stack

stack.push("Dog")

stack.push("Cat")

stack.push("Elephant")

stack.push("Lion")

stack.push("Tiger")

# Try pushing more animals than the capacity allows

stack.push("Giraffe")  # Output: Stack is full. Cannot push item: Giraffe

# Pop an animal from the stack

popped_animal = stack.pop()

print("Popped animal:", popped_animal)  # Output: Popped animal: Tiger

# Peek at the top animal of the stack

top_animal = stack.peek()

print("Top animal:", top_animal)  # Output: Top animal: Lion

# Get the size of the stack

stack_size = stack.size()

print("Stack size:", stack_size)  # Output: Stack size: 4

# Check if the stack is empty

is_empty = stack.isEmpty()

print("Is stack empty?", is_empty)  # Output: Is stack empty? False

# Check if the stack is full

is_full = stack.isFull()

print("Is stack full?", is_full)  # Output: Is stack full? False

Programming a Stack in Java

Explanation of the Java Code

• AnimalStack Class: Defines a class named AnimalStack that uses the Stack class to implement a stack for storing animal names with a specified capacity.

• Push Method: Adds an animal to the stack if it's not full; otherwise, it prints a message to say that it is not possible.

• Pop Method: Removes and returns the top animal from the stack if it's not empty; otherwise, it prints a message to say that it is not possible and returns null.

• Peek Method: Returns the top animal without removing it if the stack is not empty; otherwise, it prints a message to say that it is not possible and returns null.

• Main Method Usage: Demonstrates the usage of the AnimalStack class with a stack of animals, showcasing pushing, popping, peeking, and checking stack size and status.

import java.util.Stack;

public class AnimalStack {

    private int capacity;

    private Stack<String> stack;

    public AnimalStack(int capacity) {

        this.capacity = capacity;

        this.stack = new Stack<>();

    }

    public void push(String animal) {

        if (stack.size() < capacity) {

            stack.push(animal);

            System.out.println("Pushed item: " + animal);

        } else {

            System.out.println("Stack is full. Cannot push item: " + animal);

        }

    }

    public String pop() {

        if (!isEmpty()) {

            return stack.pop();

        } else {

            System.out.println("Stack is empty. Cannot pop item.");

            return null;

        }

    }

    public String peek() {

        if (!isEmpty()) {

            return stack.peek();

        } else {

            System.out.println("Stack is empty. Cannot peek.");

            return null;

        }

    }

    public int size() {

        return stack.size();

    }

    public boolean isEmpty() {

        return stack.isEmpty();

    }

    public boolean isFull() {

        return stack.size() == capacity;

    }

    public static void main(String[] args) {

        AnimalStack stack = new AnimalStack(5);

        stack.push("Dog");

        stack.push("Cat");

        stack.push("Elephant");

        stack.push("Lion");

        stack.push("Tiger");

        stack.push("Giraffe");  // Output: Stack is full. Cannot push item: Giraffe

        String poppedAnimal = stack.pop();

        System.out.println("Popped animal: " + poppedAnimal);  // Output: Popped animal: Tiger

        String topAnimal = stack.peek();

        System.out.println("Top animal: " + topAnimal);  // Output: Top animal: Lion

        int stackSize = stack.size();

        System.out.println("Stack size: " + stackSize);  // Output: Stack size: 4

        boolean isEmpty = stack.isEmpty();

        System.out.println("Is stack empty? " + isEmpty);  // Output: Is stack empty? false

        boolean isFull = stack.isFull();

        System.out.println("Is stack full? " + isFull);  // Output: Is stack full? false

    }

}