1. Stacks
Written by J.J. Shepherd

2. Stacks
This data structure works on the principle last in first out (LIFO)
Any kind of pile is a good way to think of a stack
A stack of games
Pile of exams

3. Stacks Stacks can be represented by any simple abstract data structure
Arrays
Linked Lists
There are two main pointers used while working with stacks
Head: Points to the first element in the stack
Tail: Points to the last element in the stack

4. Stacks
There are four methods that are always in any representation of a stack
Push: Adds a new element to the stack before the head
Pop: Removes the element at the head of the stack (IE first element)
Peek: Returns the value of the first element of the stack but does not remove it
Print: Prints all elements in the queue

5. Arrays as Stacks The head is always index 0
The tail is the index of the first element inserted into the stack
Index 1 2 3 4 5 6
Value 7 9 -
Uninitialized
Head
Tail

6. Arrays as Stacks Push adds a new element to stack at the head Index 11 2 3 4 5 6
Value 7 9 -
Uninitialized
Head
Tail

7. Arrays as Stacks First check whether or not the stack is full Index 1
if(tail >= data.length){return;}
T tData = (T)aData;
for(int i = tail;i>0;i--) {
data[i] = data[i-1]; }
data[0] = tData;
tail++;
Index 1 2 3 4 5 6
Value 7 9 -
Head
Tail

8. Arrays as Stacks Starting from the tail shift all values right Index 1
if(tail >= data.length){return;}
for(int i = tail;i>0;i--) {
data[i] = data[i-1]; }
data[0] = (T)aData;
tail++;
Index 1 2 3 4 5 6
Value 7 9 -
Head i
Tail

9. Arrays as Stacks Starting from the tail shift all values right Index 1
if(tail >= data.length){return;}
for(int i = tail;i>0;i--) {
data[i] = data[i-1]; }
data[0] = (T)aData;
tail++;
Index 1 2 3 4 5 6
Value 7 9 -
Head i
Tail

10. Arrays as Stacks Starting from the tail shift all values right Index 1
if(tail >= data.length){return;}
for(int i = tail;i>0;i--) {
data[i] = data[i-1]; }
data[0] = (T)aData;
tail++;
Index 1 2 3 4 5 6
Value 7 9 -
Head i
Tail

11. Arrays as Stacks Starting from the tail shift all values right Index 1
if(tail >= data.length){return;}
for(int i = tail;i>0;i--) {
data[i] = data[i-1]; }
data[0] = (T)aData;
tail++;
Index 1 2 3 4 5 6
Value 7 9 -
Head i
Tail

12. Arrays as Stacks Starting from the tail shift all values right Index 1
if(tail >= data.length){return;}
for(int i = tail;i>0;i--) {
data[i] = data[i-1]; }
data[0] = (T)aData;
tail++;
Index 1 2 3 4 5 6
Value 7 9 -
Head i
Tail

13. Arrays as Stacks Starting from the tail shift all values right Index 1
if(tail >= data.length){return;}
for(int i = tail;i>0;i--) {
data[i] = data[i-1]; }
data[0] = (T)aData;
tail++;
Index 1 2 3 4 5 6
Value 7 9 -
Head i
Tail

14. ETC

15. Arrays as Stacks Starting from the tail shift all values right Index 1
if(tail >= data.length){return;}
for(int i = tail;i>0;i--) {
data[i] = data[i-1]; }
data[0] = (T)aData;
tail++;
Index 1 2 3 4 5 6
Value 7 9 -
Head i
Tail

16. Arrays as Stacks Set the head to the new data Index 1 2 3 4 5 6 Value
if(tail >= data.length){return;}
for(int i = tail;i>0;i--) {
data[i] = data[i-1]; }
data[0] = (T)aData;
tail++;
Index 1 2 3 4 5 6
Value 69 7 9 -
Head
Tail

17. Arrays as Stacks Move the tail forward Index 1 2 3 4 5 6 Value 69 7 9
if(tail >= data.length){return;}
for(int i = tail;i>0;i--) {
data[i] = data[i-1]; }
data[0] = (T)aData;
tail++;
Index 1 2 3 4 5 6
Value 69 7 9 -
Head
Tail

18. Example

19. Arrays as Stacks Pop removes the element at the head and returns it
Index 1 2 3 4 5 6
Value 69 7 9 -
Head
Tail

20. Arrays as Stacks Return null if the array stack is uninitialized Index
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 69 7 9 -
Head
Tail

21. Arrays as Stacks Store the value at the head Index 1 2 3 4 5 6 Value
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 69 7 9 -
retVal 69
Head
Tail

22. Arrays as Stacks Starting from the head shift everything left Index 1
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 69 7 9 -
retVal 69
Head i
Tail

23. Arrays as Stacks Starting from the head shift everything left Index 1
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 7 9 -
retVal 69
Head i
Tail

24. Arrays as Stacks Starting from the head shift everything left Index 1
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 7 9 -
retVal 69
Head i
Tail

25. Arrays as Stacks Starting from the head shift everything left Index 1
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 7 9 -
retVal 69
Head i
Tail

26. Arrays as Stacks Starting from the head shift everything left Index 1
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 7 9 -
retVal 69
Head i
Tail

27. Arrays as Stacks Starting from the head shift everything left Index 1
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 7 9 -
retVal 69
Head i
Tail

28. ETC

29. Arrays as Stacks Starting from the head shift everything left Index 1
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 7 9 -
retVal 69
Head i
Tail

30. Arrays as Stacks Move the tail back Index 1 2 3 4 5 6 Value 7 9 - Head
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 7 9 -
retVal 69
Head
Tail

31. Arrays as Stacks Return the value Index 1 2 3 4 5 6 Value 7 9 - Head
if(data == null){return null;}
T retVal = data[0];
for(int i=0;i<tail-1;i++) {
data[i] = data[i+1]; }
tail--;
return retVal;
Index 1 2 3 4 5 6
Value 7 9 -
retVal 69
Head
Tail

32. Example

33. Stacks with Linked Lists
Hmm…

34. It’s Dumbly
Easy