StackArray stack3
Download as ppt, pdf0 likes356 views
This document discusses different implementations of a stack data structure using an array. It describes using a struct to define a StackRecord with fields for capacity, top index, and array pointer. Functions for empty, pop, and push are defined to test if the stack is empty and remove/add elements. The document also covers defining a stack element struct with a type field and union for integer, float, and string data to allow variable element types in the stack. Elements are accessed by indexing the array with the top pointer and switching on the element type field.
1 of 7
Downloaded 11 times
![Implementation of stack using
Array
Struct StackRecord
{
int Capacity;
int TopOfStack;
ElementType *Array;
}
#define STACKSIZE 100
Struct StackRecord
{ int top;
ElementType
Array[STACKSIZE];
}](https://image.slidesharecdn.com/array-stack3-150626081048-lva1-app6891/85/StackArray-stack3-1-320.jpg)
![Implementation using Array
• Pop top element from stack
int pop (stack *ps)
{ int x
if (empty (ps))
printf (“%sn”, “stack underflow!”);
else
{ x = ps → array [ps → top];
(ps → top)--;
return (x); }
}](https://image.slidesharecdn.com/array-stack3-150626081048-lva1-app6891/85/StackArray-stack3-3-320.jpg)
![Implementation using Array
• Push an element onto the stack
push (stack *ps, int x)
{ if (ps → top == STACKSIZE – 1)
printf (“%sn”, “stack overflow!”);
else
{ (ps → top)++;
ps → items [ps → top] = x;
}
}](https://image.slidesharecdn.com/array-stack3-150626081048-lva1-app6891/85/StackArray-stack3-4-320.jpg)
![Variable Types of Stack Elements
• To access the top element
struct stack s;
struct stackelement se;
se = s.items [s.top];
switch (se.etype)
{
case INTGR: printf (“%dn”, se.ival); break;
case FLT: printf (“%dn”, se.fval); break;
case STRING: printf (“%sn”, se.pval);
}](https://image.slidesharecdn.com/array-stack3-150626081048-lva1-app6891/85/StackArray-stack3-6-320.jpg)
![Variable Types of Stack Elements
• To access the top element
struct stack s;
struct stackelement se;
se = s.items [s.top];
switch (se.etype)
{
case INTGR: printf (“%dn”, se.ival); break;
case FLT: printf (“%dn”, se.fval); break;
case STRING: printf (“%sn”, se.pval);
}](https://image.slidesharecdn.com/array-stack3-150626081048-lva1-app6891/85/StackArray-stack3-7-320.jpg)
Ad
Recommended
Stack using Array
Stack using ArraySayantan Sur This document describes an implementation of a stack using an array in C. It includes functions to push elements onto the stack, pop elements off the stack, and display the elements currently in the stack. The main module contains a menu that allows the user to choose these stack operations and includes error handling for invalid inputs or overflow/underflow of the stack.
Stack using Linked List
Stack using Linked ListSayantan Sur This document describes an implementation of a stack data structure using a single linked list in C. It includes functions to push elements onto the stack, pop elements off the stack, and display the elements currently in the stack. The main function contains a menu loop that calls these functions based on user input and exits when the user selects option 4.
week-15x
week-15xKITE www.kitecolleges.com This document contains C code to implement a stack using arrays and pointers. It defines functions for push, pop, and display operations on the stack. The main function provides a menu for testing these stack operations and switches between the array and pointer implementations. The push function inserts elements into the stack, pop removes and returns elements, and display prints out the current stack contents.
Array menu
Array menuSayantan Sur This document presents a menu-driven C program that allows the user to perform operations on a dynamic integer array, including insertion, deletion, and display. The main function contains a switch menu with the array options. Functions are defined to insert elements into the array at a given position, delete elements from a specified position, and display the current array contents. The program uses global variables to track the array size and currently stored elements.
Array list
Array listcvr college of engineering This document defines functions to implement an array-based list data structure with options to insert elements at the beginning, end, or middle of the list, display the list, delete elements, and search for elements. The main function uses a switch statement to prompt the user for an operation and call the corresponding function. Functions are defined to insert elements in different positions, display the list, delete elements by value, and search for elements by value.
week-4x
week-4xKITE www.kitecolleges.com This document contains C code examples that demonstrate both recursive and non-recursive solutions to common problems:
1) Towers of Hanoi problem using recursive and non-recursive functions.
2) Finding the greatest common divisor (GCD) of two integers using recursive and non-recursive functions.
3) Calculating the factorial of a given integer using recursive and non-recursive functions.
C program to implement linked list using array abstract data type
C program to implement linked list using array abstract data typeloyola ICAM college of engineering and technology This document contains C code to implement a linked list and array-based list data structure (ADT). It includes functions to create, insert, delete, search and display elements in the list. For the linked list implementation, nodes containing data and pointer to next node are used. Functions like create, insert, delete manipulate the pointers to manage the list. The array implementation uses an array to store elements and tracks the number of elements. Functions perform similar operations of adding, removing and searching elements in the array representing the list.
week-11x
week-11xKITE www.kitecolleges.com This C program uses functions to perform operations on complex numbers represented as a structure with real and imaginary parts. It takes user input for two complex numbers, performs either addition or multiplication based on the user's selection, and displays the result. The main menu allows the user to choose addition or multiplication and calls the arithmetic function accordingly, which contains the code to perform the operation and display the output.
Avl tree
Avl treeloyola ICAM college of engineering and technology This document describes an implementation of an AVL tree in C. It includes functions to insert nodes, search for nodes, and display the tree. The insert function recursively adds nodes, performs rotations to balance the tree if needed, and tracks the tree height. It uses pointers to dynamically allocate memory for nodes and restructures the tree during rotations to maintain the AVL tree balance property.
week-16x
week-16xKITE www.kitecolleges.com The document discusses the implementation of queue operations using pointers and arrays in C. It defines the queue data structure using a struct containing a data element and pointer to the next node. Functions are defined to add, remove and check for empty/full as well as display the queue elements. A similar implementation is shown using arrays instead of pointers by defining a queue struct containing the front, rear indexes and size.
DS- Stack ADT
DS- Stack ADTMythiliMurugan3 The document defines and describes a stack data structure. A stack follows LIFO (last in, first out) and FILO (first in, last out) principles. Elements can be inserted using push and deleted using pop. Stacks have only one end for insertion/deletion and can be implemented using arrays or linked lists. The document provides code examples to implement stacks using arrays and linked lists and describes some applications of stacks like evaluating expressions and balancing symbols.
Final ds record
Final ds recordGanisius Ganish The program implements operations on a stack using an array. It includes functions for push(), pop(), and display(). Push inserts an element into the stack if not full. Pop removes an element if not empty. Display prints the stack elements using a for loop. The main() uses a switch case to call the functions based on user input until exit is chosen.
week-1x
week-1xKITE www.kitecolleges.com The document contains code for three C programs:
1) A program to generate the first n terms of the Fibonacci sequence, where the sequence is defined as starting with 0, 1, and each subsequent term is the sum of the previous two terms.
2) A program that takes user input for a number n and prints all prime numbers between 1 and n by checking if each number is divisible by numbers between 1 and itself.
3) A program that takes a positive integer as input, calculates the sum of its individual digits by repeatedly taking the remainder and quotient of the number divided by 10, and prints the final sum.
week-18x
week-18xKITE www.kitecolleges.com This C program uses stack operations to convert infix expressions to postfix expressions and then evaluate the postfix expression. It defines functions to push and pop items from a stack, determine operator precedence, convert an infix expression to postfix, and evaluate a postfix expression by performing operations. The main function gets an infix expression from the user and calls the necessary functions to convert it to postfix and evaluate the result if desired.
week-10x
week-10xKITE www.kitecolleges.com The C program takes a binary number as input, finds its 2's complement by scanning from right to left and complementing all bits after the first 1, and prints the 2's complement as output. It first checks that the input is a valid binary number, then calls a complement() function that reverses the string, complements each bit, and handles carrying for adjacent bits.
Qprgs
QprgsSsankett Negi 1) This document contains 3 C programs that implement different types of queues using arrays: a standard queue, a circular queue, and a multiple queue system.
2) The programs define functions for insertion, deletion, checking if the queue is full/empty, and displaying the contents.
3) Main contains a menu to test the different queue functions and take user input for operations.
week-17x
week-17xKITE www.kitecolleges.com This C program uses stack operations to perform two tasks: 1) Convert an infix expression to a postfix expression by pushing and popping operators and operands to a stack. 2) Evaluate the postfix expression by pushing operands, popping operands and operators, and performing operations. It includes functions to push and pop from the stack, determine operator precedence, convert expressions, and evaluate the postfix form.
week-6x
week-6xKITE www.kitecolleges.com The document contains code for three C programs that use functions:
1) A program to delete n characters from a given position in a string using a delchar function.
2) A program to check if a string is a palindrome using an IsPalindrome function.
3) A program to insert a substring into a main string at a given position using functions.
2 3. standard io
2 3. standard io웅식 전 The document discusses the standard input/output functions printf() and scanf() in C programming. printf() is used to print output to the monitor and allows formatting of output using conversion characters like %d for integers and %f for floating point numbers. scanf() reads input from standard input using similar conversion characters. Examples are given to demonstrate printing integers and floating point numbers with various width and precision specifications, as well as a basic program using scanf() to read user input.
Stack Data Structure
Stack Data StructureEr. Ganesh Ram Suwal This document contains the code for a C program that implements a stack using an array. It defines functions for push, pop, and display operations on the stack. The main function runs a menu loop that calls these functions based on the user's input choice and handles errors like overflow and underflow.
Circular linked list
Circular linked listSayantan Sur This document describes a menu driven C program that implements operations on a circular linked list. The main menu allows the user to perform operations like create, display, insert, delete, count, sort, and reverse the circular linked list. Functions are defined to implement each operation - such as the create() function allocates a new node, the display() function prints the list, and insert functions add a node to the beginning, middle or end of the list.
Single linked list
Single linked listSayantan Sur This document describes functions for a menu-driven C program that implements a single linked list. The main menu allows the user to create nodes, display the list, insert nodes, count nodes, delete nodes, sort nodes, reverse the list, and find nodes. Functions are provided to implement each operation, including creating and linking new nodes, traversing the list, and freeing deleted nodes.
01 list using array
01 list using arraySivakamiRaja1 The document describes a C program that implements a list ADT using an array. It includes functions for creating a list, inserting elements, deleting elements, searching for elements, and displaying the list. The main function uses a menu to allow the user to select an operation and call the appropriate function to perform that operation on the list.
Stack concepts by Divya
Stack concepts by DivyaDivya Kumari This document discusses the stack data structure and its operations. It defines a stack as a Last In First Out (LIFO) data structure. The main stack operations are push, which inserts an element into the stack, and pop, which removes an element from the stack. It also discusses using a stack to check for matching parentheses during program parsing. The document then provides implementations of stacks using both arrays and linked lists in C, demonstrating how to perform push and pop operations on each.
Recursion concepts by Divya
Recursion concepts by DivyaDivya Kumari Recursion is a process of solving a problem where the solution depends on solutions to smaller instances of the same problem. Some examples that use recursion include calculating factorials, generating Fibonacci numbers, reversing a linked list, and traversing trees. A recursive function calls itself directly or indirectly. To terminate the recursion, a base case is used. The memory for each function call is allocated on the stack, with each recursive call using new memory on top of the previous call. When the base case is reached, the function returns values up the call stack and memory is de-allocated.
Double linked list
Double linked listSayantan Sur This document describes a menu-driven C program that implements a doubly linked list. The program allows the user to perform operations like creation, insertion, deletion, sorting, and searching of nodes in the doubly linked list. The main functions include create() to create nodes, display() to print the list, insert() to add nodes at different positions, delete() to remove nodes, sort() to sort the list, and find() to search for a node. The program uses a menu to allow the user to select the desired operation on the doubly linked list.
Bcsl 033 data and file structures lab s5-3
Bcsl 033 data and file structures lab s5-3Dr. Loganathan R This C program defines functions to add numbers to a queue and display the numbers in reverse order. The add() function takes user input of up to 5 numbers and stores them in an array. The display() function prints the numbers from the end of the array to the beginning to reverse the order, with front and rear pointers used to track the start and end of the queue. The main() function calls add() to populate the queue, then calls display() to print the numbers in reversed order.
Bcsl 033 data and file structures lab s3-3
Bcsl 033 data and file structures lab s3-3Dr. Loganathan R This C program accepts a singly linked list of integers as input, sorts the elements in ascending order, then accepts an integer to insert into the sorted list at the appropriate position. It includes functions to create and display the linked list, sort the elements, and insert a new element while maintaining the sorted order.
Stacks
StacksSadaf Ismail The document discusses stacks and their implementation using linked lists. It defines a stack as a last-in, first-out data structure that allows insertion and deletion of elements only at one end, called the top. Key stack operations like push, pop and peek are described along with their algorithms. Linked list and array implementations of stacks are presented. Common applications of stacks like balancing symbols, postfix notation calculators, and infix to postfix conversion are also covered.
More Related Content
What's hot (20)
Avl tree
Avl treeloyola ICAM college of engineering and technology This document describes an implementation of an AVL tree in C. It includes functions to insert nodes, search for nodes, and display the tree. The insert function recursively adds nodes, performs rotations to balance the tree if needed, and tracks the tree height. It uses pointers to dynamically allocate memory for nodes and restructures the tree during rotations to maintain the AVL tree balance property.
week-16x
week-16xKITE www.kitecolleges.com The document discusses the implementation of queue operations using pointers and arrays in C. It defines the queue data structure using a struct containing a data element and pointer to the next node. Functions are defined to add, remove and check for empty/full as well as display the queue elements. A similar implementation is shown using arrays instead of pointers by defining a queue struct containing the front, rear indexes and size.
DS- Stack ADT
DS- Stack ADTMythiliMurugan3 The document defines and describes a stack data structure. A stack follows LIFO (last in, first out) and FILO (first in, last out) principles. Elements can be inserted using push and deleted using pop. Stacks have only one end for insertion/deletion and can be implemented using arrays or linked lists. The document provides code examples to implement stacks using arrays and linked lists and describes some applications of stacks like evaluating expressions and balancing symbols.
Final ds record
Final ds recordGanisius Ganish The program implements operations on a stack using an array. It includes functions for push(), pop(), and display(). Push inserts an element into the stack if not full. Pop removes an element if not empty. Display prints the stack elements using a for loop. The main() uses a switch case to call the functions based on user input until exit is chosen.
week-1x
week-1xKITE www.kitecolleges.com The document contains code for three C programs:
1) A program to generate the first n terms of the Fibonacci sequence, where the sequence is defined as starting with 0, 1, and each subsequent term is the sum of the previous two terms.
2) A program that takes user input for a number n and prints all prime numbers between 1 and n by checking if each number is divisible by numbers between 1 and itself.
3) A program that takes a positive integer as input, calculates the sum of its individual digits by repeatedly taking the remainder and quotient of the number divided by 10, and prints the final sum.
week-18x
week-18xKITE www.kitecolleges.com This C program uses stack operations to convert infix expressions to postfix expressions and then evaluate the postfix expression. It defines functions to push and pop items from a stack, determine operator precedence, convert an infix expression to postfix, and evaluate a postfix expression by performing operations. The main function gets an infix expression from the user and calls the necessary functions to convert it to postfix and evaluate the result if desired.
week-10x
week-10xKITE www.kitecolleges.com The C program takes a binary number as input, finds its 2's complement by scanning from right to left and complementing all bits after the first 1, and prints the 2's complement as output. It first checks that the input is a valid binary number, then calls a complement() function that reverses the string, complements each bit, and handles carrying for adjacent bits.
Qprgs
QprgsSsankett Negi 1) This document contains 3 C programs that implement different types of queues using arrays: a standard queue, a circular queue, and a multiple queue system.
2) The programs define functions for insertion, deletion, checking if the queue is full/empty, and displaying the contents.
3) Main contains a menu to test the different queue functions and take user input for operations.
week-17x
week-17xKITE www.kitecolleges.com This C program uses stack operations to perform two tasks: 1) Convert an infix expression to a postfix expression by pushing and popping operators and operands to a stack. 2) Evaluate the postfix expression by pushing operands, popping operands and operators, and performing operations. It includes functions to push and pop from the stack, determine operator precedence, convert expressions, and evaluate the postfix form.
week-6x
week-6xKITE www.kitecolleges.com The document contains code for three C programs that use functions:
1) A program to delete n characters from a given position in a string using a delchar function.
2) A program to check if a string is a palindrome using an IsPalindrome function.
3) A program to insert a substring into a main string at a given position using functions.
2 3. standard io
2 3. standard io웅식 전 The document discusses the standard input/output functions printf() and scanf() in C programming. printf() is used to print output to the monitor and allows formatting of output using conversion characters like %d for integers and %f for floating point numbers. scanf() reads input from standard input using similar conversion characters. Examples are given to demonstrate printing integers and floating point numbers with various width and precision specifications, as well as a basic program using scanf() to read user input.
Stack Data Structure
Stack Data StructureEr. Ganesh Ram Suwal This document contains the code for a C program that implements a stack using an array. It defines functions for push, pop, and display operations on the stack. The main function runs a menu loop that calls these functions based on the user's input choice and handles errors like overflow and underflow.
Circular linked list
Circular linked listSayantan Sur This document describes a menu driven C program that implements operations on a circular linked list. The main menu allows the user to perform operations like create, display, insert, delete, count, sort, and reverse the circular linked list. Functions are defined to implement each operation - such as the create() function allocates a new node, the display() function prints the list, and insert functions add a node to the beginning, middle or end of the list.
Single linked list
Single linked listSayantan Sur This document describes functions for a menu-driven C program that implements a single linked list. The main menu allows the user to create nodes, display the list, insert nodes, count nodes, delete nodes, sort nodes, reverse the list, and find nodes. Functions are provided to implement each operation, including creating and linking new nodes, traversing the list, and freeing deleted nodes.
01 list using array
01 list using arraySivakamiRaja1 The document describes a C program that implements a list ADT using an array. It includes functions for creating a list, inserting elements, deleting elements, searching for elements, and displaying the list. The main function uses a menu to allow the user to select an operation and call the appropriate function to perform that operation on the list.
Stack concepts by Divya
Stack concepts by DivyaDivya Kumari This document discusses the stack data structure and its operations. It defines a stack as a Last In First Out (LIFO) data structure. The main stack operations are push, which inserts an element into the stack, and pop, which removes an element from the stack. It also discusses using a stack to check for matching parentheses during program parsing. The document then provides implementations of stacks using both arrays and linked lists in C, demonstrating how to perform push and pop operations on each.
Recursion concepts by Divya
Recursion concepts by DivyaDivya Kumari Recursion is a process of solving a problem where the solution depends on solutions to smaller instances of the same problem. Some examples that use recursion include calculating factorials, generating Fibonacci numbers, reversing a linked list, and traversing trees. A recursive function calls itself directly or indirectly. To terminate the recursion, a base case is used. The memory for each function call is allocated on the stack, with each recursive call using new memory on top of the previous call. When the base case is reached, the function returns values up the call stack and memory is de-allocated.
Double linked list
Double linked listSayantan Sur This document describes a menu-driven C program that implements a doubly linked list. The program allows the user to perform operations like creation, insertion, deletion, sorting, and searching of nodes in the doubly linked list. The main functions include create() to create nodes, display() to print the list, insert() to add nodes at different positions, delete() to remove nodes, sort() to sort the list, and find() to search for a node. The program uses a menu to allow the user to select the desired operation on the doubly linked list.
Bcsl 033 data and file structures lab s5-3
Bcsl 033 data and file structures lab s5-3Dr. Loganathan R This C program defines functions to add numbers to a queue and display the numbers in reverse order. The add() function takes user input of up to 5 numbers and stores them in an array. The display() function prints the numbers from the end of the array to the beginning to reverse the order, with front and rear pointers used to track the start and end of the queue. The main() function calls add() to populate the queue, then calls display() to print the numbers in reversed order.
Bcsl 033 data and file structures lab s3-3
Bcsl 033 data and file structures lab s3-3Dr. Loganathan R This C program accepts a singly linked list of integers as input, sorts the elements in ascending order, then accepts an integer to insert into the sorted list at the appropriate position. It includes functions to create and display the linked list, sort the elements, and insert a new element while maintaining the sorted order.
Similar to StackArray stack3 (20)
Stacks
StacksSadaf Ismail The document discusses stacks and their implementation using linked lists. It defines a stack as a last-in, first-out data structure that allows insertion and deletion of elements only at one end, called the top. Key stack operations like push, pop and peek are described along with their algorithms. Linked list and array implementations of stacks are presented. Common applications of stacks like balancing symbols, postfix notation calculators, and infix to postfix conversion are also covered.
Stack and queue
Stack and queueKatang Isip Stack and Queue data structures are described. A Stack follows LIFO (last-in, first-out) where elements can only be inserted and removed from one end. Common stack operations are push, pop, and peek. A Queue follows FIFO (first-in, first-out) where elements can only be inserted at the rear and removed from the front. Common queue operations are enqueue and dequeue. Both can be implemented using arrays or linked lists. A circular array implementation improves the efficiency of dequeuing from a queue.
Project of data structure
Project of data structureUmme habiba The document discusses various applications of stacks including:
1) Reversing strings by pushing characters onto a stack and popping them off in reverse order.
2) Calculator operations using postfix notation and a stack.
3) Recursive functions using a stack to store previous function calls and variables.
4) Determining if a word is a palindrome by pushing characters onto a stack and comparing to the popped off characters.
Code examples are provided for reversing strings, recursive summation, and determining palindromes using stacks.
please tell me what lines do i alter to make this stack a queue. tel.pdf
please tell me what lines do i alter to make this stack a queue. tel.pdfagarshailenterprises please tell me what lines do i alter to make this stack a queue. tell me what to change it to
#include
using namespace std;
const int MAXSIZE = 100; // Maximum size of the stack
class Stack {
private:
int top; // Index of the top element in the stack
int data[MAXSIZE]; // Array to hold the stack elements
public:
Stack () {
top = -1; // Initialize the top index to -1 to indicate an empty stack
}
bool push (int val) {
if (top == MAXSIZE - 1) { // Stack is full
return false;
}
top++; // Increment the top index
data[top] = val; // Add the new element to the top of the stack
return true;
}
bool pop() {
if (top == -1) { // Stack is empty
return false;
}
top--; // Decrement the top index to remove the top element
return true;
}
bool peek(int& val) {
if (top == -1) { // Stack is empty
return false;
}
val = data[top]; // Return the top element without removing it.
return true;
}
void display(ostream& out) {
if (top == -1) { // Stack is empty
out << "Empty stack" << endl;
return;
}
for (int i = top; i >= 0; i--) { // Loop through the stack elements from top to bottom
out << data[i] << "";
}
out << endl;
}
};
int main() {
Stack S;
int tmp;
S.push (5);
S. peek (tmp);
cout << tmp << endl;
S.push (33);
S.push (1);
S.push (7);
S.peek (tmp);
cout << tmp << endl;
S.push (33) ;
S.push (12);
S.display ( cout );
S.pop ( );
S.display ( cout );
S.push (14);
S.display ( cout );
S.pop ( ) ;
S.pop ( );
S.display ( cout );
S.pop ( );
S. pop ( ) ;
S.display ( cout );
S.peek (tmp);
cout << tmp << endl;
}
#include
using namespace std;
const int MAXSIZE = 100; // Maximum size of the stack
class Stack {
private:
int top; // Index of the top element in the stack
int data[MAXSIZE]; // Array to hold the stack elements
public:
Stack () {
top = -1; // Initialize the top index to -1 to indicate an empty stack
}
bool push (int val) {
if (top == MAXSIZE - 1) { // Stack is full
return false;
}
top++; // Increment the top index
data[top] = val; // Add the new element to the top of the stack
return true;
}
bool pop() {
if (top == -1) { // Stack is empty
return false;
}
top--; // Decrement the top index to remove the top element
return true;
}
bool peek(int& val) {
if (top == -1) { // Stack is empty
return false;
}
val = data[top]; // Return the top element without removing it.
return true;
}
void display(ostream& out) {
if (top == -1) { // Stack is empty
out << "Empty stack" << endl;
return;
}
for (int i = top; i >= 0; i--) { // Loop through the stack elements from top to bottom
out << data[i] << "";
}
out << endl;
}
};
int main() {
Stack S;
int tmp;
S.push (5);
S. peek (tmp);
cout << tmp << endl;
S.push (33);
S.push (1);
S.push (7);
S.peek (tmp);
cout << tmp << endl;
S.push (33) ;
S.push (12);
S.display ( cout );
S.pop ( );
S.display ( cout );
S.push (14);
S.display ( cout );
S.pop ( ) ;
S.pop ( );
S.display ( cout );
S.pop ( );
S. pop ( ) ;
S.display ( cout );
S.peek (tmp);
cout << tmp << endl;
}
#include
using namespace std;
const int MAXSIZE = 100; // Maximum size of the stack
cl.
Stack,queue and linked list data structure.pptx
Stack,queue and linked list data structure.pptxyukti266975 Presentation gives brief overview of various operations on data structures
Implement the ADT stack by using an array stack to contain its entri.pdf
Implement the ADT stack by using an array stack to contain its entri.pdfSIGMATAX1 Implement the ADT stack by using an array stack to contain its entries. Expand the array
dynamically, as necessary. Maintain the stack’s bottom entry in stack[stack.length – 1].
Your Stack class must implement StackInterface (provided). You may use ArrayStack.java
(provided) as the starting point for your implementation.
You must implement a comprehensive set of unit tests using the main() method (and private
utility methods) in ArrayStack.java.
ArrayStack.java
public class ArrayStack implements StackInterface
{
private T[] stack; // Array of stack entries
private int topIndex; // Index of top entry
private boolean initialized = false;
private static final int DEFAULT_CAPACITY = 50;
private static final int MAX_CAPACITY = 10000;
public ArrayStack()
{
this(DEFAULT_CAPACITY);
} // end default constructor
public ArrayStack(int initialCapacity)
{
checkCapacity(initialCapacity);
// The cast is safe because the new array contains null entries
@SuppressWarnings(\"unchecked\")
T[] tempStack = (T[])new Object[initialCapacity];
stack = tempStack;
topIndex = -1;
initialized = true;
} // end constructor
// < Implementations of the stack operations go here. >
// < Implementations of the private methods go here; checkCapacity and
// checkInitialization are analogous to those in Chapter 2. >
// . . .
} // end ArrayStack
StackInterface.java
public interface StackInterface
{
/** Adds a new entry to the top of this stack.
@param newEntry An object to be added to the stack. */
public void push(T newEntry);
/** Removes and returns this stack\'s top entry.
@return The object at the top of the stack.
@throws EmptyStackException if the stack is empty before the operation. */
public T pop();
/** Retrieves this stack\'s top entry.
@return The object at the top of the stack.
@throws EmptyStackException if the stack is empty. */
public T peek();
/** Detects whether this stack is empty.
@return True if the stack is empty. */
public boolean isEmpty();
/** Removes all entries from this stack. */
public void clear();
} // end StackInterface
Solution
StackTester.java
public class StackTester
{
public static void main(String[] args)
{
ArrayStack aS = new ArrayStack();
aS.push(3);
aS.push(5);
aS.push(10);
aS.push(11);
System.out.println(\"\"+ aS.peek() + \", \" + aS.pop() + \", \" + aS.peek2());
aS.remove(1);
}
}
ArrayStack.java
import java.util.Arrays;
public class ArrayStack implements StackInterface
{
private T[] stack;
private int topIndex;
private boolean initialized = false;
private static final int DEFAULT_CAPACITY = 50;
private static final int MAX_CAPACITY = 10000;
public ArrayStack()
{
this(DEFAULT_CAPACITY);
}
public ArrayStack(int initialCapacity)
{
checkCapacity(initialCapacity);
@SuppressWarnings(\"unchecked\")
T[] tempStack = (T[])new Object[initialCapacity];
stack = tempStack;
topIndex = -1;
initialized = true;
}
public boolean isEmpty()
{
return topIndex < 0;
}
private void ensureCapacity()
{
if(topIndex == stack.length - 1)
{
int newLength = 2*stack.length;
.
Data Structure.pptx
Data Structure.pptxSajalFayyaz Hi everyone i hope you will be fine plz support me i hope you well statisfied with this slide and course.
Data Structures and Agorithm: DS 06 Stack.pptx
Data Structures and Agorithm: DS 06 Stack.pptxRashidFaridChishti Data Structures and Agorithm: DS 06 Stack.pptx
stack (1).pptx
stack (1).pptxCrazyKiller4 The document discusses stacks and their implementation and applications. It begins by defining a stack as a data structure that follows the LIFO (last in, first out) principle. It then describes the basic stack operations of push, pop, peek, and initialization. It provides algorithms to implement these operations using an array. Several applications of stacks are covered, including converting numbers between different bases, reversing strings, checking for palindromes, and evaluating postfix/prefix expressions. The document also discusses converting infix expressions to postfix notation using an operator stack. Overall, the document provides a comprehensive introduction to stacks, their implementation, and common uses.
Stack
StackAmrutha Rajan The document discusses stacks, which are linear data structures that follow the LIFO (last in, first out) principle. Elements are inserted and removed from only one end, called the top. Common stack operations are PUSH, which inserts an element at the top, and POP, which removes the top element. Stacks can be implemented using arrays or linked lists. Stacks have applications in recursion, expression evaluation, and showing operator precedence. Recursion uses stacks to call nested functions, with stack frames allowing data to come out in the correct order as frames are popped.
Please review my code (java)Someone helped me with it but i cannot.pdf
Please review my code (java)Someone helped me with it but i cannot.pdffathimafancyjeweller Please make it to clear 12-95. The basketball passed through the hoop even though it barely
cleared the hands of the player B who attempted to block it. Neglecting the size of the ball,
determine the magnitude vn of its initial velocity and the height h of the ball when it passes over
player B 10 ft 5 ft Prob. 12-95
Solution
Consider the motion along horizontal direction
Vox = initial velocity in horizontal direction = Va Cos30
X = horizontal distance = 25 + 3 = 28 ft
t = time taken
t = X / Vox = 28/(Va Cos30) eq-1
consider the motion in vertical direction
Y = vertical displacement = 10 - 7 = 3 ft
a = acceleration = - 32.2
Voy = initial velocity = Va Sin30
t = time taken
using the equation
Y = Voy t + (0.5) a t2
3 = (Va Sin30) (28/(Va Cos30)) + (0.5) (- 32.2) (28/(Va Cos30))2
Va = 35.8 m/s
t\' = time taken to reach B = 25 / (Va Cos30) = 25 / (35.8 Cos30) = 0.81 sec
h = 7 + Voy t\' + (0.5) a t\'2
h = 7 + (35.8 Sin30) (0.81) + (0.5) (- 32.2) (0.81)2
h = 10.94 ft.
03 stacks and_queues_using_arrays
03 stacks and_queues_using_arraystameemyousaf The document discusses stacks and their implementation and applications. Stacks are LIFO data structures that can be implemented using arrays. Key operations on stacks include push, pop, peek, isEmpty and isFull. Stacks have various applications including expression evaluation, recursion, function calls and memory management. Stacks can grow either upwards or downwards in the array.
Unit 3 stack
Unit 3 stackDabbal Singh Mahara This is course material for computer science and information technology for BSc csit TU, Kathmandu, Nepal.
Datastructures asignment
Datastructures asignmentsreekanth3dce The document discusses implementation of linked lists in C programming language. It includes functions to create, insert, delete and display nodes in a linked list. The functions demonstrated are to insert nodes at the beginning, end or after a particular node. It also includes functions to delete nodes from the beginning, end or anywhere in the list. The main function uses a switch case to call these functions and operate on a linked list based on user input.
Stack and Queue.pptx university exam preparation
Stack and Queue.pptx university exam preparationRAtna29 Queues and stacks are dynamic while arrays are static. So when we require dynamic memory we use queue or stack over arrays. Stacks and queues are used over arrays when sequential access is required. To efficiently remove any data from the start (queue) or the end (stack) of a data structure
Data Structure Lecture 2
Data Structure Lecture 2Teksify The document discusses stacks as a linear data structure where elements are added and removed based on a last-in, first-out principle. It covers stack operations like push, pop, and peek, and provides examples of implementing a stack using arrays with functions for adding and removing elements. Applications of stacks mentioned include reversing the order of characters in a string by pushing them onto a stack and then popping them off.
Stack linked list
Stack linked listbhargav0077 The document discusses different implementations of stacks and queues using linked lists and arrays. It describes how stacks can be implemented using a linked list, with push and pop operations adding and removing nodes from the head of the list. Queues can also be implemented with linked lists or arrays, but arrays require additional logic to maintain first-in, first-out order efficiently. Common applications of stacks and queues include evaluating expressions, checking for balanced brackets, and managing tasks in operating systems and server requests.
Ad
More from Rajendran (20)
Element distinctness lower bounds
Element distinctness lower boundsRajendran The document provides an overview of a lecture on proving a lower time bound of Ω(n log n) for the element distinctness problem in the decision tree model. It begins by defining the element distinctness problem and stating the lower bound that will be proved. It then discusses interpreting the input sequence as coordinates of an n-dimensional point and restricting points to the unit n-cube. The key claims are that each leaf region is connected, and distinct input points must reach distinct leaves, implying there are at least n! leaves and a time lower bound of n log n.
Scheduling with Startup and Holding Costs
Scheduling with Startup and Holding CostsRajendran This document summarizes a lecture on scheduling problems with startup and holding costs. The problem involves scheduling production on a machine over multiple days to meet demand, while minimizing costs. Costs include a startup cost each time the machine is turned on, and a holding cost each day inventory is stored. The lecture defines the problem formally, provides an example, and discusses using dynamic programming to find an optimal schedule efficiently through characterizing subproblems and storing results in a table.
Divide and conquer surfing lower bounds
Divide and conquer surfing lower boundsRajendran The document discusses lower bounds for sorting algorithms. It shows that the worst case and average case lower bounds for sorting are both Ω(n log n). This lower bound is derived by analyzing the minimum depth of balanced binary decision trees required to represent the n! possible permutations of n elements. Several algorithms, including heapsort, are shown to achieve the optimal time complexity of O(n log n), matching this lower bound. Problem transformations are also introduced as a method for proving lower bounds.
Red black tree
Red black treeRajendran The document discusses red-black trees, which are binary search trees augmented with node colors to guarantee a height of O(log n). It first defines the properties of red-black trees, then proves their height is O(log n), and finally describes insertion and deletion operations. The key points are that nodes can be red or black, insertion can violate properties so recoloring is needed, and rotations are used to restructure the tree during insertion and deletion while maintaining the red-black properties.
Hash table
Hash tableRajendran This document discusses hashing techniques for implementing symbol tables. It begins by reviewing the motivation for symbol tables in compilers and describing the basic operations of search, insertion and deletion that a hash table aims to support efficiently. It then discusses direct addressing and its limitations when key ranges are large. The concept of a hash function is introduced to map keys to a smaller range to enable direct addressing. Collision resolution techniques of chaining and open addressing are covered. Analysis of expected costs for different operations on chaining hash tables is provided. Various hash functions are described including division and multiplication methods, and the importance of choosing a hash function to distribute keys uniformly is discussed. The document concludes by mentioning universal hashing as a technique to randomize the hash function
Medians and order statistics
Medians and order statisticsRajendran The document discusses algorithms for finding order statistics like the median in a list of numbers. It presents a randomized selection algorithm that finds the ith smallest element in expected linear time O(n) by using a randomized partition like in quicksort. It also describes a deterministic selection algorithm that finds the ith element in worst-case linear time O(n) by partitioning the list around the median of medians. Finding the median can then be used to sort in linear time by recursively finding order statistics.
Proof master theorem
Proof master theoremRajendran 1) The document provides the proof of the Master Theorem for analyzing divide-and-conquer recurrences.
2) It introduces key lemmas used in the proof, including bounding the contribution of subproblem sizes.
3) The proof considers three cases depending on how the work at each level relates to the decrease in problem size, showing the recurrence has a runtime of O(nlogba), O(nklogn), or O(nk) respectively.
Recursion tree method
Recursion tree methodRajendran - Recurrences describe functions in terms of their values on smaller inputs and arise when algorithms contain recursive calls to themselves.
- To analyze the running time of recursive algorithms, the recurrence must be solved to find an explicit formula or bound the expression in terms of n.
- Examples of recurrences and their solutions are given, including binary search (O(log n)), dividing the input in half at each step (O(n)), and dividing the input in half but examining all items (O(n)).
- Methods for solving recurrences include iteration, substitution, and using recursion trees to "guess" the solution.
Recurrence theorem
Recurrence theoremRajendran The document discusses different methods for analyzing recursive functions, including:
1. The recursion-tree method, which represents each subproblem as a node with costs summed at each level and total. This is suitable for divide-and-conquer recurrences.
2. An example of using the recursion-tree method to solve T(n)=3T(n/4)+Θ(n^2), showing the tree has height log4n, Θ(nlog43) leaf nodes each costing T(1), and total cost O(n^2).
3. Another example of T(n)=T(n/3)+T(2n/3)+O(n
Master method 
Master method Rajendran This document discusses recurrences and algorithms analysis. It covers:
1. Recurrences arise when an algorithm contains recursive calls to itself. The running time is described by a recurrence relation.
2. Examples of recurrence relations are given for different types of recursive algorithms.
3. The binary search algorithm is presented as an example recursive algorithm and its recurrence relation is derived.
Master method theorem
Master method theoremRajendran The document discusses recurrences and the master theorem for finding asymptotic bounds of recursive equations. It introduces the substitution method, recursive tree method, and master theorem. The master theorem provides bounds for recurrences of the form T(n) = aT(n/b) + f(n) based on comparing f(n) to nlogba. It also discusses exceptions, gaps in the theorem, and proofs of the main results.
Hash tables
Hash tablesRajendran The document discusses hash tables and how they can be used to implement dictionaries. Hash tables map keys to table slots using a hash function in order to store and retrieve items efficiently. Collisions may occur when multiple keys hash to the same slot. Chaining is described as a method to handle collisions by storing colliding items in linked lists attached to table slots. Analysis shows that with simple uniform hashing, dictionary operations like search, insert and delete take expected O(1) time on average.
Lower bound
Lower boundRajendran This chapter discusses limitations on algorithmic power and methods for establishing lower bounds on algorithms. It introduces lower bounds as estimates of the minimum amount of work needed to solve a problem. Several methods are presented for establishing lower bounds, including trivial lower bounds based on input/output sizes, decision trees to model comparisons, adversary arguments, and reducing one problem to another with a known lower bound. Examples are given for sorting, searching, and matrix multiplication.
Master method theorem
Master method theoremRajendran The document discusses recurrences and the master theorem for finding asymptotic bounds of recursive equations. It covers the substitution method, recursive tree method, and master theorem. The master theorem provides bounds for recurrences of the form T(n) = aT(n/b) + f(n) based on comparing f(n) to nlogba. It also discusses exceptions, gaps in the theorem, and proofs of the main results.
Greedy algorithms
Greedy algorithmsRajendran This document discusses greedy algorithms and dynamic programming techniques for solving optimization problems. It covers the activity selection problem, which can be solved greedily by always selecting the shortest remaining activity. It also discusses the knapsack problem and how the fractional version can be solved greedily while the 0-1 version requires dynamic programming due to its optimal substructure but non-greedy nature. Dynamic programming builds up solutions by combining optimal solutions to overlapping subproblems.
Longest common subsequences in Algorithm Analysis
Longest common subsequences in Algorithm AnalysisRajendran The document discusses dynamic programming and the longest common subsequence (LCS) problem. It provides an example of using dynamic programming to find the LCS of two strings "ABCB" and "BDCAB" in multiple steps. The algorithm builds up the solution by filling a 2D array c[m,n] where m and n are the lengths of the two strings. Each entry c[i,j] represents the length of the LCS of the prefixes of length i and j of the two strings. The running time is O(mn).
Dynamic programming in Algorithm Analysis
Dynamic programming in Algorithm AnalysisRajendran The document discusses dynamic programming and amortized analysis. It covers:
1) An example of amortized analysis of dynamic tables, where the worst case cost of an insert is O(n) but the amortized cost is O(1).
2) Dynamic programming can be used when a problem breaks into recurring subproblems. Longest common subsequence is given as an example that is solved using dynamic programming in O(mn) time rather than a brute force O(2^m*n) approach.
3) The dynamic programming algorithm for longest common subsequence works by defining a 2D array c where c[i,j] represents the length of the LCS of the first i elements
Average case Analysis of Quicksort
Average case Analysis of QuicksortRajendran Quicksort has worst case running time of Θ(n^2) when the partition is always unbalanced, but average case running time of Θ(n log n). The document derives the average case running time rigorously using a recurrence relation approach. It involves assuming the partition splits the array randomly and solving the recurrence using an inductive hypothesis that the running time is O(n log n).
Np completeness
Np completenessRajendran 1) NP-Completeness refers to problems that are in NP (can be verified in polynomial time) and are as hard as any problem in NP.
2) The first problem proven to be NP-Complete was the Circuit Satisfiability problem, which asks whether there exists an input assignment that makes a Boolean circuit output 1.
3) To prove a problem P is NP-Complete, it must be shown that P is in NP and that any problem in NP can be reduced to P in polynomial time. This establishes P as at least as hard as any problem in NP.
computer languages
computer languagesRajendran The document discusses the differences between low-level machine code used by CPUs and high-level computer languages used by programmers. It explains that programmers write source code in high-level languages, which are then compiled into machine code through a compiler or interpreted line-by-line using an interpreter. Compiled code tends to run faster while interpreted languages typically have more programmer-friendly features. Modern dynamic languages often use a just-in-time compiler to bridge performance gaps.
Ad
Recently uploaded (20)
Capitol Doctoral Presentation -June 2025.pptx
Capitol Doctoral Presentation -June 2025.pptxCapitolTechU Slides from a Capitol Technology University presentation covering doctoral programs offered by the university. All programs are online, and regionally accredited. The presentation covers degree program details, tuition, financial aid and the application process.
Optimization technique in pharmaceutical product development.pptx
Optimization technique in pharmaceutical product development.pptxUrmiPrajapati3 Optimization techniques in pharmaceutical product development
BUSINESS QUIZ PRELIMS | QUIZ CLUB OF PSGCAS | 9 SEPTEMBER 2024
BUSINESS QUIZ PRELIMS | QUIZ CLUB OF PSGCAS | 9 SEPTEMBER 2024Quiz Club of PSG College of Arts & Science THE QUIZ CLUB OF PSGCAS BRINGS T0 YOU A FUN-FILLED, SEAT EDGE BUSINESS QUIZ
DIVE INTO THE PRELIMS OF BIZCOM 2024
QM: GOWTHAM S
BCom (2022-25)
THE QUIZ CLUB OF PSGCAS
Different pricelists for different shops in odoo Point of Sale in Odoo 17
Different pricelists for different shops in odoo Point of Sale in Odoo 17Celine George Price lists are a useful tool for managing the costs of your goods and services. This can assist you in working with other businesses effectively and maximizing your revenues. Additionally, you can provide your customers discounts by using price lists.
Black and White Illustrative Group Project Presentation.pdf (1).pdf
Black and White Illustrative Group Project Presentation.pdf (1).pdfAnnasofiaUrsini mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
Strengthened Senior High School - Landas Tool Kit.pptx
Strengthened Senior High School - Landas Tool Kit.pptxSteffMusniQuiballo Landas Tool Kit is a very helpful guide in guiding the Senior High School students on their SHS academic journey. It will pave the way on what curriculum exits will they choose and fit in.
Energy Balances Of Oecd Countries 2011 Iea Statistics 1st Edition Oecd
Energy Balances Of Oecd Countries 2011 Iea Statistics 1st Edition Oecdrazelitouali Energy Balances Of Oecd Countries 2011 Iea Statistics 1st Edition Oecd
Energy Balances Of Oecd Countries 2011 Iea Statistics 1st Edition Oecd
Energy Balances Of Oecd Countries 2011 Iea Statistics 1st Edition Oecd
SEXUALITY , UNWANTED PREGANCY AND SEXUAL ASSAULT .pptx
SEXUALITY , UNWANTED PREGANCY AND SEXUAL ASSAULT .pptxPoojaSen20 SEXUALITY AND ITS TYPES , UNWANTED PREGANCY AND SEXUAL ASSAULT
Unit 3 Poster Sketches with annotations.pptx
Unit 3 Poster Sketches with annotations.pptxbobby205207 Unit 3 Poster Sketches with annotations.pptx
How to Manage Maintenance Request in Odoo 18
How to Manage Maintenance Request in Odoo 18Celine George Efficient maintenance management is crucial for keeping equipment and work centers running smoothly in any business. Odoo 18 provides a Maintenance module that helps track, schedule, and manage maintenance requests efficiently.
Rai dyansty Chach or Brahamn dynasty, History of Dahir History of Sindh NEP.pptx
Rai dyansty Chach or Brahamn dynasty, History of Dahir History of Sindh NEP.pptxDr. Ravi Shankar Arya Mahila P. G. College, Banaras Hindu University, Varanasi, India. This presentation has been made keeping in mind the students of undergraduate and postgraduate level. To keep the facts in a natural form and to display the material in more detail, the help of various books, websites and online medium has been taken. Whatever medium the material or facts have been taken from, an attempt has been made by the presenter to give their reference at the end.
In the seventh century, the rule of Sindh state was in the hands of Rai dynasty. We know the names of five kings of this dynasty- Rai Divji, Rai Singhras, Rai Sahasi, Rai Sihras II and Rai Sahasi II. During the time of Rai Sihras II, Nimruz of Persia attacked Sindh and killed him. After the return of the Persians, Rai Sahasi II became the king. After killing him, one of his Brahmin ministers named Chach took over the throne. He married the widow of Rai Sahasi and became the ruler of entire Sindh by suppressing the rebellions of the governors.
Analysis of Quantitative Data Parametric and non-parametric tests.pptx
Analysis of Quantitative Data Parametric and non-parametric tests.pptxShrutidhara2 This presentation covers the following points--
Parametric Tests
• Testing the Significance of the Difference between Means
• Analysis of Variance (ANOVA) - One way and Two way
• Analysis of Co-variance (One-way)
Non-Parametric Tests:
• Chi-Square test
• Sign test
• Median test
• Sum of Rank test
• Mann-Whitney U-test
Moreover, it includes a comparison of parametric and non-parametric tests, a comparison of one-way ANOVA, two-way ANOVA, and one-way ANCOVA.
Pests of Rice: Damage, Identification, Life history, and Management.pptx
Pests of Rice: Damage, Identification, Life history, and Management.pptxArshad Shaikh Rice pests can significantly impact crop yield and quality. Major pests include the brown plant hopper (Nilaparvata lugens), which transmits viruses like rice ragged stunt and grassy stunt; the yellow stem borer (Scirpophaga incertulas), whose larvae bore into stems causing deadhearts and whiteheads; and leaf folders (Cnaphalocrocis medinalis), which feed on leaves reducing photosynthetic area. Other pests include rice weevils (Sitophilus oryzae) and gall midges (Orseolia oryzae). Effective management strategies are crucial to minimize losses.
How to Configure Vendor Management in Lunch App of Odoo 18
How to Configure Vendor Management in Lunch App of Odoo 18Celine George The Vendor management in the Lunch app of Odoo 18 is the central hub for managing all aspects of the restaurants or caterers that provide food for your employees.
Gibson "Secrets to Changing Behaviour in Scholarly Communication: A 2025 NISO...
Gibson "Secrets to Changing Behaviour in Scholarly Communication: A 2025 NISO...National Information Standards Organization (NISO) This presentation was provided by Jennifer Gibson of Dryad, during the first session of our 2025 NISO training series "Secrets to Changing Behavior in Scholarly Communications." Session One was held June 5, 2025.
Module 4 Presentation - Enhancing Competencies and Engagement Strategies in Y...
Module 4 Presentation - Enhancing Competencies and Engagement Strategies in Y...GeorgeDiamandis11 Enhancing Competencies and Engagement Strategies in Youth Work
Adam Grant: Transforming Work Culture Through Organizational Psychology
Adam Grant: Transforming Work Culture Through Organizational PsychologyPrachi Shah This presentation explores the groundbreaking work of Adam Grant, renowned organizational psychologist and bestselling author. It highlights his key theories on giving, motivation, leadership, and workplace dynamics that have revolutionized how organizations think about productivity, collaboration, and employee well-being. Ideal for students, HR professionals, and leadership enthusiasts, this deck includes insights from his major works like Give and Take, Originals, and Think Again, along with interactive elements for enhanced engagement.
BUSINESS QUIZ PRELIMS | QUIZ CLUB OF PSGCAS | 9 SEPTEMBER 2024
BUSINESS QUIZ PRELIMS | QUIZ CLUB OF PSGCAS | 9 SEPTEMBER 2024Quiz Club of PSG College of Arts & Science
Rai dyansty Chach or Brahamn dynasty, History of Dahir History of Sindh NEP.pptx
Rai dyansty Chach or Brahamn dynasty, History of Dahir History of Sindh NEP.pptxDr. Ravi Shankar Arya Mahila P. G. College, Banaras Hindu University, Varanasi, India.
Gibson "Secrets to Changing Behaviour in Scholarly Communication: A 2025 NISO...
Gibson "Secrets to Changing Behaviour in Scholarly Communication: A 2025 NISO...National Information Standards Organization (NISO)
StackArray stack3
- 1. Implementation of stack using Array Struct StackRecord { int Capacity; int TopOfStack; ElementType *Array; } #define STACKSIZE 100 Struct StackRecord { int top; ElementType Array[STACKSIZE]; }
- 2. Implementation of stack using Array • Test for empty stack empty (stack *ps) { return (ps → top == -1) }
- 3. Implementation using Array • Pop top element from stack int pop (stack *ps) { int x if (empty (ps)) printf (“%sn”, “stack underflow!”); else { x = ps → array [ps → top]; (ps → top)--; return (x); } }
- 4. Implementation using Array • Push an element onto the stack push (stack *ps, int x) { if (ps → top == STACKSIZE – 1) printf (“%sn”, “stack overflow!”); else { (ps → top)++; ps → items [ps → top] = x; } }
- 5. Variable types of stack elements #define STACKSIZE 100 #define INTGR 1 #define FLT 2 #define STRING 3 struct stackelement { int etype; /* element type */ union { int ival; float fval; char *pval; } element; /* end union */ }
- 6. Variable Types of Stack Elements • To access the top element struct stack s; struct stackelement se; se = s.items [s.top]; switch (se.etype) { case INTGR: printf (“%dn”, se.ival); break; case FLT: printf (“%dn”, se.fval); break; case STRING: printf (“%sn”, se.pval); }
- 7. Variable Types of Stack Elements • To access the top element struct stack s; struct stackelement se; se = s.items [s.top]; switch (se.etype) { case INTGR: printf (“%dn”, se.ival); break; case FLT: printf (“%dn”, se.fval); break; case STRING: printf (“%sn”, se.pval); }