FilesExpand file tree

 master

/

StackArrayList.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

105 lines (90 loc) · 2.37 KB

 master

/

StackArrayList.java

Top

File metadata and controls

• Code
• Blame

105 lines (90 loc) · 2.37 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

package DataStructures.Stacks;

import java.util.ArrayList;

import java.util.EmptyStackException;

/**

* This class implements a Stack using an ArrayList.

*

* <p>A stack is exactly what it sounds like. An element gets added to the top of the stack and only

* the element on the top may be removed.

*

* <p>This is an ArrayList Implementation of a stack, where size is not a problem we can extend the

* stack as much as we want.

*/

public class StackArrayList {

/** Driver Code */

public static void main(String[] args) {

StackArrayList stack = new StackArrayList();

assert stack.isEmpty();

for (int i = 1; i <= 5; ++i) {

stack.push(i);

assert stack.size() == i;

}

assert stack.size() == 5;

assert stack.peek() == 5 && stack.pop() == 5 && stack.peek() == 4;

/* pop elements at the top of this stack one by one */

while (!stack.isEmpty()) {

stack.pop();

}

assert stack.isEmpty();

try {

stack.pop();

assert false; /* this should not happen */

} catch (EmptyStackException e) {

assert true; /* this should happen */

}

}

/** ArrayList representation of the stack */

private ArrayList<Integer> stack;

/** Constructor */

public StackArrayList() {

stack = new ArrayList<>();

}

/**

* Adds value to the end of list which is the top for stack

*

* @param value value to be added

*/

public void push(int value) {

stack.add(value);

}

/**

* Removes the element at the top of this stack and returns

*

* @return Element popped

* @throws EmptyStackException if the stack is empty.

*/

public int pop() {

if (isEmpty()) {

throw new EmptyStackException();

}

/* remove the element on the top of the stack */

return stack.remove(stack.size() - 1);

}

/**

* Test if the stack is empty.

*

* @return {@code true} if this stack is empty, {@code false} otherwise.

*/

public boolean isEmpty() {

return stack.isEmpty();

}

/**

* Return the element at the top of this stack without removing it from the stack.

*

* @return the element at the top of this stack.

*/

public int peek() {

if (isEmpty()) {

throw new EmptyStackException();

}

return stack.get(stack.size() - 1);

}

/**

* Return size of this stack.

*

* @return size of this stack.

*/

public int size() {

return stack.size();

}

}