Question

In: Computer Science

MAKE node class outside of stack class class Stack{ private: class node{ ...

MAKE node class outside of stack class

class Stack{
   private:
       class node{
           public:
               node *next;
               int data;
               node(int d,node *n = NULL){
                   data = d;
                   next = n;
               }
       };
       node *start;

   public:
       Stack();
       Stack(const Stack& original);
       ~Stack();
      bool isEmpty() const ;
       int top() const;
      int pop() ;
       void push(int);
};

Stack::Stack(){
start = NULL;
}

Stack::Stack(const Stack& original){
   if (original.isEmpty()) {
       start = NULL;
   } else {
       node* p = original.start; // points to current node on other
       node* tmp = new node(p->data); // make a copy of the first node
       start = tmp;
       node* tail = tmp; // points to last node of this list
       while (p->next != NULL) {
           p = p->next;
           tmp = new node(p->data);
           tail->next = tmp;
           tail = tmp;
       }
   }
}

Stack::~Stack(){
   node * curr = start;
   node *next;
   while(curr!=NULL){
       next = curr->next;
       delete curr;
       curr = next;
   }
}

bool Stack::isEmpty() const{
   if(start==NULL)
       return 1;
   return 0;
}

int Stack::top() const{
   if(isEmpty())
       throw "Stack is Empty";
   return (start->data);

}

void Stack::push(int e){
   node *p = new node(e);
   if(isEmpty()){
       start = p;
   }else{
       p->next = start;
       start = p;
   }

}

int Stack::pop() {
   if(isEmpty())
       throw "Stack is Empty";
   else
   {
       node *p = start;
       start = start->next;
       int d = p->data;
       delete p;
       return d;
   }
}

/* A TEST PROGRAM */

#include<iostream>
using namespace std;

class Stack{
   private:
       class node{
           public:
               node *next;
               int data;
               node(int d,node *n = NULL){
                   data = d;
                   next = n;
               }
       };
       node *start;

   public:
       Stack();
       Stack(const Stack& original);
       ~Stack();
      bool isEmpty() const ;
       int top() const;
      int pop() ;
       void push(int);
};

Stack::Stack(){
start = NULL;
}

Stack::Stack(const Stack& original){
   if (original.isEmpty()) {
       start = NULL;
   } else {
       node* p = original.start; // points to current node on other
       node* tmp = new node(p->data); // make a copy of the first node
       start = tmp;
       node* tail = tmp; // points to last node of this list
       while (p->next != NULL) {
           p = p->next;
           tmp = new node(p->data);
           tail->next = tmp;
           tail = tmp;
       }
   }
}

Stack::~Stack(){
   node * curr = start;
   node *next;
   while(curr!=NULL){
       next = curr->next;
       delete curr;
       curr = next;
   }
}

bool Stack::isEmpty() const{
   if(start==NULL)
       return 1;
   return 0;
}

int Stack::top() const{
   if(isEmpty())
       throw "Stack is Empty";
   return (start->data);

}

void Stack::push(int e){
   node *p = new node(e);
   if(isEmpty()){
       start = p;
   }else{
       p->next = start;
       start = p;
   }

}

int Stack::pop() {
   if(isEmpty())
       throw "Stack is Empty";
   else
   {
       node *p = start;
       start = start->next;
       int d = p->data;
       delete p;
       return d;
   }
}

Expert Solution

Code: Made node class outside of stack class

#include <cstddef>

class node {
public:
   node *next;
   int data;
   node(int d, node *n = NULL) {
       data = d;
       next = n;
   }
};

class Stack {
private:
   node *start;
public:
   Stack();
   Stack(const Stack& original);
   ~Stack();
   bool isEmpty() const;
   int top() const;
   int pop();
   void push(int);
};

Stack::Stack() {
start = NULL;
}

Stack::Stack(const Stack& original) {
   if (original.isEmpty()) {
       start = NULL;
   }
   else {
       node* p = original.start; // points to current node on other
       node* tmp = new node(p->data); // make a copy of the first node
       start = tmp;
       node* tail = tmp; // points to last node of this list
       while (p->next != NULL) {
           p = p->next;
           tmp = new node(p->data);
           tail->next = tmp;
           tail = tmp;
       }
   }
}

Stack::~Stack() {
   node * curr = start;
   node *next;
   while (curr != NULL) {
       next = curr->next;
       delete curr;
       curr = next;
   }
}

bool Stack::isEmpty() const {
   if (start == NULL)
       return 1;
   return 0;
}

int Stack::top() const {
   if (isEmpty())
       throw "Stack is Empty";
   return (start->data);

}

void Stack::push(int e) {
   node *p = new node(e);
   if (isEmpty()) {
       start = p;
   }
   else {
       p->next = start;
       start = p;
   }

}

int Stack::pop() {
   if (isEmpty())
       throw "Stack is Empty";
   else
   {
       node *p = start;
       start = start->next;
       int d = p->data;
       delete p;
       return d;
   }
}

/* A TEST PROGRAM */

#include<iostream>
using namespace std;

class node {
public:
   node *next;
   int data;
   node(int d, node *n = NULL) {
       data = d;
       next = n;
   }
};

class Stack {
private:

node *start;

public:
   Stack();
   Stack(const Stack& original);
   ~Stack();
   bool isEmpty() const;
   int top() const;
   int pop();
   void push(int);
};

Stack::Stack() {
start = NULL;
}

Stack::Stack(const Stack& original) {
   if (original.isEmpty()) {
       start = NULL;
   }
   else {
       node* p = original.start; // points to current node on other
       node* tmp = new node(p->data); // make a copy of the first node
       start = tmp;
       node* tail = tmp; // points to last node of this list
       while (p->next != NULL) {
           p = p->next;
           tmp = new node(p->data);
           tail->next = tmp;
           tail = tmp;
       }
   }
}

Stack::~Stack() {
   node * curr = start;
   node *next;
   while (curr != NULL) {
       next = curr->next;
       delete curr;
       curr = next;
   }
}

bool Stack::isEmpty() const {
   if (start == NULL)
       return 1;
   return 0;
}

int Stack::top() const {
   if (isEmpty())
       throw "Stack is Empty";
   return (start->data);

}

void Stack::push(int e) {
   node *p = new node(e);
   if (isEmpty()) {
       start = p;
   }
   else {
       p->next = start;
       start = p;
   }

}

int Stack::pop() {
   if (isEmpty())
       throw "Stack is Empty";
   else
   {
       node *p = start;
       start = start->next;
       int d = p->data;
       delete p;
       return d;
   }
}

venereology answered 7 months ago

Stack Class //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Queue Class public class Stack { private java.util.ArrayList pool = new java.util.ArrayList(); pu

Stack Class //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Queue Class public class Stack { private java.util.ArrayList pool = new java.util.ArrayList(); public Stack() { } public Stack(int n) { pool.ensureCapacity(n); } public void clear() { pool.clear(); } public boolean isEmpty() { return pool.isEmpty(); } public Object topEl() { if (isEmpty()) throw new java.util.EmptyStackException(); return pool.get(pool.size()-1); } public Object pop() { if (isEmpty()) throw new java.util.EmptyStackException(); return pool.remove(pool.size()-1); } public void push(Object el) { pool.add(el); } public String toString() {...

public class SinglyLikedList { private class Node{ public int item; public...

public class SinglyLikedList { private class Node{ public int item; public Node next; public Node(int item, Node next) { this.item = item; this.next = next; } } private Node first; public void addFirst(int a) { first = new Node(a, first); } } 1. Write the method add(int item, int position), which takes an item and a position, and...

Implement a class named stack pair that provides a pair of stacks. Make the class a...

Implement a class named stack pair that provides a pair of stacks. Make the class a template class. So, you will have two files: stack pair.h and stack pair.template, following the style of the text. The basic idea is that two stacks can share a single static array. This may be advantageous if only one of the stacks will be in heavy use at any one time. • The class should have various methods to manipulate the stack: T pop...

Java program to implement circular linked list. public class CircularLinkedList { private Node tail; private int...

Java program to implement circular linked list. public class CircularLinkedList { private Node tail; private int size; public CircularLinkedList() { tail= null; size = 0; } public int size(){ return size; } public boolean isEmpty() { return size==0; } //if list is not empty return the first element public E first() { if (isEmpty()) return null; //code here return 0; } //if list not empty return last element public E last() { if (isEmpty()) return null; return tail.getElement(); } /*...

public class MyLinked { static class Node { public Node (double item, Node...

public class MyLinked { static class Node { public Node (double item, Node next) { this.item = item; this.next = next; } public double item; public Node next; } int N; Node first; // remove all occurrences of item from the list public void remove (double item) { // TODO } Write the remove function. Do NOT add any fields to the node/list classes, do...

To write a Generic Collection class for Stack<E>, using the generic Node<E> from Lab 5, and...

To write a Generic Collection class for Stack<E>, using the generic Node<E> from Lab 5, and test it using a stack of Car, Integer, and String Stack<E> For Programming Lab 6, you are to write your own Generic Collection for a Stack that will use your Node<E> from Lab 5 UML for Stack<E> Stack<E> - top : Node<E> - numElements : int + Stack( ) + push( element : E ) : void + pop( ) : E + size(...

# List the two private member variables (including name and functionality) in the node class. #Write...

# List the two private member variables (including name and functionality) in the node class. #Write a general pattern for a loop statement that traverses all the nodes of a linked list

public class ValidBST { class BSTTest<Key extends Comparable<Key>, Value> { private Node root; // root of...

public class ValidBST { class BSTTest<Key extends Comparable<Key>, Value> { private Node root; // root of BST private class Node { private Key key; // sorted by key private Value val; // associated data private Node left, right; // left and right subtrees public Node(Key key, Value val) { this.key = key; this.val = val; } } } public boolean isValidBST(BSTTest bst) { return false; } public static void main(String[] args) { } }

Laboratory Tasks public class LinkedList { Node head; class Node { &nbsp

Laboratory Tasks public class LinkedList { Node head; class Node { int data; Node next; Node(int d) { data = d; next = null; } } } Complete the above java program by adding the following methods: Part1: isEmpty() checks if the linked list is empty or not. (return type is boolean) printList() prints all data in the linked list. (void method) insertFirst(int newData) add newData at the head of the linked list. (void method) insertLasL(int newData) add newData at...

Consider a linked list whose nodes are objects of the class Node: class Node { ...

Consider a linked list whose nodes are objects of the class Node: class Node { public int data; public Node next; } prev references a node n1 in the list and curr references the node n2 that is right after n1 in the list. Which of the following statements is used to insert a new node, referenced by newNodebetween prev and curr? Group of answer choices newNode.next = curr; prev.next = newNode; newNode.next = head; head = newNode;...