Stacks und Queues Implementieren

[Ninjafighter]

Sehr geehrte Community,

ich muss einen vorgegeben Stack und Queue implementieren.

public interface IStack<T> {
   
    /** Adds new element to the top */
    public void push(T t);
    /** Removes and returns the top element */
    public T pop();
    /** Returns the top element without removing */
    public T top();
    /** Checks if the stack is empty */
    public boolean isEmpty();
   
}

public interface IQueue<T> {
   
    /** Enqueues an element */
    public void enqueue(T t);
    /** Dequeues the first element */
    public T dequeue();
    /** Returns the first element */
    public T front();
    /** Checks if the queue is empty */
    public boolean isEmpty();
   
}

Was ich bis jetzt gemacht habe ist aus einem Standartbeispiel, ich versuchte irgendwie es an die Aufgabe anzupassen.

Für Stack

public class Stack<T> implements IStack<T> {

    // Attributes
    private Object[] elements = null;
    private int num = 0;

    // Constructors
    public Stack (int size) {
        elements = new Object [size];
    }

    public Stack() {
        elements = new Object[100];
    }

    @Override
    public void push(T t) {

        // If Stack is full, throw exception
        if (num == elements.length)
            throw StackException();

        // Put the element on the top of the stack
        elements[num] = obj;

        // Increase counter by one
        num++;
    }

    @Override
    public T pop() {
       
        // If Stack is empty, throw exception
        if ( isEmpty()) throw StackException {
           
            // Decrease counter by one
            num--;
           
            // Store element
            Object o = elements[num];
           
            // Delete element
            elements[num] = null;
           
            // Return element
            return o;
        }
    }

    @Override
    public T top() {

        // If Stack empty, throw exception
        if (isEmpty())
            throw new StackException();

        // Go back to the first element
        return elements[num - 1];
    }

    @Override
    public boolean isEmpty() {
        return num == 0;
    }

}

Für Queue

public class Queue<T> implements IQueue<T> {

    Element first = null, last = null;

    private class Element {
        Object obj;
        Element next = null;

        Element(Object o) {
            obj = o;
        }
    }

    @Override
    public void enqueue(T t) {

        if (isEmpty()) {
            first = last = new Element(t);
        } else {
            last.next = new Element(t);
            last = last.next;

        }

    }

    @Override
    public T dequeue() {
        if ( first != null) first = first.next;
        return null;
    }

    @Override
    public T front() {
            if (first != null) first = first.next;
            return null;
    }

    @Override
    public boolean isEmpty() {

        return first == null;
    }

}

Nun, meine Frage ist, was muss ich verbessern, damit Stack und Queue funktionstüchtig sind oder ist das Obere, was ich gemacht habe, komplett falsch, dementsprechend komplett neu machen?

Ich zähle mich noch als Anfänger, Listen usw. sind auch neu für mich daher verzeihung, wenn es im falschen Thread ist. Bitte entschuldigt auch, wenn ich es wirklich komplett falsch gemacht habe. Ich versuches es wirklich zu lernen.

 

[Blender3D]

Ich gebe Dir den Stack als Beispiel da Du Ausnahmen wirfst habe ich die zum Interface hinzugefügt.

public interface IStack<T> {
    /** Adds new element to the top */
    public void push(T t) throws StackException;
    /**
     * Removes and returns the top element
     *
     * @throws StackException
     */
    public T pop() throws StackException;
    /**
     * Returns the top element without removing
     *
     * @throws StackException
     */
    public T top() throws StackException;
    /** Checks if the stack is empty */
    public boolean isEmpty();
}

@SuppressWarnings("serial")
public class StackException extends Exception {
    public StackException(String msg) {
        System.err.println("Stack " + msg);
    }
}

public class Stack<T> implements IStack<T> {
    // Attributes
    private T[] elements = null;// elements on the stack
    private int top = -1; // points to element on top

    // Constructors
    @SuppressWarnings("unchecked")
    public Stack(int size) {
        elements = ((T[]) new Object[size]);
    }
    public Stack() {
        this(100);
    }
    @Override
    public void push(T t) throws StackException {
        if (top == elements.length - 1) // full
            throw new StackException("overflow");
        elements[++top] = t;
    }
    @Override
    public T pop() throws StackException {
        if (isEmpty()) // empty stack
            throw new StackException("underfow");
        return elements[top--];
    }
    @Override
    public T top() throws StackException {
        if (isEmpty()) // empty stack
            throw new StackException("underfow");
        return elements[top];
    }
    @Override
    public boolean isEmpty() {
        return top == -1;
    }
}

 

[Ninjafighter]

Vielen Dank für die Hilfe. Hat geklappt